diff --git a/src/Controls/samples/Controls.Sample/Resources/Raw/HybridSamplePage/scripts/HybridWebView.js b/src/Controls/samples/Controls.Sample/Resources/Raw/HybridSamplePage/scripts/HybridWebView.js
index 706e3ffaaa3b..52d67172af49 100644
--- a/src/Controls/samples/Controls.Sample/Resources/Raw/HybridSamplePage/scripts/HybridWebView.js
+++ b/src/Controls/samples/Controls.Sample/Resources/Raw/HybridSamplePage/scripts/HybridWebView.js
@@ -91,20 +91,49 @@
         }
     },
 
-    "__InvokeJavaScript": function __InvokeJavaScript(taskId, methodName, args) {
-        if (methodName[Symbol.toStringTag] === 'AsyncFunction') {
-            // For async methods, we need to call the method and then trigger the callback when it's done
-            const asyncPromise = methodName(...args);
-            asyncPromise
-                .then(asyncResult => {
-                    window.HybridWebView.__TriggerAsyncCallback(taskId, asyncResult);
-                })
-                .catch(error => console.error(error));
+    "__InvokeJavaScript": async function __InvokeJavaScript(taskId, methodName, args) {
+        try {
+            var result = null;
+            if (methodName[Symbol.toStringTag] === 'AsyncFunction') {
+                result = await methodName(...args);
+            } else {
+                result = methodName(...args);
+            }
+            window.HybridWebView.__TriggerAsyncCallback(taskId, result);
+        } catch (ex) {
+            console.error(ex);
+            window.HybridWebView.__TriggerAsyncFailedCallback(taskId, ex);
+        }
+    },
+
+    "__TriggerAsyncFailedCallback": function __TriggerAsyncCallback(taskId, error) {
+
+        if (!error) {
+            json = {
+                Message: "Unknown error",
+                StackTrace: Error().stack
+            };
+        } else if (error instanceof Error) {
+            json = {
+                Name: error.name,
+                Message: error.message,
+                StackTrace: error.stack
+            };
+        } else if (typeof (error) === 'string') {
+            json = {
+                Message: error,
+                StackTrace: Error().stack
+            };
         } else {
-            // For sync methods, we can call the method and trigger the callback immediately
-            const syncResult = methodName(...args);
-            window.HybridWebView.__TriggerAsyncCallback(taskId, syncResult);
+            json = {
+                Message: JSON.stringify(error),
+                StackTrace: Error().stack
+            };
         }
+
+        json = JSON.stringify(json);
+
+        window.HybridWebView.__SendMessageInternal('__InvokeJavaScriptFailed', taskId + '|' + json);
     },
 
     "__TriggerAsyncCallback": function __TriggerAsyncCallback(taskId, result) {
diff --git a/src/Controls/src/Core/Hosting/AppHostBuilderExtensions.cs b/src/Controls/src/Core/Hosting/AppHostBuilderExtensions.cs
index 500e24eeaf70..6007d702e75f 100644
--- a/src/Controls/src/Core/Hosting/AppHostBuilderExtensions.cs
+++ b/src/Controls/src/Core/Hosting/AppHostBuilderExtensions.cs
@@ -189,6 +189,12 @@ static MauiAppBuilder SetupDefaults(this MauiAppBuilder builder)
 			handlers.AddControlsHandlers();
 		});
 
+		// NOTE: not registered under NativeAOT or TrimMode=Full scenarios
+		if (RuntimeFeature.IsHybridWebViewSupported)
+		{
+			builder.Services.AddScoped<IHybridWebViewTaskManager>(_ => new HybridWebViewTaskManager());
+		}
+
 #if WINDOWS
 		builder.Services.TryAddEnumerable(ServiceDescriptor.Transient<IMauiInitializeService, MauiControlsInitializer>());
 #endif
diff --git a/src/Controls/tests/DeviceTests/Elements/HybridWebView/HybridWebViewTests.cs b/src/Controls/tests/DeviceTests/Elements/HybridWebView/HybridWebViewTests.cs
index c78e24bb5a44..1637ec4b0063 100644
--- a/src/Controls/tests/DeviceTests/Elements/HybridWebView/HybridWebViewTests.cs
+++ b/src/Controls/tests/DeviceTests/Elements/HybridWebView/HybridWebViewTests.cs
@@ -4,6 +4,7 @@
 using System.Runtime.CompilerServices;
 using System.Text.Json.Serialization;
 using System.Threading.Tasks;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Maui.Controls;
 using Microsoft.Maui.Handlers;
 using Microsoft.Maui.Hosting;
@@ -24,6 +25,7 @@ void SetupBuilder()
 				});
 
 				builder.Services.AddHybridWebViewDeveloperTools();
+				builder.Services.AddScoped<IHybridWebViewTaskManager, HybridWebViewTaskManager>();
 			});
 		}
 
@@ -311,6 +313,106 @@ public Task InvokeDotNet(string methodName, string expectedReturnValue) =>
 				Assert.Equal(methodName, invokeJavaScriptTarget.LastMethodCalled);
 			});
 
+		[Theory]
+		[InlineData("")]
+		[InlineData("Async")]
+		public async Task InvokeJavaScriptMethodThatThrowsNumber(string type)
+		{
+#if ANDROID
+			// NOTE: skip this test on older Android devices because it is not currently supported on these versions
+			if (!System.OperatingSystem.IsAndroidVersionAtLeast(24))
+			{
+				return;
+			}
+#endif
+
+			var ex = await RunExceptionTest("EvaluateMeWithParamsThatThrows" + type, 1);
+			Assert.Equal("InvokeJavaScript threw an exception: 777.777", ex.Message);
+			Assert.Equal("777.777", ex.InnerException.Message);
+			Assert.Null(ex.InnerException.Data["JavaScriptErrorName"]);
+			Assert.NotNull(ex.InnerException.StackTrace);
+		}
+
+		[Theory]
+		[InlineData("")]
+		[InlineData("Async")]
+		public async Task InvokeJavaScriptMethodThatThrowsString(string type)
+		{
+#if ANDROID
+			// NOTE: skip this test on older Android devices because it is not currently supported on these versions
+			if (!System.OperatingSystem.IsAndroidVersionAtLeast(24))
+			{
+				return;
+			}
+#endif
+
+			var ex = await RunExceptionTest("EvaluateMeWithParamsThatThrows" + type, 2);
+			Assert.Equal("InvokeJavaScript threw an exception: String: 777.777", ex.Message);
+			Assert.Equal("String: 777.777", ex.InnerException.Message);
+			Assert.Null(ex.InnerException.Data["JavaScriptErrorName"]);
+			Assert.NotNull(ex.InnerException.StackTrace);
+		}
+
+		[Theory]
+		[InlineData("")]
+		[InlineData("Async")]
+		public async Task InvokeJavaScriptMethodThatThrowsError(string type)
+		{
+#if ANDROID
+			// NOTE: skip this test on older Android devices because it is not currently supported on these versions
+			if (!System.OperatingSystem.IsAndroidVersionAtLeast(24))
+			{
+				return;
+			}
+#endif
+
+			var ex = await RunExceptionTest("EvaluateMeWithParamsThatThrows" + type, 3);
+			Assert.Equal("InvokeJavaScript threw an exception: Generic Error: 777.777", ex.Message);
+			Assert.Equal("Generic Error: 777.777", ex.InnerException.Message);
+			Assert.Equal("Error", ex.InnerException.Data["JavaScriptErrorName"]);
+			Assert.NotNull(ex.InnerException.StackTrace);
+		}
+
+		[Theory]
+		[InlineData("")]
+		[InlineData("Async")]
+		public async Task InvokeJavaScriptMethodThatThrowsTypedNumber(string type)
+		{
+#if ANDROID
+			// NOTE: skip this test on older Android devices because it is not currently supported on these versions
+			if (!System.OperatingSystem.IsAndroidVersionAtLeast(24))
+			{
+				return;
+			}
+#endif
+
+			var ex = await RunExceptionTest("EvaluateMeWithParamsThatThrows" + type, 4);
+			Assert.Contains("undefined", ex.Message, StringComparison.OrdinalIgnoreCase);
+			Assert.Contains("undefined", ex.InnerException.Message, StringComparison.OrdinalIgnoreCase);
+			Assert.Equal("TypeError", ex.InnerException.Data["JavaScriptErrorName"]);
+			Assert.NotNull(ex.InnerException.StackTrace);
+		}
+
+		async Task<Exception> RunExceptionTest(string method, int errorType)
+		{
+			Exception exception = null;
+
+			await RunTest(async (hybridWebView) =>
+			{
+				var x = 123.456m;
+				var y = 654.321m;
+
+				exception = await Assert.ThrowsAnyAsync<Exception>(() =>
+					hybridWebView.InvokeJavaScriptAsync<decimal>(
+						method,
+						HybridWebViewTestContext.Default.Decimal,
+						[x, y, errorType],
+						[HybridWebViewTestContext.Default.Decimal, HybridWebViewTestContext.Default.Decimal, HybridWebViewTestContext.Default.Int32]));
+			});
+
+			return exception;
+		}
+
 		Task RunTest(Func<HybridWebView, Task> test) =>
 			RunTest(null, test);
 
@@ -460,6 +562,7 @@ public class ComputationResult
 
 		[JsonSourceGenerationOptions(WriteIndented = true)]
 		[JsonSerializable(typeof(ComputationResult))]
+		[JsonSerializable(typeof(int))]
 		[JsonSerializable(typeof(decimal))]
 		[JsonSerializable(typeof(bool))]
 		[JsonSerializable(typeof(int))]
diff --git a/src/Controls/tests/DeviceTests/MauiProgram.cs b/src/Controls/tests/DeviceTests/MauiProgram.cs
index c9358470187d..61c75be8df00 100644
--- a/src/Controls/tests/DeviceTests/MauiProgram.cs
+++ b/src/Controls/tests/DeviceTests/MauiProgram.cs
@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.Reflection;
 using Microsoft.Maui.Controls;
 using Microsoft.Maui.Hosting;
@@ -9,6 +10,11 @@ namespace Microsoft.Maui.DeviceTests
 {
 	public static class MauiProgram
 	{
+		static MauiProgram()
+		{
+			AppContext.SetSwitch("HybridWebView.InvokeJavaScriptThrowsExceptions", isEnabled: true);
+		}
+
 #if ANDROID
 		public static Android.Content.Context CurrentContext => MauiProgramDefaults.DefaultContext;
 #elif WINDOWS
diff --git a/src/Controls/tests/DeviceTests/Resources/Raw/HybridTestRoot/index.html b/src/Controls/tests/DeviceTests/Resources/Raw/HybridTestRoot/index.html
index 82a1c5a70e41..63c20576e871 100644
--- a/src/Controls/tests/DeviceTests/Resources/Raw/HybridTestRoot/index.html
+++ b/src/Controls/tests/DeviceTests/Resources/Raw/HybridTestRoot/index.html
@@ -6,7 +6,19 @@
     <title></title>
     <link rel="icon" href="data:,">
     <script src="scripts/HybridWebView.js"></script>
+
+    <!-- test helper functions-->
     <script>
+
+        // an async delay helper function
+        function delay(ms) {
+            return new Promise(resolve => setTimeout(resolve, ms));
+        }
+
+    </script>
+
+    <script>
+
         window.addEventListener(
             "HybridWebViewMessageReceived",
             function (e) {
@@ -20,6 +32,11 @@
             return value;
         }
 
+    </script>
+
+    <!-- test cases -->
+    <script>
+
         // test method invoke with simple parameters and simple return value
         // test evaluate javascript to invoke
         function EvaluateMeWithParamsAndReturn(s1, s2) {
@@ -61,6 +78,36 @@
             return jsonData;
         }
 
+        function ThrowAnError(value, errorType) {
+            if (errorType === 1) {                  // throw number
+                throw value;
+            } else if (errorType === 2) {           // throw string
+                throw `String: ${value}`;
+            } else if (errorType === 3) {           // throw Error
+                throw new Error(`Generic Error: ${value}`);
+            } else if (errorType === 4) {           // throw runtime Error
+                undefined.toString();
+            }
+
+            // there was an error throwing an error :-{
+            throw new Error(`Unknown error type: ${errorType}`);
+        }
+
+        // test method invoke with parameters that throws instead of returning correctly
+        function EvaluateMeWithParamsThatThrows(a, b, errorType) {
+            let sum = a + b;
+            ThrowAnError(sum, errorType);
+        }
+
+        // test async method invoke with parameters that throws instead of returning correctly
+        async function EvaluateMeWithParamsThatThrowsAsync(a, b, errorType) {
+            // actually do something sync
+            await delay(10);
+
+            let sum = a + b;
+            ThrowAnError(sum, errorType);
+        }
+
         // test evaluate arbitrary javascript
         window.TestKey = 'test_value';
 
diff --git a/src/Controls/tests/DeviceTests/Resources/Raw/HybridTestRoot/scripts/HybridWebView.js b/src/Controls/tests/DeviceTests/Resources/Raw/HybridTestRoot/scripts/HybridWebView.js
index 706e3ffaaa3b..52d67172af49 100644
--- a/src/Controls/tests/DeviceTests/Resources/Raw/HybridTestRoot/scripts/HybridWebView.js
+++ b/src/Controls/tests/DeviceTests/Resources/Raw/HybridTestRoot/scripts/HybridWebView.js
@@ -91,20 +91,49 @@
         }
     },
 
-    "__InvokeJavaScript": function __InvokeJavaScript(taskId, methodName, args) {
-        if (methodName[Symbol.toStringTag] === 'AsyncFunction') {
-            // For async methods, we need to call the method and then trigger the callback when it's done
-            const asyncPromise = methodName(...args);
-            asyncPromise
-                .then(asyncResult => {
-                    window.HybridWebView.__TriggerAsyncCallback(taskId, asyncResult);
-                })
-                .catch(error => console.error(error));
+    "__InvokeJavaScript": async function __InvokeJavaScript(taskId, methodName, args) {
+        try {
+            var result = null;
+            if (methodName[Symbol.toStringTag] === 'AsyncFunction') {
+                result = await methodName(...args);
+            } else {
+                result = methodName(...args);
+            }
+            window.HybridWebView.__TriggerAsyncCallback(taskId, result);
+        } catch (ex) {
+            console.error(ex);
+            window.HybridWebView.__TriggerAsyncFailedCallback(taskId, ex);
+        }
+    },
+
+    "__TriggerAsyncFailedCallback": function __TriggerAsyncCallback(taskId, error) {
+
+        if (!error) {
+            json = {
+                Message: "Unknown error",
+                StackTrace: Error().stack
+            };
+        } else if (error instanceof Error) {
+            json = {
+                Name: error.name,
+                Message: error.message,
+                StackTrace: error.stack
+            };
+        } else if (typeof (error) === 'string') {
+            json = {
+                Message: error,
+                StackTrace: Error().stack
+            };
         } else {
-            // For sync methods, we can call the method and trigger the callback immediately
-            const syncResult = methodName(...args);
-            window.HybridWebView.__TriggerAsyncCallback(taskId, syncResult);
+            json = {
+                Message: JSON.stringify(error),
+                StackTrace: Error().stack
+            };
         }
+
+        json = JSON.stringify(json);
+
+        window.HybridWebView.__SendMessageInternal('__InvokeJavaScriptFailed', taskId + '|' + json);
     },
 
     "__TriggerAsyncCallback": function __TriggerAsyncCallback(taskId, result) {
diff --git a/src/Core/src/Handlers/HybridWebView/HybridWebViewHandler.cs b/src/Core/src/Handlers/HybridWebView/HybridWebViewHandler.cs
index dbc47653beb6..b0085149dcc6 100644
--- a/src/Core/src/Handlers/HybridWebView/HybridWebViewHandler.cs
+++ b/src/Core/src/Handlers/HybridWebView/HybridWebViewHandler.cs
@@ -37,7 +37,7 @@ namespace Microsoft.Maui.Handlers
 #if !NETSTANDARD
 	[RequiresDynamicCode(DynamicFeatures)]
 #endif
-	public partial class HybridWebViewHandler : IHybridWebViewHandler, IHybridWebViewTaskManager
+	public partial class HybridWebViewHandler : IHybridWebViewHandler
 	{
 		internal const string DynamicFeatures = "HybridWebView uses dynamic System.Text.Json serialization features.";
 		internal const string NotSupportedMessage = DynamicFeatures + " Enable the $(MauiHybridWebViewSupported) property in your .csproj file to use in a trimming unsafe manner.";
@@ -90,22 +90,11 @@ public HybridWebViewHandler(IPropertyMapper? mapper = null, CommandMapper? comma
 
 		internal HybridWebViewDeveloperTools DeveloperTools => MauiContext?.Services.GetService<HybridWebViewDeveloperTools>() ?? new HybridWebViewDeveloperTools();
 
+		private const string InvokeJavaScriptThrowsExceptionsSwitch = "HybridWebView.InvokeJavaScriptThrowsExceptions";
 
-		/// <summary>
-		/// Handler for when the an Async JavaScript task has completed and needs to notify .NET.
-		/// </summary>
-		private void AsyncTaskCompleted(string taskId, string result)
-		{
-			// Look for the callback in the list of pending callbacks
-			if (!string.IsNullOrEmpty(taskId) && _asyncTaskCallbacks.TryGetValue(taskId, out var callback))
-			{
-				// Get the callback and remove it from the list
-				callback.SetResult(result);
-
-				// Remove the callback
-				_asyncTaskCallbacks.TryRemove(taskId, out var _);
-			}
-		}
+		// TODO: .NET 10 flip the default to true for .NET 10
+		private static bool IsInvokeJavaScriptThrowsExceptionsEnabled =>
+			AppContext.TryGetSwitch(InvokeJavaScriptThrowsExceptionsSwitch, out var enabled) && enabled;
 
 		void MessageReceived(string rawMessage)
 		{
@@ -128,6 +117,7 @@ void MessageReceived(string rawMessage)
 
 			switch (messageType)
 			{
+				case "__InvokeJavaScriptFailed":
 				case "__InvokeJavaScriptCompleted":
 					{
 #if !NETSTANDARD2_0
@@ -142,7 +132,29 @@ void MessageReceived(string rawMessage)
 
 						var taskId = messageContent.Substring(0, indexOfPipeInContent);
 						var result = messageContent.Substring(indexOfPipeInContent + 1);
-						AsyncTaskCompleted(taskId, result);
+
+						var taskManager = this.GetRequiredService<IHybridWebViewTaskManager>();
+						if (messageType == "__InvokeJavaScriptFailed")
+						{
+							if (IsInvokeJavaScriptThrowsExceptionsEnabled)
+							{
+								if (string.IsNullOrWhiteSpace(result))
+								{
+									taskManager.SetTaskFailed(taskId, new HybridWebViewInvokeJavaScriptException());
+								}
+								else
+								{
+									var jsError = JsonSerializer.Deserialize(result, HybridWebViewHandlerJsonContext.Default.JSInvokeError);
+									var jsException = new HybridWebViewInvokeJavaScriptException(jsError?.Message, jsError?.Name, jsError?.StackTrace);
+									var ex = new HybridWebViewInvokeJavaScriptException($"InvokeJavaScript threw an exception: {jsException.Message}", jsException);
+									taskManager.SetTaskFailed(taskId, ex);
+								}
+							}
+						}
+						else
+						{
+							taskManager.SetTaskCompleted(taskId, result);
+						}
 					}
 					break;
 				case "__RawMessage":
@@ -243,6 +255,13 @@ private sealed class JSInvokeMethodData
 			public string[]? ParamValues { get; set; }
 		}
 
+		private sealed class JSInvokeError
+		{
+			public string? Name { get; set; }
+			public string? Message { get; set; }
+			public string? StackTrace { get; set; }
+		}
+
 		private sealed class DotNetInvokeResult
 		{
 			public object? Result { get; set; }
@@ -251,6 +270,7 @@ private sealed class DotNetInvokeResult
 
 		[JsonSourceGenerationOptions()]
 		[JsonSerializable(typeof(JSInvokeMethodData))]
+		[JsonSerializable(typeof(JSInvokeError))]
 		private partial class HybridWebViewHandlerJsonContext : JsonSerializerContext
 		{
 		}
@@ -315,17 +335,31 @@ public static async void MapEvaluateJavaScriptAsync(IHybridWebViewHandler handle
 		public static async void MapInvokeJavaScriptAsync(IHybridWebViewHandler handler, IHybridWebView hybridWebView, object? arg)
 		{
 #if PLATFORM && !TIZEN
-			if (arg is not HybridWebViewInvokeJavaScriptRequest invokeJavaScriptRequest ||
-				handler.PlatformView is not MauiHybridWebView hybridPlatformWebView ||
-				handler is not IHybridWebViewTaskManager taskManager)
+			if (arg is not HybridWebViewInvokeJavaScriptRequest invokeJavaScriptRequest)
 			{
 				return;
 			}
 
+			try
+			{
+				var result = await MapInvokeJavaScriptAsyncImpl(handler, hybridWebView, invokeJavaScriptRequest);
+
+				invokeJavaScriptRequest.SetResult(result);
+			}
+			catch (Exception ex)
+			{
+				invokeJavaScriptRequest.SetException(ex);
+			}
+#else
+			await Task.CompletedTask;
+#endif
+		}
+
+		static async Task<object?> MapInvokeJavaScriptAsyncImpl(IHybridWebViewHandler handler, IHybridWebView hybridWebView, HybridWebViewInvokeJavaScriptRequest invokeJavaScriptRequest)
+		{
 			// Create a callback for async JavaScript methods to invoke when they are done
-			var callback = new TaskCompletionSource<string>();
-			var currentInvokeTaskId = $"{taskManager.GetNextInvokeTaskId()}";
-			taskManager.AsyncTaskCallbacks.TryAdd(currentInvokeTaskId, callback);
+			var taskManager = handler.GetRequiredService<IHybridWebViewTaskManager>();
+			var (currentInvokeTaskId, callback) = taskManager.CreateTask();
 
 			var paramsValuesStringArray =
 				invokeJavaScriptRequest.ParamValues == null
@@ -341,18 +375,16 @@ await handler.InvokeAsync(nameof(IHybridWebView.EvaluateJavaScriptAsync),
 
 			if (stringResult is null)
 			{
-				invokeJavaScriptRequest.SetResult(null);
+				return null;
 			}
 			else
 			{
 				var typedResult = JsonSerializer.Deserialize(stringResult, invokeJavaScriptRequest.ReturnTypeJsonTypeInfo);
-				invokeJavaScriptRequest.SetResult(typedResult);
+				return typedResult;
 			}
-#else
-			await Task.CompletedTask;
-#endif
 		}
 
+
 #if PLATFORM && !TIZEN
 		// Copied from WebView.cs
 		internal static string? EscapeJsString(string js)
@@ -419,15 +451,5 @@ await handler.InvokeAsync(nameof(IHybridWebView.EvaluateJavaScriptAsync),
 #if !NETSTANDARD
 		internal static readonly FileExtensionContentTypeProvider ContentTypeProvider = new();
 #endif
-
-		// IHybridWebViewTaskManager implementation
-		ConcurrentDictionary<string, TaskCompletionSource<string>> _asyncTaskCallbacks = new ConcurrentDictionary<string, TaskCompletionSource<string>>();
-		int _asyncInvokeTaskId;
-
-		int IHybridWebViewTaskManager.GetNextInvokeTaskId()
-		{
-			return Interlocked.Increment(ref _asyncInvokeTaskId);
-		}
-		ConcurrentDictionary<string, TaskCompletionSource<string>> IHybridWebViewTaskManager.AsyncTaskCallbacks => _asyncTaskCallbacks;
 	}
 }
diff --git a/src/Core/src/Handlers/HybridWebView/HybridWebViewInvokeJavaScriptException.cs b/src/Core/src/Handlers/HybridWebView/HybridWebViewInvokeJavaScriptException.cs
new file mode 100644
index 000000000000..b9811887d821
--- /dev/null
+++ b/src/Core/src/Handlers/HybridWebView/HybridWebViewInvokeJavaScriptException.cs
@@ -0,0 +1,36 @@
+using System;
+
+namespace Microsoft.Maui.Handlers;
+
+internal class HybridWebViewInvokeJavaScriptException : Exception
+{
+	private readonly string? _stackTrace;
+
+	public HybridWebViewInvokeJavaScriptException()
+		: base()
+	{
+	}
+
+	public HybridWebViewInvokeJavaScriptException(string? message)
+		: base(message)
+	{
+	}
+
+	public HybridWebViewInvokeJavaScriptException(string? message, Exception? innerException)
+		: base(message, innerException)
+	{
+	}
+
+	public HybridWebViewInvokeJavaScriptException(string? message, string? name, string? stackTrace)
+		: base(message)
+	{
+		if (!string.IsNullOrWhiteSpace(name))
+		{
+			Data["JavaScriptErrorName"] = name;
+		}
+
+		_stackTrace = stackTrace;
+	}
+
+	public override string? StackTrace => _stackTrace ?? base.StackTrace;
+}
diff --git a/src/Core/src/Handlers/HybridWebView/HybridWebViewTask.cs b/src/Core/src/Handlers/HybridWebView/HybridWebViewTask.cs
new file mode 100644
index 000000000000..f7cf545d3a4b
--- /dev/null
+++ b/src/Core/src/Handlers/HybridWebView/HybridWebViewTask.cs
@@ -0,0 +1,5 @@
+using System.Threading.Tasks;
+
+namespace Microsoft.Maui.Handlers;
+
+internal record struct HybridWebViewTask(string TaskId, TaskCompletionSource<string?> TaskCompletionSource);
diff --git a/src/Core/src/Handlers/HybridWebView/HybridWebViewTaskManager.cs b/src/Core/src/Handlers/HybridWebView/HybridWebViewTaskManager.cs
new file mode 100644
index 000000000000..be2572716bdf
--- /dev/null
+++ b/src/Core/src/Handlers/HybridWebView/HybridWebViewTaskManager.cs
@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Concurrent;
+using System.Globalization;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Microsoft.Maui.Handlers;
+
+internal class HybridWebViewTaskManager : IHybridWebViewTaskManager
+{
+	private int _lastTaskId;
+	private readonly ConcurrentDictionary<string, TaskCompletionSource<string?>> _asyncTaskCallbacks = new();
+
+	public HybridWebViewTask CreateTask()
+	{
+		var taskId = Interlocked.Increment(ref _lastTaskId);
+		var taskIdString = taskId.ToString("0", CultureInfo.InvariantCulture);
+
+		var tcs = new TaskCompletionSource<string?>();
+
+		if (!_asyncTaskCallbacks.TryAdd(taskIdString, tcs))
+		{
+			throw new InvalidOperationException($"Unable to add a new task with new ID {taskIdString} to the task manager.");
+		}
+
+		return new(taskIdString, tcs);
+	}
+
+	public void SetTaskCompleted(string taskId, string result)
+	{
+		if (_asyncTaskCallbacks.TryRemove(taskId, out var callback))
+		{
+			callback.SetResult(result);
+		}
+	}
+
+	public void SetTaskFailed(string taskId, Exception exception)
+	{
+		if (_asyncTaskCallbacks.TryRemove(taskId, out var callback))
+		{
+			callback.SetException(exception);
+		}
+	}
+}
diff --git a/src/Core/src/Handlers/HybridWebView/IHybridWebViewTaskManager.cs b/src/Core/src/Handlers/HybridWebView/IHybridWebViewTaskManager.cs
index 5045ec26450b..13f0de6603ea 100644
--- a/src/Core/src/Handlers/HybridWebView/IHybridWebViewTaskManager.cs
+++ b/src/Core/src/Handlers/HybridWebView/IHybridWebViewTaskManager.cs
@@ -1,11 +1,12 @@
-using System.Collections.Concurrent;
-using System.Threading.Tasks;
+using System;
 
-namespace Microsoft.Maui.Handlers
+namespace Microsoft.Maui.Handlers;
+
+internal interface IHybridWebViewTaskManager
 {
-	internal interface IHybridWebViewTaskManager
-	{
-		int GetNextInvokeTaskId();
-		ConcurrentDictionary<string, TaskCompletionSource<string>> AsyncTaskCallbacks { get; }
-	}
+	HybridWebViewTask CreateTask();
+
+	void SetTaskCompleted(string taskId, string result);
+
+	void SetTaskFailed(string taskId, Exception exception);
 }