diff --git a/src/BlazorUI/Bit.BlazorUI.Extras/Components/AppShell/BitAppShellJsRuntimeExtensions.cs b/src/BlazorUI/Bit.BlazorUI.Extras/Components/AppShell/BitAppShellJsRuntimeExtensions.cs
index 6b9bf75064..e14d0a851e 100644
--- a/src/BlazorUI/Bit.BlazorUI.Extras/Components/AppShell/BitAppShellJsRuntimeExtensions.cs
+++ b/src/BlazorUI/Bit.BlazorUI.Extras/Components/AppShell/BitAppShellJsRuntimeExtensions.cs
@@ -6,21 +6,21 @@ internal static class BitAppShellJsRuntimeExtensions
 {
     internal static ValueTask BitAppShellInitScroll(this IJSRuntime jsRuntime, ElementReference container, string url)
     {
-        return jsRuntime.InvokeVoid("BitBlazorUI.AppShell.initScroll", container, url);
+        return jsRuntime.FastInvokeVoid("BitBlazorUI.AppShell.initScroll", container, url);
     }
 
     internal static ValueTask BitAppShellLocationChangedScroll(this IJSRuntime jsRuntime, string url)
     {
-        return jsRuntime.InvokeVoid("BitBlazorUI.AppShell.locationChangedScroll", url);
+        return jsRuntime.FastInvokeVoid("BitBlazorUI.AppShell.locationChangedScroll", url);
     }
 
     internal static ValueTask BitAppShellAfterRenderScroll(this IJSRuntime jsRuntime, string url)
     {
-        return jsRuntime.InvokeVoid("BitBlazorUI.AppShell.afterRenderScroll", url);
+        return jsRuntime.FastInvokeVoid("BitBlazorUI.AppShell.afterRenderScroll", url);
     }
 
     internal static ValueTask BitAppShellDisposeScroll(this IJSRuntime jsRuntime)
     {
-        return jsRuntime.InvokeVoid("BitBlazorUI.AppShell.disposeScroll");
+        return jsRuntime.FastInvokeVoid("BitBlazorUI.AppShell.disposeScroll");
     }
 }
diff --git a/src/BlazorUI/Bit.BlazorUI.Extras/Components/Chart/BitChart.razor.cs b/src/BlazorUI/Bit.BlazorUI.Extras/Components/Chart/BitChart.razor.cs
index d3d809f266..f26509ea41 100644
--- a/src/BlazorUI/Bit.BlazorUI.Extras/Components/Chart/BitChart.razor.cs
+++ b/src/BlazorUI/Bit.BlazorUI.Extras/Components/Chart/BitChart.razor.cs
@@ -27,9 +27,13 @@ public partial class BitChart : IAsyncDisposable
     [Parameter] public int? Height { get; set; }
 
     /// <summary>
-    /// This event is fired when the chart has been setup through interop and
-    /// the JavaScript chart object is available. Use this callback if you need to setup
-    /// custom JavaScript options or register plugins.
+    /// This event is fired once, on the component's first render, after the interop setup attempt has run.
+    /// It fires unconditionally - regardless of whether <see cref="Config"/> was set or the chart setup
+    /// actually succeeded - so treat it as a "first render completed" signal rather than a guarantee that the
+    /// JavaScript chart object is available. Note that the chart setup (<c>BitChartJsSetupChart</c>) has
+    /// already been attempted by the time this callback fires, so it is not a suitable place to register
+    /// plugins or custom JavaScript options that need to be present during setup. Any such registration must
+    /// happen before first render (i.e. before <see cref="Config"/> is assigned).
     /// </summary>
     [Parameter] public EventCallback SetupCompletedCallback { get; set; }
 
@@ -147,13 +151,21 @@ protected override async Task OnAfterRenderAsync(bool firstRender)
                 await _js.BitChartJsSetupChart(Config);
             }
 
+            // Always signal completion on first render, matching the long-standing behavior: consumers may
+            // rely on SetupCompletedCallback firing once the component has rendered regardless of whether the
+            // chart setup itself succeeded (e.g. when Config is still null, or when interop was unavailable
+            // and the result was swallowed on the WebAssembly fast path).
             await SetupCompletedCallback.InvokeAsync(this);
+
             return;
         }
 
         if (Config is not null)
         {
-            await _js.BitChartJsSetupChart(Config);
+            // Re-runs setup after a Config change. The readiness result is intentionally discarded here:
+            // SetupCompletedCallback is raised only once, on first render, so subsequent re-setups don't
+            // re-signal readiness.
+            _ = await _js.BitChartJsSetupChart(Config);
         }
     }
 
diff --git a/src/BlazorUI/Bit.BlazorUI.Extras/Components/Chart/BitChart.ts b/src/BlazorUI/Bit.BlazorUI.Extras/Components/Chart/BitChart.ts
index f4eb9ac8e9..e868fecb69 100644
--- a/src/BlazorUI/Bit.BlazorUI.Extras/Components/Chart/BitChart.ts
+++ b/src/BlazorUI/Bit.BlazorUI.Extras/Components/Chart/BitChart.ts
@@ -54,7 +54,7 @@ namespace BitBlazorUI {
 
         public static updateChart(config: BitChartConfiguration): boolean {
             if (!BitChart._bitCharts.has(config.canvasId))
-                throw `Could not find a chart with the given id. ${config.canvasId}`;
+                throw new Error(`Could not find a chart with the given id: ${config.canvasId}`);
 
             let myChart = BitChart._bitCharts.get(config.canvasId);
 
diff --git a/src/BlazorUI/Bit.BlazorUI.Extras/Components/Chart/JsInterop/BitChartJsInterop.cs b/src/BlazorUI/Bit.BlazorUI.Extras/Components/Chart/JsInterop/BitChartJsInterop.cs
index 391b21674f..c591f6edb0 100644
--- a/src/BlazorUI/Bit.BlazorUI.Extras/Components/Chart/JsInterop/BitChartJsInterop.cs
+++ b/src/BlazorUI/Bit.BlazorUI.Extras/Components/Chart/JsInterop/BitChartJsInterop.cs
@@ -22,7 +22,7 @@ internal static class BitChartJsInterop
 
     public static ValueTask BitChartJsRemoveChart(this IJSRuntime jsRuntime, string? canvasId)
     {
-        return jsRuntime.InvokeVoid("BitBlazorUI.BitChart.removeChart", canvasId);
+        return jsRuntime.FastInvokeVoid("BitBlazorUI.BitChart.removeChart", canvasId);
     }
 
     /// <summary>
@@ -30,12 +30,16 @@ public static ValueTask BitChartJsRemoveChart(this IJSRuntime jsRuntime, string?
     /// </summary>
     /// <param name="jsRuntime"></param>
     /// <param name="chartConfig">The config for the new chart.</param>
-    /// <returns></returns>
-    public static ValueTask<bool> BitChartJsSetupChart(this IJSRuntime jsRuntime, BitChartConfigBase chartConfig)
+    /// <returns>
+    /// <see langword="true"/> when the chart was set up (or updated in place when one with the same id already existed).
+    /// The underlying <c>BitBlazorUI.BitChart.setupChart</c> throws on failure rather than returning <see langword="false"/>;
+    /// on the in-process (WASM) fast path that error can be swallowed, in which case the result is <see langword="null"/>.
+    /// </returns>
+    public static ValueTask<bool?> BitChartJsSetupChart(this IJSRuntime jsRuntime, BitChartConfigBase chartConfig)
     {
         var dynParam = StripNulls(chartConfig);
         Dictionary<string, object> param = ConvertExpandoObjectToDictionary(dynParam!);
-        return jsRuntime.Invoke<bool>("BitBlazorUI.BitChart.setupChart", param);
+        return jsRuntime.FastInvoke<bool?>("BitBlazorUI.BitChart.setupChart", param);
     }
 
     /// <summary>
@@ -43,12 +47,16 @@ public static ValueTask<bool> BitChartJsSetupChart(this IJSRuntime jsRuntime, Bi
     /// </summary>
     /// <param name="jsRuntime"></param>
     /// <param name="chartConfig">The updated config of the chart you want to update.</param>
-    /// <returns></returns>
-    public static ValueTask<bool> BitChartJsUpdateChart(this IJSRuntime jsRuntime, BitChartConfigBase chartConfig)
+    /// <returns>
+    /// <see langword="true"/> when the chart was updated. The underlying <c>BitBlazorUI.BitChart.updateChart</c> throws
+    /// when no chart with the given id exists rather than returning <see langword="false"/>; on the in-process (WASM)
+    /// fast path that error can be swallowed, in which case the result is <see langword="null"/>.
+    /// </returns>
+    public static ValueTask<bool?> BitChartJsUpdateChart(this IJSRuntime jsRuntime, BitChartConfigBase chartConfig)
     {
         var dynParam = StripNulls(chartConfig);
         var param = ConvertExpandoObjectToDictionary(dynParam!);
-        return jsRuntime.Invoke<bool>("BitBlazorUI.BitChart.updateChart", param);
+        return jsRuntime.FastInvoke<bool?>("BitBlazorUI.BitChart.updateChart", param);
     }
 
 
diff --git a/src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/BitDataGrid.ts b/src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/BitDataGrid.ts
index 1b8c80517a..8e953c9c0d 100644
--- a/src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/BitDataGrid.ts
+++ b/src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/BitDataGrid.ts
@@ -44,7 +44,13 @@ namespace BitBlazorUI {
                     colOptions.style.transform = `translateX(${applyOffset}px)`;
                 }
 
-                colOptions.scrollIntoViewIfNeeded();
+                if (typeof colOptions.scrollIntoViewIfNeeded === 'function') {
+                    colOptions.scrollIntoViewIfNeeded();
+                } else {
+                    // Non-standard scrollIntoViewIfNeeded is unavailable in some browsers; fall back to the
+                    // standard scrollIntoView with nearest alignment so the popup still stays in view.
+                    colOptions.scrollIntoView({ block: 'nearest', inline: 'nearest' });
+                }
 
                 const autoFocusElem = colOptions.querySelector('[autofocus]');
                 if (autoFocusElem) {
diff --git a/src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/BitDataGridJsRuntimeExtensions.cs b/src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/BitDataGridJsRuntimeExtensions.cs
index 684418b1a8..a052ebf4b0 100644
--- a/src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/BitDataGridJsRuntimeExtensions.cs
+++ b/src/BlazorUI/Bit.BlazorUI.Extras/Components/DataGrid/BitDataGridJsRuntimeExtensions.cs
@@ -2,11 +2,22 @@
 
 internal static class BitDataGridJsRuntimeExtensions
 {
-    public static async ValueTask<IJSObjectReference> BitDataGridInit(this IJSRuntime jsRuntime, ElementReference tableElement)
+    // FastInvoke returns default (null) when the runtime can't service interop or a JSON/JS interop
+    // error is swallowed on the in-process (WASM) path. Callers must null-check before using the
+    // reference; a null result means DataGrid JS hooks were not initialized.
+    public static async ValueTask<IJSObjectReference?> BitDataGridInit(this IJSRuntime jsRuntime, ElementReference tableElement)
     {
-        return await jsRuntime.Invoke<IJSObjectReference>("BitBlazorUI.DataGrid.init", tableElement);
+        const string identifier = "BitBlazorUI.DataGrid.init";
+        var result = await jsRuntime.FastInvoke<IJSObjectReference>(identifier, tableElement);
+        return jsRuntime.ReportIfUnexpectedNull(identifier, result);
     }
 
+    // This is a fire-and-forget call from OnAfterRenderAsync that runs DOM-heavy positioning logic
+    // (getBoundingClientRect, scrollIntoViewIfNeeded, focus). It deliberately uses the regular async
+    // invocation rather than FastInvokeVoid: on WebAssembly FastInvokeVoid runs synchronously and can
+    // alter Promise/ordering and error-propagation semantics, so we use the async Invoke pattern to keep
+    // any JS-side failure (e.g. scrollIntoViewIfNeeded being unsupported) contained within the returned
+    // task instead of letting it escape synchronously into the render loop.
     public static async ValueTask BitDataGridCheckColumnOptionsPosition(this IJSRuntime jsRuntime, ElementReference tableElement)
     {
         await jsRuntime.InvokeVoid("BitBlazorUI.DataGrid.checkColumnOptionsPosition", tableElement);
diff --git a/src/BlazorUI/Bit.BlazorUI.Extras/Components/InfiniteScrolling/BitInfiniteScrolling.ts b/src/BlazorUI/Bit.BlazorUI.Extras/Components/InfiniteScrolling/BitInfiniteScrolling.ts
index 417bb8541f..a3e940dc88 100644
--- a/src/BlazorUI/Bit.BlazorUI.Extras/Components/InfiniteScrolling/BitInfiniteScrolling.ts
+++ b/src/BlazorUI/Bit.BlazorUI.Extras/Components/InfiniteScrolling/BitInfiniteScrolling.ts
@@ -23,7 +23,13 @@ namespace BitBlazorUI {
                 for (const entry of entries) {
                     if (entry.isIntersecting) {
                         observer.unobserve(lastElement);
-                        await dotnetObj.invokeMethodAsync("Load");
+                        try {
+                            await dotnetObj.invokeMethodAsync("Load");
+                        } catch (e) {
+                            // Swallow the rejection so it doesn't surface as an unhandled promise rejection.
+                            // The .NET object can already be disposed (component torn down) or the circuit gone.
+                            console.error('BitBlazorUI.InfiniteScrolling.setup:', e);
+                        }
                     }
                 }
             }, {
diff --git a/src/BlazorUI/Bit.BlazorUI.Extras/Components/InfiniteScrolling/BitInfiniteScrollingJsRuntimeExtensions.cs b/src/BlazorUI/Bit.BlazorUI.Extras/Components/InfiniteScrolling/BitInfiniteScrollingJsRuntimeExtensions.cs
index ecfcd131e9..0557a3c4fe 100644
--- a/src/BlazorUI/Bit.BlazorUI.Extras/Components/InfiniteScrolling/BitInfiniteScrollingJsRuntimeExtensions.cs
+++ b/src/BlazorUI/Bit.BlazorUI.Extras/Components/InfiniteScrolling/BitInfiniteScrollingJsRuntimeExtensions.cs
@@ -10,18 +10,18 @@ public static ValueTask BitInfiniteScrollingSetup<T>(this IJSRuntime jsRuntime,
                                                               decimal? threshold,
                                                               DotNetObjectReference<BitInfiniteScrolling<T>> dotnetObj)
     {
-        return jsRuntime.InvokeVoid("BitBlazorUI.InfiniteScrolling.setup", id, scrollerSelector, rootElement, lastElement, threshold, dotnetObj);
+        return jsRuntime.FastInvokeVoid("BitBlazorUI.InfiniteScrolling.setup", id, scrollerSelector, rootElement, lastElement, threshold, dotnetObj);
     }
 
     public static ValueTask BitInfiniteScrollingReobserve(this IJSRuntime jsRuntime,
                                                                string id,
                                                                ElementReference lastElement)
     {
-        return jsRuntime.InvokeVoid("BitBlazorUI.InfiniteScrolling.reobserve", id, lastElement);
+        return jsRuntime.FastInvokeVoid("BitBlazorUI.InfiniteScrolling.reobserve", id, lastElement);
     }
 
     public static ValueTask BitInfiniteScrollingDispose(this IJSRuntime jsRuntime, string id)
     {
-        return jsRuntime.InvokeVoid("BitBlazorUI.InfiniteScrolling.dispose", id);
+        return jsRuntime.FastInvokeVoid("BitBlazorUI.InfiniteScrolling.dispose", id);
     }
 }
diff --git a/src/BlazorUI/Bit.BlazorUI.Extras/Components/PdfReader/BitPdfReaderJsRuntimeExtensions.cs b/src/BlazorUI/Bit.BlazorUI.Extras/Components/PdfReader/BitPdfReaderJsRuntimeExtensions.cs
index f1e7c1eff2..d489b10eaa 100644
--- a/src/BlazorUI/Bit.BlazorUI.Extras/Components/PdfReader/BitPdfReaderJsRuntimeExtensions.cs
+++ b/src/BlazorUI/Bit.BlazorUI.Extras/Components/PdfReader/BitPdfReaderJsRuntimeExtensions.cs
@@ -9,16 +9,21 @@ public static ValueTask<int> BitPdfReaderSetup(this IJSRuntime jsRuntime, BitPdf
 
     public static ValueTask BitPdfReaderRenderPage(this IJSRuntime jsRuntime, string id, int pageNumber)
     {
+        // The JS renderPage is async (awaits pdf.js page rendering). FastInvoke would use the
+        // synchronous in-process path in WASM, discarding the returned Promise (fire-and-forget),
+        // so callers would proceed/raise events before rendering completes and errors would be lost.
         return jsRuntime.InvokeVoid("BitBlazorUI.PdfReader.renderPage", id, pageNumber);
     }
 
     public static ValueTask BitPdfReaderRefreshPage(this IJSRuntime jsRuntime, BitPdfReaderConfig config, int pageNumber)
     {
+        // The JS refreshPage is async (awaits renderPage). See BitPdfReaderRenderPage for why
+        // the asynchronous invocation must be used instead of the synchronous fast-invoke.
         return jsRuntime.InvokeVoid("BitBlazorUI.PdfReader.refreshPage", config, pageNumber);
     }
 
     public static ValueTask BitPdfReaderDispose(this IJSRuntime jsRuntime, string id)
     {
-        return jsRuntime.InvokeVoid("BitBlazorUI.PdfReader.dispose", id);
+        return jsRuntime.FastInvokeVoid("BitBlazorUI.PdfReader.dispose", id);
     }
 }
diff --git a/src/BlazorUI/Bit.BlazorUI.Extras/Components/PhoneInput/BitPhoneInput.razor.cs b/src/BlazorUI/Bit.BlazorUI.Extras/Components/PhoneInput/BitPhoneInput.razor.cs
index 7f4cdf04ec..16408186b7 100644
--- a/src/BlazorUI/Bit.BlazorUI.Extras/Components/PhoneInput/BitPhoneInput.razor.cs
+++ b/src/BlazorUI/Bit.BlazorUI.Extras/Components/PhoneInput/BitPhoneInput.razor.cs
@@ -367,7 +367,7 @@ protected override async Task OnAfterRenderAsync(bool firstRender)
         if (_isOpen && _activeIndex >= 0 && _activeIndex != _lastScrolledIndex)
         {
             _lastScrolledIndex = _activeIndex;
-            await _js.BitExtrasScrollOptionIntoView(GetOptionId(_activeIndex));
+            await _js.BitExtrasScrollElementIntoView(GetOptionId(_activeIndex));
         }
 
         await base.OnAfterRenderAsync(firstRender);
diff --git a/src/BlazorUI/Bit.BlazorUI.Extras/Components/ProModal/BitProModal.razor.cs b/src/BlazorUI/Bit.BlazorUI.Extras/Components/ProModal/BitProModal.razor.cs
index 3129bb4e8c..37a0ee7d15 100644
--- a/src/BlazorUI/Bit.BlazorUI.Extras/Components/ProModal/BitProModal.razor.cs
+++ b/src/BlazorUI/Bit.BlazorUI.Extras/Components/ProModal/BitProModal.razor.cs
@@ -440,11 +440,11 @@ private async Task ToggleScroll(bool isOpen)
 
         if (_scrollerElementOnOpen.HasValue)
         {
-            _offsetTop = await _js.BitUtilsToggleOverflow(_scrollerElementOnOpen.Value, isOpen);
+            _offsetTop = await _js.BitUtilsToggleOverflow(_scrollerElementOnOpen.Value, isOpen) ?? 0;
         }
         else
         {
-            _offsetTop = await _js.BitUtilsToggleOverflow(_scrollerSelectorOnOpen ?? "body", isOpen);
+            _offsetTop = await _js.BitUtilsToggleOverflow(_scrollerSelectorOnOpen ?? "body", isOpen) ?? 0;
         }
     }
 
diff --git a/src/BlazorUI/Bit.BlazorUI.Extras/Extensions/JsInterop/ExtrasJsRuntimeExtensions.cs b/src/BlazorUI/Bit.BlazorUI.Extras/Extensions/JsInterop/ExtrasJsRuntimeExtensions.cs
index 68a2da41d3..4f78091e41 100644
--- a/src/BlazorUI/Bit.BlazorUI.Extras/Extensions/JsInterop/ExtrasJsRuntimeExtensions.cs
+++ b/src/BlazorUI/Bit.BlazorUI.Extras/Extensions/JsInterop/ExtrasJsRuntimeExtensions.cs
@@ -4,17 +4,17 @@ internal static class ExtrasJsRuntimeExtensions
 {
     internal static ValueTask BitExtrasApplyRootClasses(this IJSRuntime jsRuntime, List<string> cssClasses, Dictionary<string, string> cssVariables)
     {
-        return jsRuntime.InvokeVoid("BitBlazorUI.Extras.applyRootClasses", cssClasses, cssVariables);
+        return jsRuntime.FastInvokeVoid("BitBlazorUI.Extras.applyRootClasses", cssClasses, cssVariables);
     }
 
     internal static ValueTask BitExtrasGoToTop(this IJSRuntime jsRuntime, ElementReference element, BitScrollBehavior? behavior = null)
     {
-        return jsRuntime.InvokeVoid("BitBlazorUI.Extras.goToTop", element, behavior?.ToString().ToLowerInvariant());
+        return jsRuntime.FastInvokeVoid("BitBlazorUI.Extras.goToTop", element, behavior?.ToString().ToLowerInvariant());
     }
 
     internal static ValueTask BitExtrasScrollBy(this IJSRuntime jsRuntime, ElementReference element, decimal x, decimal y)
     {
-        return jsRuntime.InvokeVoid("BitBlazorUI.Extras.scrollBy", element, x, y);
+        return jsRuntime.FastInvokeVoid("BitBlazorUI.Extras.scrollBy", element, x, y);
     }
 
     public static ValueTask BitExtrasInitScripts(this IJSRuntime jsRuntime, IEnumerable<string> scripts, bool isModule = false)
@@ -29,16 +29,16 @@ public static ValueTask BitExtrasInitStylesheets(this IJSRuntime jsRuntime, IEnu
 
     internal static ValueTask BitExtrasSetPreventKeys(this IJSRuntime jsRuntime, ElementReference element, string[] keys)
     {
-        return jsRuntime.InvokeVoid("BitBlazorUI.Extras.setPreventKeys", element, keys);
+        return jsRuntime.FastInvokeVoid("BitBlazorUI.Extras.setPreventKeys", element, keys);
     }
 
     internal static ValueTask BitExtrasDisposePreventKeys(this IJSRuntime jsRuntime, ElementReference element)
     {
-        return jsRuntime.InvokeVoid("BitBlazorUI.Extras.disposePreventKeys", element);
+        return jsRuntime.FastInvokeVoid("BitBlazorUI.Extras.disposePreventKeys", element);
     }
 
-    internal static ValueTask BitExtrasScrollOptionIntoView(this IJSRuntime jsRuntime, string optionId)
+    internal static ValueTask BitExtrasScrollElementIntoView(this IJSRuntime jsRuntime, string elementId)
     {
-        return jsRuntime.InvokeVoid("BitBlazorUI.Extras.scrollOptionIntoView", optionId);
+        return jsRuntime.FastInvokeVoid("BitBlazorUI.Extras.scrollElementIntoView", elementId);
     }
 }
diff --git a/src/BlazorUI/Bit.BlazorUI.Extras/Scripts/Extras.ts b/src/BlazorUI/Bit.BlazorUI.Extras/Scripts/Extras.ts
index f5f215e628..7d14399878 100644
--- a/src/BlazorUI/Bit.BlazorUI.Extras/Scripts/Extras.ts
+++ b/src/BlazorUI/Bit.BlazorUI.Extras/Scripts/Extras.ts
@@ -18,7 +18,7 @@ namespace BitBlazorUI {
 
             element.scrollBy(x, y);
         }
-
+        
         // Attaches (or updates) a deterministic keydown listener that calls preventDefault
         // for the provided keys. Unlike Blazor's `@onkeydown:preventDefault` binding -- whose
         // value is evaluated at render time and therefore only applies to the *next* key event
@@ -52,93 +52,299 @@ namespace BitBlazorUI {
             delete el.bitPreventKeys;
         }
 
-        // Scrolls the option element into the visible area of its scroll container using
+        // Scrolls the element into the visible area of its scroll container using
         // 'nearest' so keyboard navigation keeps the active item on screen with minimal movement.
-        public static scrollOptionIntoView(optionId: string) {
-            if (!optionId) return;
+        public static scrollElementIntoView(elementId: string) {
+            if (!elementId) return;
 
-            const element = document.getElementById(optionId);
+            const element = document.getElementById(elementId);
             if (!element) return;
 
             try {
                 element.scrollIntoView({ block: 'nearest', inline: 'nearest' });
-            } catch (e) { console.error('BitBlazorUI.Extras.scrollOptionIntoView:', e); }
+            } catch (e) { console.error('BitBlazorUI.Extras.scrollElementIntoView:', e); }
         }
-
-        private static _initScriptsPromises: { [key: string]: Promise<unknown> } = {};
+        
         public static async initScripts(scripts: string[], isModule: boolean) {
-            const key = scripts.join('|');
-            if (Extras._initScriptsPromises[key] !== undefined) {
-                return Extras._initScriptsPromises[key];
+            // Resolve only when every script has actually executed. Loading is tracked per-url so that
+            // concurrent callers (e.g. several components, or a re-mount) await the same execution instead
+            // of a second caller seeing the <script> tag in the DOM and assuming it is already usable.
+            //
+            // Classic (non-module) scripts share a single global scope and execute in load order, not
+            // insertion order, so loading them concurrently can run a dependent before its dependency
+            // (BitChart's DateAdapterScripts, BitRichTextEditor's quill module scripts). To preserve the
+            // guaranteed execution order those callers rely on, classic scripts are awaited sequentially.
+            // ES modules resolve their own dependencies via import, so they are loaded concurrently.
+            if (isModule) {
+                const promises: Promise<void>[] = [];
+                for (const s of scripts ?? []) {
+                    promises.push(Extras.loadResource('script', s, true));
+                }
+                const results = await Promise.allSettled(promises);
+                const failure = results.find((r): r is PromiseRejectedResult => r.status === 'rejected');
+                if (failure) {
+                    throw failure.reason;
+                }
+                return;
             }
 
-            const allScripts = Array.from(document.scripts).map(s => s.src);
-            const notAddedScripts = scripts.filter(s => !allScripts.find(as => as.includes(s)));
+            for (const s of scripts ?? []) {
+                await Extras.loadResource('script', s, false);
+            }
+        }
 
-            if (notAddedScripts.length == 0) return Promise.resolve();
+        public static async initStylesheets(stylesheets: string[]) {
+            // Resolve only when every stylesheet has actually loaded. Loading is tracked per-url so that
+            // concurrent callers (e.g. several components, or a re-mount) await the same load instead
+            // of a second caller seeing the <link> tag in the DOM and assuming it is already usable.
+            // Kick off in array order (each call appends its <link> synchronously, preserving cascade
+            // precedence) but await all settlements so one failure does not suppress the rest.
+            const promises: Promise<void>[] = [];
+            for (const s of stylesheets ?? []) {
+                promises.push(Extras.loadResource('stylesheet', s));
+            }
+            const results = await Promise.allSettled(promises);
+            const failure = results.find((r): r is PromiseRejectedResult => r.status === 'rejected');
+            if (failure) {
+                throw failure.reason;
+            }
+        }
 
-            const promise = new Promise(async (res: any, rej: any) => {
-                try {
-                    await Promise.all(notAddedScripts.map(addScript));
-                    res();
-                } catch (e: any) {
-                    rej(e);
-                }
-            });
+        private static _scriptPromises: { [url: string]: Promise<void> } = {};
+        private static _stylesheetPromises: { [url: string]: Promise<void> } = {};
 
-            Extras._initScriptsPromises[key] = promise;
-            return promise;
+        private static normalizeResourceUrl(url: string): string {
+            try { return new URL(url, document.baseURI).href; }
+            catch { return url; }
+        }
 
-            async function addScript(url: string) {
-                return new Promise((res, rej) => {
-                    const script = document.createElement('script');
-                    script.src = url;
-                    if (isModule) {
-                        script.type = 'module';
-                    }
-                    script.onload = res;
-                    script.onerror = rej;
-                    document.body.appendChild(script);
-                })
-            }
+        private static isHostStylesheetApplied(link: HTMLLinkElement): boolean {
+            // After the document finishes loading, a stylesheet link with no .sheet failed to apply (404, CORS, etc.).
+            return link.sheet !== null;
         }
 
-        private static _initStylesheetsPromises: { [key: string]: Promise<unknown> } = {};
-        public static async initStylesheets(stylesheets: string[], isModule: boolean) {
-            const key = stylesheets.join('|');
-            if (Extras._initStylesheetsPromises[key] !== undefined) {
-                return Extras._initStylesheetsPromises[key];
+        private static isHostScriptLoaded(script: HTMLScriptElement): boolean {
+            if (script.hasAttribute('data-bit-load-failed')) {
+                return false;
             }
 
-            const allStylesheets = Array.from(document.links).filter(l => l.rel === 'stylesheet').map(s => s.href);
-            const notAddedStylesheets = stylesheets.filter(s => !allStylesheets.find(as => as.includes(s)));
+            const src = script.src;
+            if (!src) {
+                return true;
+            }
 
-            if (notAddedStylesheets.length == 0) return Promise.resolve();
+            // After the document finishes loading, Resource Timing (when exposed) distinguishes a fetched
+            // script from a 404/network failure. We can only verify when a numeric HTTP status is present:
+            // cross-origin entries without Timing-Allow-Origin report responseStatus 0, and browsers that
+            // don't implement responseStatus (e.g. Safari, older Firefox) report undefined. In both cases
+            // we cannot tell success from failure, so we assume the host tag succeeded.
+            const url = Extras.normalizeResourceUrl(src);
+            const entries = performance.getEntriesByName(url, 'resource') as PerformanceResourceTiming[];
+            if (entries.length === 0) {
+                return true;
+            }
 
-            const promise = new Promise(async (res: any, rej: any) => {
-                try {
-                    await Promise.all(notAddedStylesheets.map(addStylesheet));
-                    res();
-                } catch (e: any) {
-                    rej(e);
+            const status = entries[entries.length - 1].responseStatus;
+            if (status == null || status === 0) {
+                return true;
+            }
+
+            return status >= 200 && status < 400;
+        }
+
+        private static loadResourceError(kind: 'script' | 'stylesheet', url: string): Error {
+            return new Error(`Failed to load ${kind}: ${url}`);
+        }
+
+        private static awaitHostResource(element: HTMLElement, kind: 'script' | 'stylesheet', url: string): Promise<void> {
+            if (document.readyState === 'complete') {
+                if (kind === 'stylesheet' && !Extras.isHostStylesheetApplied(element as HTMLLinkElement)) {
+                    return Promise.reject(Extras.loadResourceError(kind, url));
                 }
+                if (kind === 'script' && !Extras.isHostScriptLoaded(element as HTMLScriptElement)) {
+                    return Promise.reject(Extras.loadResourceError(kind, url));
+                }
+                return Promise.resolve();
+            }
+
+            // An already-applied stylesheet has a non-null .sheet at any readyState, so short-circuit
+            // instead of waiting on a 'load' event that may have already fired. We intentionally do NOT
+            // apply the equivalent isHostScriptLoaded check here: it relies on Resource Timing, which has
+            // no entry for an in-flight script before the document is 'complete', so it would resolve
+            // prematurely for a host script that is still loading. Such scripts fall through to the
+            // load/error/window listeners below, which await real readiness.
+            if (kind === 'stylesheet' && Extras.isHostStylesheetApplied(element as HTMLLinkElement)) {
+                return Promise.resolve();
+            }
+
+            return new Promise<void>((res, rej) => {
+                const onError = () => {
+                    element.setAttribute('data-bit-load-failed', '');
+                    settle();
+                };
+                // Remove all three listeners as soon as one of them settles the Promise, so the closure
+                // isn't kept alive by the still-registered listeners (notably the window 'load' one, which
+                // may otherwise never fire). { once: true } only removes the listener that actually fired.
+                const cleanup = () => {
+                    element.removeEventListener('load', settle);
+                    element.removeEventListener('error', onError);
+                    window.removeEventListener('load', settle);
+                };
+                const settle = () => {
+                    cleanup();
+                    if (kind === 'stylesheet' && !Extras.isHostStylesheetApplied(element as HTMLLinkElement)) {
+                        rej(Extras.loadResourceError(kind, url));
+                        return;
+                    }
+                    if (kind === 'script' && !Extras.isHostScriptLoaded(element as HTMLScriptElement)) {
+                        rej(Extras.loadResourceError(kind, url));
+                        return;
+                    }
+                    res();
+                };
+                element.addEventListener('load', settle, { once: true });
+                // On failure, mark the tag (so findExistingResource skips it on a later lookup) and let
+                // settle() reject. Rejecting keeps the cache from being poisoned with a broken resource and
+                // lets loadResource inject a fresh, working tag on retry. Scripts and stylesheets behave
+                // identically here, matching the readyState === 'complete' branch above.
+                element.addEventListener('error', onError, { once: true });
+                // Final backstop: the window load event fires once all initial resources settle.
+                window.addEventListener('load', settle, { once: true });
             });
+        }
 
-            Extras._initStylesheetsPromises[key] = promise;
-            return promise;
+        // Classic <script> reuse must be limited to tags the browser actually executes as JavaScript.
+        // A bare (typeless) or JS-typed script runs; data blocks like type="application/json" do not, so
+        // they must never satisfy a classic-script lookup. The empty/absent type defaults to JavaScript.
+        // This is the HTML spec's set of JavaScript MIME types; 'module' is intentionally excluded since
+        // it's handled by the dedicated module branch.
+        private static isExecutableClassicScriptType(type: string): boolean {
+            const t = (type ?? '').trim().toLowerCase();
+            if (t === '') return true;
+            return [
+                'text/javascript',
+                'application/javascript',
+                'application/ecmascript',
+                'text/ecmascript',
+                'application/x-ecmascript',
+                'application/x-javascript',
+                'text/javascript1.0',
+                'text/javascript1.1',
+                'text/javascript1.2',
+                'text/javascript1.3',
+                'text/javascript1.4',
+                'text/javascript1.5',
+                'text/jscript',
+                'text/livescript',
+                'text/x-ecmascript',
+                'text/x-javascript',
+            ].indexOf(t) !== -1;
+        }
 
-            async function addStylesheet(url: string) {
-                return new Promise((res, rej) => {
-                    const link = document.createElement('link');
-                    link.href = url;
-                    link.rel = 'stylesheet';
-                    link.onload = res;
-                    link.onerror = rej;
-                    document.head.appendChild(link);
-                })
+        private static findExistingResource(kind: 'script' | 'stylesheet', targetUrl: string, isModule?: boolean): HTMLElement | undefined {
+            if (kind === 'script') {
+                // Match the script type too: a classic script must not be reused when a module script is
+                // requested (or vice versa), since they produce different <script> tags and execution semantics.
+                // For the classic case, only reuse tags whose type is an executable JavaScript type so
+                // non-executable tags (e.g. application/json) can never satisfy the lookup. Also exclude
+                // nomodule scripts: they don't execute in module-capable browsers, so reusing one would
+                // falsely report the resource as loaded.
+                const wantModule = !!isModule;
+                return Array.from(document.scripts).find(s => !!s.src
+                    && Extras.normalizeResourceUrl(s.src) === targetUrl
+                    && (wantModule ? (s.type ?? '').trim().toLowerCase() === 'module' : (Extras.isExecutableClassicScriptType(s.type) && !s.noModule))
+                    && !s.hasAttribute('data-bit-load-failed')
+                    && !(document.readyState === 'complete' && !Extras.isHostScriptLoaded(s)));
             }
+
+            return Array.from(document.querySelectorAll<HTMLLinkElement>('link[rel="stylesheet"]'))
+                .find(l => !!l.href
+                    && Extras.normalizeResourceUrl(l.href) === targetUrl
+                    && !l.hasAttribute('data-bit-load-failed')
+                    && !(document.readyState === 'complete' && !Extras.isHostStylesheetApplied(l)));
         }
 
+        private static createResourceElement(kind: 'script' | 'stylesheet', url: string, isModule?: boolean): HTMLElement {
+            if (kind === 'script') {
+                const script = document.createElement('script');
+                script.src = url;
+                if (isModule) {
+                    script.type = 'module';
+                }
+                return script;
+            }
+
+            const link = document.createElement('link');
+            link.href = url;
+            link.rel = 'stylesheet';
+            return link;
+        }
+
+        private static appendResourceElement(kind: 'script' | 'stylesheet', element: HTMLElement): void {
+            (kind === 'script' ? document.body : document.head).appendChild(element);
+        }
+
+        private static loadResource(kind: 'script' | 'stylesheet', url: string, isModule?: boolean): Promise<void> {
+            // Track each resource by url. Loads resolve only after the 'load' event (scripts after they
+            // execute, stylesheets after they are applied), so concurrent/duplicate callers await the real
+            // readiness rather than assuming it from the presence of a tag in the DOM.
+            // Match by the full absolute URL (origin + path + query + hash, resolved against the document
+            // base) so that resources from different origins or with different query strings are treated
+            // as distinct. Resolving against baseURI also avoids substring collisions like "lib.js" matching
+            // "mylib.js". Use the same normalized form as the cache key so relative/absolute equivalents
+            // hit the same entry.
+            const cache = kind === 'script' ? Extras._scriptPromises : Extras._stylesheetPromises;
+            const targetUrl = Extras.normalizeResourceUrl(url);
+            // The DOM lookup still matches by targetUrl, but the cache key for scripts also folds in the
+            // isModule flag so the same URL loaded as a classic script vs a module script are cached as
+            // distinct entries (they produce different <script> tags and execution semantics).
+            const cacheKey = kind === 'script' ? `${targetUrl}\n${isModule ? 'module' : 'classic'}` : targetUrl;
+
+            const existingPromise = cache[cacheKey];
+            if (existingPromise !== undefined) return existingPromise;
+
+            // A tag we didn't add is host-provided. If the document has finished loading, verify the
+            // resource actually applied/executed before treating it as ready. Otherwise the tag may still
+            // be loading (e.g. a deferred/async CDN tag the host inserted), so await its load/error event
+            // instead of assuming readiness from the mere presence of the tag. Waiting is gated on
+            // document.readyState so we never block on a 'load' event that has already fired.
+            // Host resources that failed to apply/load are skipped here so a working tag can be injected below.
+            const existingTag = Extras.findExistingResource(kind, targetUrl, isModule);
+            if (existingTag) {
+                const ready = Extras.awaitHostResource(existingTag, kind, url);
+                // Drop the cache entry before delegating so the retry doesn't read this very promise back
+                // out of the cache (which would create a Promises/A+ chaining cycle and reject with a
+                // confusing TypeError). The failed host tag is marked data-bit-load-failed, so
+                // findExistingResource skips it and the retry injects a fresh tag.
+                const withRetry = ready.catch(() => {
+                    delete cache[cacheKey];
+                    return Extras.loadResource(kind, url, isModule);
+                });
+                cache[cacheKey] = withRetry;
+                withRetry.catch(() => { delete cache[cacheKey]; });
+                return withRetry;
+            }
+
+            const promise = new Promise<void>((res, rej) => {
+                const element = Extras.createResourceElement(kind, url, isModule);
+                element.addEventListener('load', () => res());
+                // error is supported on <link rel="stylesheet"> in all browsers bitBlazorUI targets.
+                element.addEventListener('error', () => {
+                    // Remove the failed tag so a retry creates a fresh one instead of matching this
+                    // broken element via findExistingResource (which would report readiness on complete).
+                    element.remove();
+                    rej(Extras.loadResourceError(kind, url));
+                });
+                Extras.appendResourceElement(kind, element);
+            });
+
+            cache[cacheKey] = promise;
+
+            // Don't cache a rejected load: a later retry should be able to attempt the resource again.
+            promise.catch(() => { delete cache[cacheKey]; });
+
+            return promise;
+        }
 
         public static invokeJs<T>(identifier: string, ...args: unknown[]): Promise<T> {
             identifier ??= '';
diff --git a/src/BlazorUI/Bit.BlazorUI/Components/Inputs/CircularTimePicker/BitCircularTimePicker.razor.cs b/src/BlazorUI/Bit.BlazorUI/Components/Inputs/CircularTimePicker/BitCircularTimePicker.razor.cs
index da69893484..157c37bbc8 100644
--- a/src/BlazorUI/Bit.BlazorUI/Components/Inputs/CircularTimePicker/BitCircularTimePicker.razor.cs
+++ b/src/BlazorUI/Bit.BlazorUI/Components/Inputs/CircularTimePicker/BitCircularTimePicker.razor.cs
@@ -611,6 +611,8 @@ private async Task UpdateTime(MouseEventArgs e)
         if (IsEnabled is false || ReadOnly || InvalidValueBinding()) return;
 
         var rect = await _js.BitUtilsGetBoundingClientRect(_clockRef);
+        if (rect is null) return;
+        
         var radius = rect.Width / 2;
         var centerX = radius;
         var centerY = radius;
diff --git a/src/BlazorUI/Bit.BlazorUI/Components/Inputs/CircularTimePicker/BitCircularTimePickerJsRuntimeExtensions.cs b/src/BlazorUI/Bit.BlazorUI/Components/Inputs/CircularTimePicker/BitCircularTimePickerJsRuntimeExtensions.cs
index f6da110208..78f2d68a98 100644
--- a/src/BlazorUI/Bit.BlazorUI/Components/Inputs/CircularTimePicker/BitCircularTimePickerJsRuntimeExtensions.cs
+++ b/src/BlazorUI/Bit.BlazorUI/Components/Inputs/CircularTimePicker/BitCircularTimePickerJsRuntimeExtensions.cs
@@ -2,13 +2,19 @@
 
 internal static class BitCircularTimePickerJsRuntimeExtensions
 {
-    internal static ValueTask<string> BitCircularTimePickerSetup(this IJSRuntime js, DotNetObjectReference<BitCircularTimePicker> obj, string pointerUpHandler, string pointerMoveHandler)
+    // FastInvoke returns default (null) when the runtime can't service interop or a JSON/JS interop
+    // error is swallowed on the in-process (WASM) path, so normalize to an empty id to keep callers
+    // from treating a failed setup as an initialized abort controller.
+    internal static async ValueTask<string> BitCircularTimePickerSetup(this IJSRuntime js, DotNetObjectReference<BitCircularTimePicker> obj, string pointerUpHandler, string pointerMoveHandler)
     {
-        return js.Invoke<string>("BitBlazorUI.CircularTimePicker.setup", obj, pointerUpHandler, pointerMoveHandler);
+        const string identifier = "BitBlazorUI.CircularTimePicker.setup";
+        var result = await js.FastInvoke<string>(identifier, obj, pointerUpHandler, pointerMoveHandler);
+        js.ReportIfUnexpectedNull(identifier, result);
+        return result ?? string.Empty;
     }
 
     internal static ValueTask BitCircularTimePickerDispose(this IJSRuntime jSRuntime, string? abortControllerId)
     {
-        return jSRuntime.InvokeVoid("BitBlazorUI.CircularTimePicker.dispose", abortControllerId);
+        return jSRuntime.FastInvokeVoid("BitBlazorUI.CircularTimePicker.dispose", abortControllerId);
     }
 }
diff --git a/src/BlazorUI/Bit.BlazorUI/Components/Inputs/ColorPicker/BitColorPicker.razor.cs b/src/BlazorUI/Bit.BlazorUI/Components/Inputs/ColorPicker/BitColorPicker.razor.cs
index 638e91e4c4..be61a0dbfe 100644
--- a/src/BlazorUI/Bit.BlazorUI/Components/Inputs/ColorPicker/BitColorPicker.razor.cs
+++ b/src/BlazorUI/Bit.BlazorUI/Components/Inputs/ColorPicker/BitColorPicker.razor.cs
@@ -134,6 +134,15 @@ protected override async Task OnAfterRenderAsync(bool firstRender)
 
         _abortControllerId = await _js.BitColorPickerSetup(_dotnetObj, nameof(HandlePointerUp), nameof(HandlePointerMove));
 
+        // When setup fails it returns no id, meaning the JS side never registered the abort controller and
+        // therefore can't own and dispose this .NET reference later. Release it here so the GCHandle doesn't
+        // leak, and leave _abortControllerId null so DisposeAsync skips the (now pointless) JS dispose call.
+        if (_abortControllerId is null)
+        {
+            _dotnetObj.Dispose();
+            _dotnetObj = null!;
+        }
+
         await SetSaturationPickerThumbPositionAsync();
     }
 
@@ -165,6 +174,7 @@ private async Task UpdateColor(MouseEventArgs e)
         if (ColorHasBeenSet && ColorChanged.HasDelegate is false) return;
 
         var pickerRect = await _js.BitUtilsGetBoundingClientRect(_saturationPickerRef);
+        if (pickerRect is null) return;
 
         var left = e.ClientX < pickerRect.Left 
                     ? 0
diff --git a/src/BlazorUI/Bit.BlazorUI/Components/Inputs/ColorPicker/BitColorPicker.ts b/src/BlazorUI/Bit.BlazorUI/Components/Inputs/ColorPicker/BitColorPicker.ts
index e2c5ad5500..f938211724 100644
--- a/src/BlazorUI/Bit.BlazorUI/Components/Inputs/ColorPicker/BitColorPicker.ts
+++ b/src/BlazorUI/Bit.BlazorUI/Components/Inputs/ColorPicker/BitColorPicker.ts
@@ -23,7 +23,11 @@
             const bitController = ColorPicker._bitControllers.find(bc => bc.id == id);
             bitController?.controller.abort();
 
-            bitController?.dotnetObj?.dispose();
+            try {
+                bitController?.dotnetObj?.dispose();
+            } catch (e) {
+                console.error("BitBlazorUI.ColorPicker.dispose:", e);
+            }
 
             ColorPicker._bitControllers = ColorPicker._bitControllers.filter(bc => bc.id != id);
         }
diff --git a/src/BlazorUI/Bit.BlazorUI/Components/Inputs/ColorPicker/BitColorPickerJsRuntimeExtensions.cs b/src/BlazorUI/Bit.BlazorUI/Components/Inputs/ColorPicker/BitColorPickerJsRuntimeExtensions.cs
index 232e258bfe..4546c3febd 100644
--- a/src/BlazorUI/Bit.BlazorUI/Components/Inputs/ColorPicker/BitColorPickerJsRuntimeExtensions.cs
+++ b/src/BlazorUI/Bit.BlazorUI/Components/Inputs/ColorPicker/BitColorPickerJsRuntimeExtensions.cs
@@ -2,13 +2,21 @@
 
 internal static class BitColorPickerJsRuntimeExtensions
 {
-    internal static ValueTask<string> BitColorPickerSetup(this IJSRuntime js, DotNetObjectReference<BitColorPicker> obj, string pointerUpHandler, string pointerMoveHandler)
+    // FastInvoke returns default (null) when the runtime can't service interop or a JSON/JS interop
+    // error is swallowed on the in-process (WASM) path. The nullable failure state is preserved (rather
+    // than normalized to an empty id) so callers can detect a failed setup and dispose the
+    // DotNetObjectReference themselves, since the JS dispose path can't own a reference that was never
+    // registered.
+    internal static async ValueTask<string?> BitColorPickerSetup(this IJSRuntime js, DotNetObjectReference<BitColorPicker> obj, string pointerUpHandler, string pointerMoveHandler)
     {
-        return js.Invoke<string>("BitBlazorUI.ColorPicker.setup", obj, pointerUpHandler, pointerMoveHandler);
+        const string identifier = "BitBlazorUI.ColorPicker.setup";
+        var result = await js.FastInvoke<string>(identifier, obj, pointerUpHandler, pointerMoveHandler);
+        js.ReportIfUnexpectedNull(identifier, result);
+        return result;
     }
 
     internal static ValueTask BitColorPickerDispose(this IJSRuntime jSRuntime, string? abortControllerId)
     {
-        return jSRuntime.InvokeVoid("BitBlazorUI.ColorPicker.dispose", abortControllerId);
+        return jSRuntime.FastInvokeVoid("BitBlazorUI.ColorPicker.dispose", abortControllerId);
     }
 }
diff --git a/src/BlazorUI/Bit.BlazorUI/Components/Inputs/DatePicker/BitDatePicker.razor.cs b/src/BlazorUI/Bit.BlazorUI/Components/Inputs/DatePicker/BitDatePicker.razor.cs
index 1a6c94ca98..dcff59dd24 100644
--- a/src/BlazorUI/Bit.BlazorUI/Components/Inputs/DatePicker/BitDatePicker.razor.cs
+++ b/src/BlazorUI/Bit.BlazorUI/Components/Inputs/DatePicker/BitDatePicker.razor.cs
@@ -905,7 +905,7 @@ private async Task HandleOnClick()
 
         ResetPickersState();
 
-        var bodyWidth = await _js.BitUtilsGetBodyWidth();
+        var bodyWidth = await _js.BitUtilsGetBodyWidth() ?? 0;
         var notEnoughWidthAvailable = bodyWidth < MAX_WIDTH;
 
         if (_showMonthPickerAsOverlayInternal is false)
@@ -1796,5 +1796,12 @@ protected override async ValueTask DisposeAsync(bool disposing)
             await _js.BitSwipesDispose(_calloutId);
         }
         catch (JSDisconnectedException) { } // we can ignore this exception here
+        finally
+        {
+            // Dispose the .NET reference after the JS cleanup so any callbacks the JS teardown makes still
+            // have a live target, matching BitDateRangePicker.DisposeAsync. The finally ensures it's always
+            // released even if the JS cleanup throws a non-JSDisconnectedException.
+            _dotnetObj?.Dispose();
+        }
     }
 }
diff --git a/src/BlazorUI/Bit.BlazorUI/Components/Inputs/DateRangePicker/BitDateRangePicker.razor.cs b/src/BlazorUI/Bit.BlazorUI/Components/Inputs/DateRangePicker/BitDateRangePicker.razor.cs
index 4866cae0e8..6af7473bf1 100644
--- a/src/BlazorUI/Bit.BlazorUI/Components/Inputs/DateRangePicker/BitDateRangePicker.razor.cs
+++ b/src/BlazorUI/Bit.BlazorUI/Components/Inputs/DateRangePicker/BitDateRangePicker.razor.cs
@@ -889,7 +889,7 @@ private async Task HandleOnClick()
 
         ResetPickersState();
 
-        var bodyWidth = await _js.BitUtilsGetBodyWidth();
+        var bodyWidth = await _js.BitUtilsGetBodyWidth() ?? 0;
         var notEnoughWidthAvailable = bodyWidth < MAX_WIDTH;
 
         if (_showMonthPickerAsOverlayInternal is false)
@@ -2341,5 +2341,12 @@ protected override async ValueTask DisposeAsync(bool disposing)
             await _js.BitSwipesDispose(_calloutId);
         }
         catch (JSDisconnectedException) { } // we can ignore this exception here
+        finally
+        {
+            // Dispose the .NET reference after the JS cleanup so any callbacks the JS teardown makes still
+            // have a live target, matching BitDropdown.DisposeAsync. The finally ensures the managed
+            // reference is always released even if the JS cleanup throws a non-JSDisconnectedException.
+            _dotnetObj?.Dispose();
+        }
     }
 }
diff --git a/src/BlazorUI/Bit.BlazorUI/Components/Inputs/Dropdown/BitDropdown.razor.cs b/src/BlazorUI/Bit.BlazorUI/Components/Inputs/Dropdown/BitDropdown.razor.cs
index 389f05e074..9f863a494b 100644
--- a/src/BlazorUI/Bit.BlazorUI/Components/Inputs/Dropdown/BitDropdown.razor.cs
+++ b/src/BlazorUI/Bit.BlazorUI/Components/Inputs/Dropdown/BitDropdown.razor.cs
@@ -1494,7 +1494,7 @@ private async Task HandleOnKeyDown(KeyboardEventArgs eventArgs)
         }
         else if (eventArgs.Key == "Enter")
         {
-            _searchText = await _js.BitUtilsGetProperty(_isResponsiveMode ? _comboBoxInputResponsiveRef : _comboBoxInputRef, "value");
+            _searchText = await _js.BitUtilsGetProperty(_isResponsiveMode ? _comboBoxInputResponsiveRef : _comboBoxInputRef, "value") ?? string.Empty;
 
             await AddDynamicItem();
 
diff --git a/src/BlazorUI/Bit.BlazorUI/Components/Inputs/FileUpload/BitFileUpload.ts b/src/BlazorUI/Bit.BlazorUI/Components/Inputs/FileUpload/BitFileUpload.ts
index f22ad996e8..95df8cce30 100644
--- a/src/BlazorUI/Bit.BlazorUI/Components/Inputs/FileUpload/BitFileUpload.ts
+++ b/src/BlazorUI/Bit.BlazorUI/Components/Inputs/FileUpload/BitFileUpload.ts
@@ -14,8 +14,10 @@
                 FileUpload.clear(id);
             }
 
+            if (!inputElement?.files?.length) return [];
+
             const lastIndex = append ? FileUpload._fileUploaders.filter(u => u.id === id).length : 0;
-            const files = Array.from(inputElement.files!).map((file, index) => ({
+            const files = Array.from(inputElement.files).map((file, index) => ({
                 name: file.name,
                 size: file.size,
                 type: file.type,
@@ -41,7 +43,9 @@
             if (index === -1) {
                 uploaders.forEach(u => u.upload(from, to, uploadUrl, headers));
             } else {
-                const uploader = uploaders.filter(u => u.index === index)[0];
+                const uploader = uploaders.find(u => u.index === index);
+                if (!uploader) return;
+
                 uploader.upload(from, to, uploadUrl, headers);
             }
         }
@@ -52,7 +56,9 @@
             if (index === -1) {
                 uploaders.forEach(u => u.pause());
             } else {
-                const uploader = uploaders.filter(u => u.index === index)[0];
+                const uploader = uploaders.find(u => u.index === index);
+                if (!uploader) return;
+
                 uploader.pause();
             }
         }
diff --git a/src/BlazorUI/Bit.BlazorUI/Components/Inputs/FileUpload/BitFileUploadJsRuntimeExtensions.cs b/src/BlazorUI/Bit.BlazorUI/Components/Inputs/FileUpload/BitFileUploadJsRuntimeExtensions.cs
index eb7de51c30..30e3ad624b 100644
--- a/src/BlazorUI/Bit.BlazorUI/Components/Inputs/FileUpload/BitFileUploadJsRuntimeExtensions.cs
+++ b/src/BlazorUI/Bit.BlazorUI/Components/Inputs/FileUpload/BitFileUploadJsRuntimeExtensions.cs
@@ -5,7 +5,7 @@ namespace Bit.BlazorUI;
 internal static class BitFileUploadJsRuntimeExtensions
 {
     [DynamicDependency(DynamicallyAccessedMemberTypes.All, typeof(BitFileInfo))]
-    internal static ValueTask<BitFileInfo[]> BitFileUploadSetup(this IJSRuntime jsRuntime,
+    internal static async ValueTask<BitFileInfo[]> BitFileUploadSetup(this IJSRuntime jsRuntime,
                                                                      string id,
                                                                      DotNetObjectReference<BitFileUpload>? dotnetObjectReference,
                                                                      ElementReference element,
@@ -13,7 +13,13 @@ internal static ValueTask<BitFileInfo[]> BitFileUploadSetup(this IJSRuntime jsRu
                                                                      string? uploadAddress,
                                                                      Dictionary<string, string>? uploadRequestHttpHeaders)
     {
-        return jsRuntime.Invoke<BitFileInfo[]>("BitBlazorUI.FileUpload.setup", id, dotnetObjectReference, element, append, uploadAddress, uploadRequestHttpHeaders);
+        // FastInvoke returns default (null) when the runtime can't service interop or a JSON/JS interop
+        // error is swallowed on the in-process (WASM) path, so normalize to an empty array to keep callers
+        // (e.g. _files.AddRange(...)) from crashing with ArgumentNullException.
+        const string identifier = "BitBlazorUI.FileUpload.setup";
+        var result = await jsRuntime.FastInvoke<BitFileInfo[]>(identifier, id, dotnetObjectReference, element, append, uploadAddress, uploadRequestHttpHeaders);
+        jsRuntime.ReportIfUnexpectedNull(identifier, result);
+        return result ?? [];
     }
 
     internal static ValueTask BitFileUploadUpload(this IJSRuntime jsRuntime,
@@ -24,34 +30,39 @@ internal static ValueTask BitFileUploadUpload(this IJSRuntime jsRuntime,
                                                        string? uploadUrl,
                                                        Dictionary<string, string>? httpHeaders)
     {
-        return (httpHeaders is null ? jsRuntime.InvokeVoid("BitBlazorUI.FileUpload.upload", id, from, to, index, uploadUrl)
-                                    : jsRuntime.InvokeVoid("BitBlazorUI.FileUpload.upload", id, from, to, index, uploadUrl, httpHeaders));
+        return (httpHeaders is null ? jsRuntime.FastInvokeVoid("BitBlazorUI.FileUpload.upload", id, from, to, index, uploadUrl)
+                                    : jsRuntime.FastInvokeVoid("BitBlazorUI.FileUpload.upload", id, from, to, index, uploadUrl, httpHeaders));
     }
 
     internal static ValueTask BitFileUploadPause(this IJSRuntime jsRuntime, string id, int index = -1)
     {
-        return jsRuntime.InvokeVoid("BitBlazorUI.FileUpload.pause", id, index);
+        return jsRuntime.FastInvokeVoid("BitBlazorUI.FileUpload.pause", id, index);
     }
 
-    internal static ValueTask<IJSObjectReference> BitFileUploadSetupDragDrop(this IJSRuntime jsRuntime,
-                                                                                  ElementReference dragDropZoneElement,
-                                                                                  ElementReference inputFileElement)
+    // FastInvoke returns default (null) when the runtime can't service interop or a JSON/JS interop
+    // error is swallowed on the in-process (WASM) path. Callers must null-check before using the
+    // reference; a null result means drag/drop was not initialized.
+    internal static async ValueTask<IJSObjectReference?> BitFileUploadSetupDragDrop(this IJSRuntime jsRuntime,
+                                                                                         ElementReference dragDropZoneElement,
+                                                                                         ElementReference inputFileElement)
     {
-        return jsRuntime.Invoke<IJSObjectReference>("BitBlazorUI.FileUpload.setupDragDrop", dragDropZoneElement, inputFileElement);
+        const string identifier = "BitBlazorUI.FileUpload.setupDragDrop";
+        var result = await jsRuntime.FastInvoke<IJSObjectReference>(identifier, dragDropZoneElement, inputFileElement);
+        return jsRuntime.ReportIfUnexpectedNull(identifier, result);
     }
 
     internal static ValueTask BitFileUploadBrowse(this IJSRuntime jsRuntime, ElementReference inputFileElement)
     {
-        return jsRuntime.InvokeVoid("BitBlazorUI.FileUpload.browse", inputFileElement);
+        return jsRuntime.FastInvokeVoid("BitBlazorUI.FileUpload.browse", inputFileElement);
     }
 
     internal static ValueTask BitFileUploadClear(this IJSRuntime jsRuntime, string id)
     {
-        return jsRuntime.InvokeVoid("BitBlazorUI.FileUpload.clear", id);
+        return jsRuntime.FastInvokeVoid("BitBlazorUI.FileUpload.clear", id);
     }
 
     internal static ValueTask BitFileUploadReset(this IJSRuntime jsRuntime, string id, ElementReference inputFileElement)
     {
-        return jsRuntime.InvokeVoid("BitBlazorUI.FileUpload.reset", id, inputFileElement);
+        return jsRuntime.FastInvokeVoid("BitBlazorUI.FileUpload.reset", id, inputFileElement);
     }
 }
diff --git a/src/BlazorUI/Bit.BlazorUI/Components/Inputs/OtpInput/BitOtpInputJsRuntimeExtensions.cs b/src/BlazorUI/Bit.BlazorUI/Components/Inputs/OtpInput/BitOtpInputJsRuntimeExtensions.cs
index f90b5b094b..2c97422ff3 100644
--- a/src/BlazorUI/Bit.BlazorUI/Components/Inputs/OtpInput/BitOtpInputJsRuntimeExtensions.cs
+++ b/src/BlazorUI/Bit.BlazorUI/Components/Inputs/OtpInput/BitOtpInputJsRuntimeExtensions.cs
@@ -4,11 +4,11 @@ internal static class BitOtpInputJsRuntimeExtensions
 {
     internal static ValueTask BitOtpInputSetup(this IJSRuntime jsRuntime, string id, DotNetObjectReference<BitOtpInput> obj, ElementReference input)
     {
-        return jsRuntime.InvokeVoid("BitBlazorUI.OtpInput.setup", id, obj, input);
+        return jsRuntime.FastInvokeVoid("BitBlazorUI.OtpInput.setup", id, obj, input);
     }
 
     internal static ValueTask BitOtpInputDispose(this IJSRuntime jsRuntime, string id)
     {
-        return jsRuntime.InvokeVoid("BitBlazorUI.OtpInput.dispose", id);
+        return jsRuntime.FastInvokeVoid("BitBlazorUI.OtpInput.dispose", id);
     }
 }
diff --git a/src/BlazorUI/Bit.BlazorUI/Components/Inputs/SearchBox/BitSearchBox.razor.cs b/src/BlazorUI/Bit.BlazorUI/Components/Inputs/SearchBox/BitSearchBox.razor.cs
index 9ad6184bf3..3b9c25428b 100644
--- a/src/BlazorUI/Bit.BlazorUI/Components/Inputs/SearchBox/BitSearchBox.razor.cs
+++ b/src/BlazorUI/Bit.BlazorUI/Components/Inputs/SearchBox/BitSearchBox.razor.cs
@@ -452,7 +452,7 @@ private async Task HandleOnKeyDown(KeyboardEventArgs eventArgs)
             }
             else
             {
-                CurrentValue = await _js.BitUtilsGetProperty(InputElement, "value");
+                CurrentValue = await _js.BitUtilsGetProperty(InputElement, "value") ?? string.Empty;
 
                 await CloseCallout();
 
diff --git a/src/BlazorUI/Bit.BlazorUI/Components/Inputs/SearchBox/BitSearchBoxJsRuntimeExtensions.cs b/src/BlazorUI/Bit.BlazorUI/Components/Inputs/SearchBox/BitSearchBoxJsRuntimeExtensions.cs
index 2e35b6e09c..0c8565683b 100644
--- a/src/BlazorUI/Bit.BlazorUI/Components/Inputs/SearchBox/BitSearchBoxJsRuntimeExtensions.cs
+++ b/src/BlazorUI/Bit.BlazorUI/Components/Inputs/SearchBox/BitSearchBoxJsRuntimeExtensions.cs
@@ -4,6 +4,6 @@ internal static class BitSearchBoxJsRuntimeExtensions
 {
     internal static ValueTask BitSearchBoxMoveCursorToEnd(this IJSRuntime jsRuntime, ElementReference input)
     {
-        return jsRuntime.InvokeVoid("BitBlazorUI.SearchBox.moveCursorToEnd", input);
+        return jsRuntime.FastInvokeVoid("BitBlazorUI.SearchBox.moveCursorToEnd", input);
     }
 }
diff --git a/src/BlazorUI/Bit.BlazorUI/Components/Inputs/Slider/BitSlider.razor.cs b/src/BlazorUI/Bit.BlazorUI/Components/Inputs/Slider/BitSlider.razor.cs
index 477d03c123..894907424f 100644
--- a/src/BlazorUI/Bit.BlazorUI/Components/Inputs/Slider/BitSlider.razor.cs
+++ b/src/BlazorUI/Bit.BlazorUI/Components/Inputs/Slider/BitSlider.razor.cs
@@ -349,6 +349,6 @@ private async ValueTask<int> GetClientHeight(ElementReference element)
         var height = await _js.BitUtilsGetProperty(element, "clientHeight");
         return height.HasNoValue()
             ? 0
-            : int.Parse(height);
+            : int.Parse(height!);
     }
 }
diff --git a/src/BlazorUI/Bit.BlazorUI/Components/Inputs/TimePicker/BitTimePicker.razor.cs b/src/BlazorUI/Bit.BlazorUI/Components/Inputs/TimePicker/BitTimePicker.razor.cs
index d0cddb8c8e..0bce8bfe0d 100644
--- a/src/BlazorUI/Bit.BlazorUI/Components/Inputs/TimePicker/BitTimePicker.razor.cs
+++ b/src/BlazorUI/Bit.BlazorUI/Components/Inputs/TimePicker/BitTimePicker.razor.cs
@@ -782,5 +782,12 @@ protected override async ValueTask DisposeAsync(bool disposing)
             await _js.BitSwipesDispose(_calloutId);
         }
         catch (JSDisconnectedException) { } // we can ignore this exception here
+        finally
+        {
+            // Dispose the .NET reference after the JS cleanup so JS callbacks can't target an already-disposed
+            // reference, matching BitDropdown.DisposeAsync. The finally ensures it's always released even if the
+            // JS cleanup throws a non-JSDisconnectedException.
+            _dotnetObj?.Dispose();
+        }
     }
 }
diff --git a/src/BlazorUI/Bit.BlazorUI/Components/Lists/Carousel/BitCarousel.razor.cs b/src/BlazorUI/Bit.BlazorUI/Components/Lists/Carousel/BitCarousel.razor.cs
index f68593940a..e08327ddd6 100644
--- a/src/BlazorUI/Bit.BlazorUI/Components/Lists/Carousel/BitCarousel.razor.cs
+++ b/src/BlazorUI/Bit.BlazorUI/Components/Lists/Carousel/BitCarousel.razor.cs
@@ -293,6 +293,7 @@ private async Task ResetDimensionsAsync()
         var itemsCount = _allItems.Count;
         var rect = await _js.BitUtilsGetBoundingClientRect(_carouselContainer);
         if (rect is null) return;
+        
         var sign = Dir == BitDir.Rtl ? -1 : 1;
         for (int i = 0; i < itemsCount; i++)
         {
diff --git a/src/BlazorUI/Bit.BlazorUI/Components/Lists/Swiper/BitSwiper.ts b/src/BlazorUI/Bit.BlazorUI/Components/Lists/Swiper/BitSwiper.ts
index 312bc7ae33..56357688a1 100644
--- a/src/BlazorUI/Bit.BlazorUI/Components/Lists/Swiper/BitSwiper.ts
+++ b/src/BlazorUI/Bit.BlazorUI/Components/Lists/Swiper/BitSwiper.ts
@@ -7,6 +7,8 @@
             element: HTMLDivElement,
             dotnetObj: DotNetObject) {
 
+            if (!element) return;
+
             const ac = new AbortController();
             Swiper._abortControllers[id] = ac;
 
@@ -16,28 +18,33 @@
         }
 
         public static getDimensions(root: HTMLDivElement, container: HTMLDivElement) {
-            if (!root) return {};
-
-            const rootWidth = root.offsetWidth;
-            const containerWidth = [].slice.call(container.children).reduce((pre, cur: HTMLDivElement) => pre + cur.offsetWidth, 0);
-            const effectiveWidth = containerWidth - (container.parentElement?.offsetWidth ?? 0);
-
-            const computedStyle = window.getComputedStyle(container);
-            const matrix = computedStyle.getPropertyValue('transform');
-            const matched = matrix.match(/matrix\((.+)\)/);
-
-            let translateX = 0;
-            if (matched && matched.length > 1) {
-                const splitted = matched[1].split(',');
-                translateX = +splitted[4];
+            if (!root || !container) return null;
+
+            try {
+                const rootWidth = root.offsetWidth;
+                const containerWidth = [].slice.call(container.children).reduce((pre, cur: HTMLDivElement) => pre + cur.offsetWidth, 0);
+                const effectiveWidth = containerWidth - (container.parentElement?.offsetWidth ?? 0);
+
+                const computedStyle = window.getComputedStyle(container);
+                const matrix = computedStyle.getPropertyValue('transform');
+                const matched = matrix.match(/matrix\((.+)\)/);
+
+                let translateX = 0;
+                if (matched && matched.length > 1) {
+                    const splitted = matched[1].split(',');
+                    translateX = +splitted[4];
+                }
+
+                return {
+                    rootWidth,
+                    containerWidth,
+                    effectiveWidth,
+                    translateX
+                };
+            } catch (e) {
+                console.error("BitBlazorUI.Swiper.getDimensions:", e);
+                return null;
             }
-
-            return {
-                rootWidth,
-                containerWidth,
-                effectiveWidth,
-                translateX
-            };
         }
 
         public static dispose(id: string) {
diff --git a/src/BlazorUI/Bit.BlazorUI/Components/Lists/Swiper/BitSwiperJsRuntimeExtensions.cs b/src/BlazorUI/Bit.BlazorUI/Components/Lists/Swiper/BitSwiperJsRuntimeExtensions.cs
index c47f332b0e..50a48e0400 100644
--- a/src/BlazorUI/Bit.BlazorUI/Components/Lists/Swiper/BitSwiperJsRuntimeExtensions.cs
+++ b/src/BlazorUI/Bit.BlazorUI/Components/Lists/Swiper/BitSwiperJsRuntimeExtensions.cs
@@ -4,16 +4,16 @@ internal static class BitSwiperJsRuntimeExtensions
 {
     internal static ValueTask BitSwiperSetup(this IJSRuntime jsRuntime, string id, ElementReference element, DotNetObjectReference<BitSwiper> dotnetObj)
     {
-        return jsRuntime.InvokeVoid("BitBlazorUI.Swiper.setup", id, element, dotnetObj);
+        return jsRuntime.FastInvokeVoid("BitBlazorUI.Swiper.setup", id, element, dotnetObj);
     }
 
-    internal static ValueTask<SwiperDimensions> BitSwiperGetDimensions(this IJSRuntime jsRuntime, ElementReference root, ElementReference container)
+    internal static ValueTask<SwiperDimensions?> BitSwiperGetDimensions(this IJSRuntime jsRuntime, ElementReference root, ElementReference container)
     {
-        return jsRuntime.Invoke<SwiperDimensions>("BitBlazorUI.Swiper.getDimensions", root, container);
+        return jsRuntime.FastInvoke<SwiperDimensions?>("BitBlazorUI.Swiper.getDimensions", root, container);
     }
 
     internal static ValueTask BitSwiperDispose(this IJSRuntime jsRuntime, string id)
     {
-        return jsRuntime.InvokeVoid("BitBlazorUI.Swiper.dispose", id);
+        return jsRuntime.FastInvokeVoid("BitBlazorUI.Swiper.dispose", id);
     }
 }
diff --git a/src/BlazorUI/Bit.BlazorUI/Components/Surfaces/Dialog/BitDialog.razor.cs b/src/BlazorUI/Bit.BlazorUI/Components/Surfaces/Dialog/BitDialog.razor.cs
index a38129874c..75346ff754 100644
--- a/src/BlazorUI/Bit.BlazorUI/Components/Surfaces/Dialog/BitDialog.razor.cs
+++ b/src/BlazorUI/Bit.BlazorUI/Components/Surfaces/Dialog/BitDialog.razor.cs
@@ -247,7 +247,7 @@ protected override async Task OnAfterRenderAsync(bool firstRender)
 
         if (AutoToggleScroll is false) return;
 
-        _offsetTop = await _js.BitUtilsToggleOverflow(ScrollerSelector, IsOpen);
+        _offsetTop = await _js.BitUtilsToggleOverflow(ScrollerSelector, IsOpen) ?? 0;
 
         if (AbsolutePosition is false) return;
 
diff --git a/src/BlazorUI/Bit.BlazorUI/Components/Surfaces/Panel/BitPanel.razor.cs b/src/BlazorUI/Bit.BlazorUI/Components/Surfaces/Panel/BitPanel.razor.cs
index 3f74199f09..808ba15ec2 100644
--- a/src/BlazorUI/Bit.BlazorUI/Components/Surfaces/Panel/BitPanel.razor.cs
+++ b/src/BlazorUI/Bit.BlazorUI/Components/Surfaces/Panel/BitPanel.razor.cs
@@ -8,6 +8,7 @@ public partial class BitPanel : BitComponentBase
     private float _offsetTop;
     private bool _internalIsOpen;
     private string _containerId = default!;
+    private DotNetObjectReference<BitPanel>? _dotnetObj;
 
 
 
@@ -166,12 +167,25 @@ protected override async Task OnAfterRenderAsync(bool firstRender)
 
         if (firstRender)
         {
-            var dotnetObj = DotNetObjectReference.Create(this);
+            _dotnetObj = DotNetObjectReference.Create(this);
             var position = Position ?? BitPanelPosition.End;
             var orientationLock = position == BitPanelPosition.Start || position == BitPanelPosition.End
                                     ? BitSwipeOrientation.Horizontal 
                                     : BitSwipeOrientation.Vertical;
-            await _js.BitSwipesSetup(_containerId, SwipeTrigger ?? 0.25m, position, Dir == BitDir.Rtl, orientationLock, dotnetObj, false);
+            try
+            {
+                await _js.BitSwipesSetup(_containerId, SwipeTrigger ?? 0.25m, position, Dir == BitDir.Rtl, orientationLock, _dotnetObj, false);
+            }
+            catch
+            {
+                // BitSwipesSetup didn't complete, so the JS dispose path (which normally owns _dotnetObj)
+                // will never run. Release the managed reference here to avoid leaking the GCHandle, then
+                // rethrow so the original failure surfaces. On the success path the reference is kept for
+                // later cleanup handled by DisposeAsync.
+                _dotnetObj?.Dispose();
+                _dotnetObj = null;
+                throw;
+            }
         }
 
         if (_internalIsOpen == IsOpen) return;
@@ -182,7 +196,7 @@ protected override async Task OnAfterRenderAsync(bool firstRender)
 
         if (AutoToggleScroll is false) return;
 
-        _offsetTop = await _js.BitUtilsToggleOverflow(ScrollerSelector ?? "body", IsOpen);
+        _offsetTop = await _js.BitUtilsToggleOverflow(ScrollerSelector ?? "body", IsOpen) ?? 0;
 
         StyleBuilder.Reset();
         StateHasChanged();
@@ -256,11 +270,32 @@ protected override async ValueTask DisposeAsync(bool disposing)
     {
         if (IsDisposed || disposing is false) return;
 
+        // Ownership of _dotnetObj is single-sourced to the JS dispose path: BitSwipe.dispose() in Swipes.ts
+        // disposes the .NET reference. Disposing it here first would both double-dispose the object and risk
+        // BitSwipesDispose's handlers invoking an already-disposed reference.
         try
         {
             await _js.BitSwipesDispose(_containerId);
+
+            // The JS dispose owns disposal of the .NET reference; clear our field after the successful
+            // ownership handoff so we don't keep a stale reference alive.
+            _dotnetObj = null;
+        }
+        catch (JSDisconnectedException)
+        {
+            // The circuit/browser is gone, so BitSwipe.dispose() (which normally owns _dotnetObj) can't run.
+            // Release the managed reference here so it doesn't leak.
+            _dotnetObj?.Dispose();
+            _dotnetObj = null;
+        }
+        catch
+        {
+            // Any other failure means the JS dispose didn't complete its ownership handoff, so release the
+            // managed reference here to avoid leaking the GCHandle, then rethrow so the original error surfaces.
+            _dotnetObj?.Dispose();
+            _dotnetObj = null;
+            throw;
         }
-        catch (JSDisconnectedException) { } // we can ignore this exception here
 
         await base.DisposeAsync(disposing);
     }
diff --git a/src/BlazorUI/Bit.BlazorUI/Components/Surfaces/Splitter/BitSplitter.razor.cs b/src/BlazorUI/Bit.BlazorUI/Components/Surfaces/Splitter/BitSplitter.razor.cs
index f4cb134f5a..d3b079a34a 100644
--- a/src/BlazorUI/Bit.BlazorUI/Components/Surfaces/Splitter/BitSplitter.razor.cs
+++ b/src/BlazorUI/Bit.BlazorUI/Components/Surfaces/Splitter/BitSplitter.razor.cs
@@ -137,22 +137,54 @@ protected override void RegisterCssStyles()
 
     private void OnSetVertical()
     {
-        _ = _js.BitSplitterResetPaneDimensions(_firstPanelRef);
-        _ = _js.BitSplitterResetPaneDimensions(_secondPanelRef);
+        // Fire-and-forget: the reset runs on the renderer's sync context via InvokeAsync, but its task is
+        // not awaited. On the async interop path (Server/Hybrid) the BitSplitterResetPaneDimensions calls
+        // can fault (e.g. a JSException), which would otherwise become an unobserved task exception. Attach
+        // a fault-only continuation that observes and reports the failure instead of silently dropping it.
+        _ = InvokeAsync(ResetPaneDimensionsOnVerticalChange)
+            .ContinueWith(static task => Console.Error.WriteLine(
+                    $"Error resetting BitSplitter pane dimensions on orientation change: {task.Exception}"),
+                CancellationToken.None,
+                TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.ExecuteSynchronously,
+                TaskScheduler.Default);
+    }
+
+    private async Task ResetPaneDimensionsOnVerticalChange()
+    {
+        await _js.BitSplitterResetPaneDimensions(_firstPanelRef);
+        await _js.BitSplitterResetPaneDimensions(_secondPanelRef);
     }
 
     private async Task OnDraggingStart(double position)
     {
+        // Probe only the measurements needed for the active orientation and keep the nullable result.
+        // A null measurement means the JS size probe failed; defaulting it to 0 would create an invalid
+        // baseline for pane resizing, so abort the drag instead of starting from a bogus size.
+        if (Vertical)
+        {
+            var firstHeight = await _js.BitSplitterGetSplitterHeight(_firstPanelRef);
+            var secondHeight = await _js.BitSplitterGetSplitterHeight(_secondPanelRef);
+
+            if (firstHeight is null || secondHeight is null) return;
+
+            _initialFirstPanelHeight = firstHeight.Value;
+            _initialSecondPanelHeight = secondHeight.Value;
+        }
+        else
+        {
+            var firstWidth = await _js.BitSplitterGetSplitterWidth(_firstPanelRef);
+            var secondWidth = await _js.BitSplitterGetSplitterWidth(_secondPanelRef);
+
+            if (firstWidth is null || secondWidth is null) return;
+
+            _initialFirstPanelWidth = firstWidth.Value;
+            _initialSecondPanelWidth = secondWidth.Value;
+        }
+
         _isDragging = true;
         ClassBuilder.Reset();
 
         _initialPosition = position;
-
-        _initialFirstPanelWidth = await _js.BitSplitterGetSplitterWidth(_firstPanelRef);
-        _initialSecondPanelWidth = await _js.BitSplitterGetSplitterWidth(_secondPanelRef);
-
-        _initialFirstPanelHeight = await _js.BitSplitterGetSplitterHeight(_firstPanelRef);
-        _initialSecondPanelHeight = await _js.BitSplitterGetSplitterHeight(_secondPanelRef);
     }
 
     private async Task OnDragging(double position)
diff --git a/src/BlazorUI/Bit.BlazorUI/Components/Surfaces/Splitter/BitSplitter.ts b/src/BlazorUI/Bit.BlazorUI/Components/Surfaces/Splitter/BitSplitter.ts
index 7ef14df21e..229705a31d 100644
--- a/src/BlazorUI/Bit.BlazorUI/Components/Surfaces/Splitter/BitSplitter.ts
+++ b/src/BlazorUI/Bit.BlazorUI/Components/Surfaces/Splitter/BitSplitter.ts
@@ -8,25 +8,51 @@
             document.body.style.overscrollBehavior = '';
         };
 
-        public static getSplitterWidth(element: HTMLElement) {
-            return element.getBoundingClientRect().width;
+        public static getSplitterWidth(element: HTMLElement): number | null {
+            if (!element || typeof element.getBoundingClientRect !== 'function') return null;
+
+            try {
+                return element.getBoundingClientRect().width;
+            } catch (e) {
+                console.error("BitBlazorUI.Splitter.getSplitterWidth:", e);
+                return null;
+            }
         };
 
         public static setSplitterWidth(element: HTMLElement, width: number) {
-            element.style.width = width + 'px';
+            if (!element || !element.style) return;
+
+            try {
+                element.style.width = width + 'px';
+            } catch (e) { console.error("BitBlazorUI.Splitter.setSplitterWidth:", e); }
         };
 
-        public static getSplitterHeight(element: HTMLElement) {
-            return element.getBoundingClientRect().height;
+        public static getSplitterHeight(element: HTMLElement): number | null {
+            if (!element || typeof element.getBoundingClientRect !== 'function') return null;
+
+            try {
+                return element.getBoundingClientRect().height;
+            } catch (e) {
+                console.error("BitBlazorUI.Splitter.getSplitterHeight:", e);
+                return null;
+            }
         };
 
         public static setSplitterHeight(element: HTMLElement, height: number) {
-            element.style.height = height + 'px';
+            if (!element || !element.style) return;
+
+            try {
+                element.style.height = height + 'px';
+            } catch (e) { console.error("BitBlazorUI.Splitter.setSplitterHeight:", e); }
         };
 
-        public static resetPaneDimensions(element: HTMLElement) {
-            element.style.width = '';
-            element.style.height = '';
+        public static resetPaneDimensions(element: HTMLElement | undefined) {
+            if (!element || !element.style) return;
+
+            try {
+                element.style.width = '';
+                element.style.height = '';
+            } catch (e) { console.error("BitBlazorUI.Splitter.resetPaneDimensions:", e); }
         };
     }
 }
\ No newline at end of file
diff --git a/src/BlazorUI/Bit.BlazorUI/Components/Surfaces/Splitter/BitSplitterJsRuntimeExtensions.cs b/src/BlazorUI/Bit.BlazorUI/Components/Surfaces/Splitter/BitSplitterJsRuntimeExtensions.cs
index 6dab2ebcd4..386169a0cd 100644
--- a/src/BlazorUI/Bit.BlazorUI/Components/Surfaces/Splitter/BitSplitterJsRuntimeExtensions.cs
+++ b/src/BlazorUI/Bit.BlazorUI/Components/Surfaces/Splitter/BitSplitterJsRuntimeExtensions.cs
@@ -4,36 +4,38 @@ internal static class BitSplitterJsRuntimeExtensions
 {
     internal static ValueTask BitSplitterResetPaneDimensions(this IJSRuntime js, ElementReference element)
     {
-        return js.InvokeVoid("BitBlazorUI.Splitter.resetPaneDimensions", element);
+        return js.FastInvokeVoid("BitBlazorUI.Splitter.resetPaneDimensions", element);
     }
 
-    internal static ValueTask<double> BitSplitterGetSplitterWidth(this IJSRuntime js, ElementReference element)
+    // FastInvoke returns null when the runtime can't service interop or a JSON/JS interop error is
+    // swallowed on the in-process (WASM) path. Nullable distinguishes that from a legitimate 0 width.
+    internal static ValueTask<double?> BitSplitterGetSplitterWidth(this IJSRuntime js, ElementReference element)
     {
-        return js.Invoke<double>("BitBlazorUI.Splitter.getSplitterWidth", element);
+        return js.FastInvoke<double?>("BitBlazorUI.Splitter.getSplitterWidth", element);
     }
 
     internal static ValueTask BitSplitterSetSplitterWidth(this IJSRuntime js, ElementReference element, double value)
     {
-        return js.InvokeVoid("BitBlazorUI.Splitter.setSplitterWidth", element, value);
+        return js.FastInvokeVoid("BitBlazorUI.Splitter.setSplitterWidth", element, value);
     }
 
-    internal static ValueTask<double> BitSplitterGetSplitterHeight(this IJSRuntime js, ElementReference element)
+    internal static ValueTask<double?> BitSplitterGetSplitterHeight(this IJSRuntime js, ElementReference element)
     {
-        return js.Invoke<double>("BitBlazorUI.Splitter.getSplitterHeight", element);
+        return js.FastInvoke<double?>("BitBlazorUI.Splitter.getSplitterHeight", element);
     }
 
     internal static ValueTask BitSplitterSetSplitterHeight(this IJSRuntime js, ElementReference element, double value)
     {
-        return js.InvokeVoid("BitBlazorUI.Splitter.setSplitterHeight", element, value);
+        return js.FastInvokeVoid("BitBlazorUI.Splitter.setSplitterHeight", element, value);
     }
 
     internal static ValueTask BitSplitterHandleSplitterDragging(this IJSRuntime js, TouchEventArgs e)
     {
-        return js.InvokeVoid("BitBlazorUI.Splitter.handleSplitterDragging", e);
+        return js.FastInvokeVoid("BitBlazorUI.Splitter.handleSplitterDragging", e);
     }
 
     internal static ValueTask BitSplitterHandleSplitterDraggingEnd(this IJSRuntime js)
     {
-        return js.InvokeVoid("BitBlazorUI.Splitter.handleSplitterDraggingEnd");
+        return js.FastInvokeVoid("BitBlazorUI.Splitter.handleSplitterDraggingEnd");
     }
 }
diff --git a/src/BlazorUI/Bit.BlazorUI/Components/Utilities/Overlay/BitOverlay.razor.cs b/src/BlazorUI/Bit.BlazorUI/Components/Utilities/Overlay/BitOverlay.razor.cs
index e15f3a1c1c..62e00a5ddc 100644
--- a/src/BlazorUI/Bit.BlazorUI/Components/Utilities/Overlay/BitOverlay.razor.cs
+++ b/src/BlazorUI/Bit.BlazorUI/Components/Utilities/Overlay/BitOverlay.razor.cs
@@ -80,7 +80,7 @@ protected override async Task OnAfterRenderAsync(bool firstRender)
 
         var scrollerSelector = ScrollerSelector.HasValue() ? ScrollerSelector! : "body";
 
-        _offsetTop = await _js.BitUtilsToggleOverflow(scrollerSelector, IsOpen);
+        _offsetTop = await _js.BitUtilsToggleOverflow(scrollerSelector, IsOpen) ?? 0;
 
         if (AbsolutePosition is false) return;
 
diff --git a/src/BlazorUI/Bit.BlazorUI/Components/Utilities/PullToRefresh/BitPullToRefresh.razor.cs b/src/BlazorUI/Bit.BlazorUI/Components/Utilities/PullToRefresh/BitPullToRefresh.razor.cs
index dc1f2c25bf..2cbea71a92 100644
--- a/src/BlazorUI/Bit.BlazorUI/Components/Utilities/PullToRefresh/BitPullToRefresh.razor.cs
+++ b/src/BlazorUI/Bit.BlazorUI/Components/Utilities/PullToRefresh/BitPullToRefresh.razor.cs
@@ -10,6 +10,7 @@ public partial class BitPullToRefresh : BitComponentBase
     private decimal _diff;
     private bool _refreshing;
     private ElementReference _loadingRef = default!;
+    private DotNetObjectReference<BitPullToRefresh>? _dotnetObj;
 
 
 
@@ -144,8 +145,8 @@ protected override async Task OnAfterRenderAsync(bool firstRender)
     {
         if (firstRender)
         {
-            var dotnetObj = DotNetObjectReference.Create(this);
-            await _js.BitPullToRefreshSetup(UniqueId, RootElement, _loadingRef, ScrollerElement, ScrollerSelector, Trigger, Factor, Margin, Threshold, dotnetObj);
+            _dotnetObj = DotNetObjectReference.Create(this);
+            await _js.BitPullToRefreshSetup(UniqueId, RootElement, _loadingRef, ScrollerElement, ScrollerSelector, Trigger, Factor, Margin, Threshold, _dotnetObj);
         }
 
         await base.OnAfterRenderAsync(firstRender);
@@ -241,12 +242,31 @@ protected override async ValueTask DisposeAsync(bool disposing)
     {
         if (IsDisposed || disposing is false) return;
 
+        // Ownership of _dotnetObj is single-sourced to the JS dispose path: BitPullToRefresh.ts disposes
+        // the .NET reference in its dispose(). Disposing it here too would double-dispose the same object.
         try
         {
             await _js.BitPullToRefreshDispose(UniqueId);
         }
-        catch (JSDisconnectedException) { } // we can ignore this exception here
-
-        await base.DisposeAsync(disposing);
+        catch (JSDisconnectedException)
+        {
+            // The circuit/browser is gone, so the JS dispose that normally owns _dotnetObj can't run.
+            // Release the managed reference here so it doesn't leak.
+            _dotnetObj?.Dispose();
+            _dotnetObj = null;
+        }
+        catch
+        {
+            // Any other failure means the JS dispose didn't complete its ownership handoff, so release the
+            // managed reference here to avoid leaking it, then rethrow so the original error still surfaces.
+            _dotnetObj?.Dispose();
+            _dotnetObj = null;
+            throw;
+        }
+        finally
+        {
+            // Base cleanup must always run, even when the JS dispose failed and rethrew above.
+            await base.DisposeAsync(disposing);
+        }
     }
 }
diff --git a/src/BlazorUI/Bit.BlazorUI/Components/Utilities/PullToRefresh/BitPullToRefresh.ts b/src/BlazorUI/Bit.BlazorUI/Components/Utilities/PullToRefresh/BitPullToRefresh.ts
index 5391495c60..338c242071 100644
--- a/src/BlazorUI/Bit.BlazorUI/Components/Utilities/PullToRefresh/BitPullToRefresh.ts
+++ b/src/BlazorUI/Bit.BlazorUI/Components/Utilities/PullToRefresh/BitPullToRefresh.ts
@@ -138,7 +138,7 @@
         factor: number;
         margin: number;
         threshold: number;
-        dotnetObj: DotNetObject;
+        dotnetObj: DotNetObject | undefined;
         disposer: () => void = () => { };
 
         constructor(id: string,
@@ -168,7 +168,10 @@
 
         public dispose() {
             this.disposer();
+            // Let any failure from the .NET handoff surface so the C# DisposeAsync fallback can release
+            // _dotnetObj instead of silently leaking it. Clear the reference only after dispose() succeeds.
             this.dotnetObj?.dispose();
+            this.dotnetObj = undefined;
         }
     }
 }
\ No newline at end of file
diff --git a/src/BlazorUI/Bit.BlazorUI/Components/Utilities/PullToRefresh/BitPullToRefreshJsRuntimeExtensions.cs b/src/BlazorUI/Bit.BlazorUI/Components/Utilities/PullToRefresh/BitPullToRefreshJsRuntimeExtensions.cs
index bdc8410354..00f847c36a 100644
--- a/src/BlazorUI/Bit.BlazorUI/Components/Utilities/PullToRefresh/BitPullToRefreshJsRuntimeExtensions.cs
+++ b/src/BlazorUI/Bit.BlazorUI/Components/Utilities/PullToRefresh/BitPullToRefreshJsRuntimeExtensions.cs
@@ -1,6 +1,4 @@
-using System.Diagnostics.CodeAnalysis;
-
-namespace Bit.BlazorUI;
+namespace Bit.BlazorUI;
 
 internal static class BitPullToRefreshJsRuntimeExtensions
 {
@@ -14,13 +12,13 @@ internal static ValueTask BitPullToRefreshSetup(this IJSRuntime jsRuntime,
                                                                     decimal factor,
                                                                     int margin,
                                                                     int threshold,
-                                                                    DotNetObjectReference<BitPullToRefresh>? dotnetObjectReference)
+                                                                    DotNetObjectReference<BitPullToRefresh> dotnetObjectReference)
     {
-        return jsRuntime.InvokeVoid("BitBlazorUI.PullToRefresh.setup", id, anchor, loading, scrollerElement, scrollerSelector, trigger, factor, margin , threshold, dotnetObjectReference);
+        return jsRuntime.FastInvokeVoid("BitBlazorUI.PullToRefresh.setup", id, anchor, loading, scrollerElement, scrollerSelector, trigger, factor, margin, threshold, dotnetObjectReference);
     }
 
     internal static ValueTask BitPullToRefreshDispose(this IJSRuntime jsRuntime, string id)
     {
-        return jsRuntime.InvokeVoid("BitBlazorUI.PullToRefresh.dispose", id);
+        return jsRuntime.FastInvokeVoid("BitBlazorUI.PullToRefresh.dispose", id);
     }
 }
diff --git a/src/BlazorUI/Bit.BlazorUI/Components/Utilities/SwipeTrap/BitSwipeTrap.razor.cs b/src/BlazorUI/Bit.BlazorUI/Components/Utilities/SwipeTrap/BitSwipeTrap.razor.cs
index 5549d89862..554f16f9d6 100644
--- a/src/BlazorUI/Bit.BlazorUI/Components/Utilities/SwipeTrap/BitSwipeTrap.razor.cs
+++ b/src/BlazorUI/Bit.BlazorUI/Components/Utilities/SwipeTrap/BitSwipeTrap.razor.cs
@@ -7,6 +7,10 @@ namespace Bit.BlazorUI;
 /// </summary>
 public partial class BitSwipeTrap : BitComponentBase
 {
+    private DotNetObjectReference<BitSwipeTrap>? _dotnetObj;
+
+
+
     [Inject] private IJSRuntime _js { get; set; } = default!;
 
 
@@ -96,7 +100,7 @@ protected override async Task OnAfterRenderAsync(bool firstRender)
     {
         if (firstRender)
         {
-            var dotnetObj = DotNetObjectReference.Create(this);
+            _dotnetObj = DotNetObjectReference.Create(this);
             await _js.BitSwipeTrapSetup(
                 UniqueId, 
                 RootElement, 
@@ -104,7 +108,7 @@ await _js.BitSwipeTrapSetup(
                 Threshold ?? 0, 
                 Throttle ?? 0, 
                 OrientationLock ?? BitSwipeOrientation.None, 
-                dotnetObj);
+                _dotnetObj);
         }
 
         await base.OnAfterRenderAsync(firstRender);
@@ -116,12 +120,31 @@ protected override async ValueTask DisposeAsync(bool disposing)
     {
         if (IsDisposed || disposing is false) return;
 
+        // Ownership of _dotnetObj is single-sourced to the JS dispose path: BitSwipeTrap.ts disposes the
+        // .NET reference in its dispose(). Disposing it here too would double-dispose the same object.
         try
         {
             await _js.BitSwipeTrapDispose(UniqueId);
         }
-        catch (JSDisconnectedException) { } // we can ignore this exception here
-
-        await base.DisposeAsync(disposing);
+        catch (JSDisconnectedException)
+        {
+            // The circuit/browser is gone, so the JS dispose that normally owns _dotnetObj can't run.
+            // Release the managed reference here so it doesn't leak.
+            _dotnetObj?.Dispose();
+            _dotnetObj = null;
+        }
+        catch
+        {
+            // Any other failure means the JS dispose didn't complete its ownership handoff, so release the
+            // managed reference here to avoid leaking it, then rethrow so the original error still surfaces.
+            _dotnetObj?.Dispose();
+            _dotnetObj = null;
+            throw;
+        }
+        finally
+        {
+            // Base cleanup must always run, even when the JS dispose failed and rethrew above.
+            await base.DisposeAsync(disposing);
+        }
     }
 }
diff --git a/src/BlazorUI/Bit.BlazorUI/Components/Utilities/SwipeTrap/BitSwipeTrap.ts b/src/BlazorUI/Bit.BlazorUI/Components/Utilities/SwipeTrap/BitSwipeTrap.ts
index 90a55d87fc..8ed7606fd1 100644
--- a/src/BlazorUI/Bit.BlazorUI/Components/Utilities/SwipeTrap/BitSwipeTrap.ts
+++ b/src/BlazorUI/Bit.BlazorUI/Components/Utilities/SwipeTrap/BitSwipeTrap.ts
@@ -165,6 +165,8 @@
 
         public dispose() {
             this.removeHandlers();
+            // Let any failure from the .NET handoff surface so the C# DisposeAsync fallback can release
+            // _dotnetObj instead of silently leaking it.
             this.dotnetObj?.dispose();
         }
     }
diff --git a/src/BlazorUI/Bit.BlazorUI/Extensions/JsInterop/IJSRuntimeExtensions.cs b/src/BlazorUI/Bit.BlazorUI/Extensions/JsInterop/IJSRuntimeExtensions.cs
index ad822d6354..143e053628 100644
--- a/src/BlazorUI/Bit.BlazorUI/Extensions/JsInterop/IJSRuntimeExtensions.cs
+++ b/src/BlazorUI/Bit.BlazorUI/Extensions/JsInterop/IJSRuntimeExtensions.cs
@@ -1,12 +1,12 @@
 using System.Reflection;
+using System.Collections.Concurrent;
 using System.Diagnostics.CodeAnalysis;
+using static Bit.BlazorUI.JsInteropConstants;
 
 namespace Bit.BlazorUI;
 
 public static class IJSRuntimeExtensions
 {
-    public const DynamicallyAccessedMemberTypes JsonSerialized = DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.PublicProperties;
-
 
 
     /// <summary>
@@ -73,19 +73,67 @@ public static ValueTask InvokeVoid(this IJSRuntime jsRuntime, string identifier,
 
 
 
-    [SuppressMessage("Trimming", "IL2075:'this' argument does not satisfy 'DynamicallyAccessedMembersAttribute' in call to target method. The return value of the source method does not have matching annotations.", Justification = "<Pending>")]
+    // Cache the reflected framework members per runtime type. The runtime type is stable for the
+    // lifetime of the process, so this avoids repeating the reflection lookup on every interop call.
+    private static readonly ConcurrentDictionary<Type, PropertyInfo?> _remoteIsInitializedPropertyCache = new();
+    private static readonly ConcurrentDictionary<Type, FieldInfo?> _webViewIpcSenderFieldCache = new();
+
+    /// <summary>
+    /// Detects Blazor host runtimes where JavaScript interop must not be attempted.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// Matches framework implementations by runtime <c>Type.Name</c> and probes internal state via reflection.
+    /// This is unsupported by the ASP.NET Core team and may break on .NET upgrades; when a reflected member is
+    /// missing we treat the runtime as <em>valid</em> so calls fail loudly instead of being silently dropped.
+    /// </para>
+    /// <para>Upstream types (aspnetcore <c>main</c>):</para>
+    /// <list type="bullet">
+    /// <item><description><see href="https://github.com/dotnet/aspnetcore/blob/main/src/Components/Endpoints/src/DependencyInjection/UnsupportedJavaScriptRuntime.cs">UnsupportedJavaScriptRuntime</see> — static/prerender host</description></item>
+    /// <item><description><see href="https://github.com/dotnet/aspnetcore/blob/main/src/Components/Server/src/Circuits/RemoteJSRuntime.cs">RemoteJSRuntime</see> — reflects <c>IsInitialized</c></description></item>
+    /// <item><description><see href="https://github.com/dotnet/aspnetcore/blob/main/src/Components/WebView/WebView/src/Services/WebViewJSRuntime.cs">WebViewJSRuntime</see> — reflects <c>_ipcSender</c></description></item>
+    /// </list>
+    /// <para>Guarded by <c>IsRuntimeInvalidFrameworkContractTests</c>.</para>
+    /// </remarks>
+    [SuppressMessage("Trimming", "IL2075:'this' argument does not satisfy 'DynamicallyAccessedMembersAttribute' in call to target method. The return value of the source method does not have matching annotations.", Justification = "Reflection here only reads a well-known bool property (RemoteJSRuntime.IsInitialized) and a private field (WebViewJSRuntime._ipcSender) by name for host-runtime detection; no members are dynamically invoked or instantiated, and a missing member is handled by treating the runtime as valid, so trimming cannot break this probe.")]
     public static bool IsRuntimeInvalid(this IJSRuntime jsRuntime)
     {
-        if (jsRuntime is null) return false;
+        // A null runtime can't service interop, so report it as invalid. This lets the no-op paths in
+        // InvokeVoid/Invoke/FastInvoke skip the call instead of dereferencing null (the async fallback
+        // would otherwise throw ArgumentNullException from the framework's JSRuntimeExtensions).
+        if (jsRuntime is null) return true;
 
         var type = jsRuntime.GetType();
 
-        return type.Name switch
+        switch (type.Name)
         {
-            "UnsupportedJavaScriptRuntime" => true, // Prerendering
-            "RemoteJSRuntime" => (bool)type.GetProperty("IsInitialized")!.GetValue(jsRuntime)! is false, // Blazor server
-            "WebViewJSRuntime" => type.GetField("_ipcSender", BindingFlags.NonPublic | BindingFlags.Instance)!.GetValue(jsRuntime) is null, // Blazor Hybrid
-            _ => false // Blazor WASM
-        };
+            // https://github.com/dotnet/aspnetcore/blob/main/src/Components/Endpoints/src/DependencyInjection/UnsupportedJavaScriptRuntime.cs
+            case "UnsupportedJavaScriptRuntime": // Prerendering / static SSR
+                return true;
+
+            // https://github.com/dotnet/aspnetcore/blob/main/src/Components/Server/src/Circuits/RemoteJSRuntime.cs
+            case "RemoteJSRuntime": // Blazor Server
+                {
+                    // RemoteJSRuntime.IsInitialized is an internal framework member accessed via reflection.
+                    // If a future .NET release renames or removes it, fall back to treating the runtime as
+                    // valid so legitimate interop still runs (and any genuine failure surfaces as the
+                    // framework's own exception) instead of silently dropping every JS call.
+                    var property = _remoteIsInitializedPropertyCache.GetOrAdd(type, static t => t.GetProperty("IsInitialized"));
+                    return property?.GetValue(jsRuntime) is bool isInitialized && isInitialized is false;
+                }
+
+            // https://github.com/dotnet/aspnetcore/blob/main/src/Components/WebView/WebView/src/Services/WebViewJSRuntime.cs
+            case "WebViewJSRuntime": // Blazor Hybrid
+                {
+                    // WebViewJSRuntime._ipcSender is a private framework field accessed via reflection.
+                    // See the RemoteJSRuntime note above for the rationale behind the safe fallback.
+                    var field = _webViewIpcSenderFieldCache.GetOrAdd(type, static t => t.GetField("_ipcSender", BindingFlags.NonPublic | BindingFlags.Instance));
+                    if (field is null) return false;
+                    return field.GetValue(jsRuntime) is null;
+                }
+
+            default: // Blazor WASM and other valid runtimes
+                return false;
+        }
     }
 }
diff --git a/src/BlazorUI/Bit.BlazorUI/Extensions/JsInterop/IJSRuntimeFastExtensions.cs b/src/BlazorUI/Bit.BlazorUI/Extensions/JsInterop/IJSRuntimeFastExtensions.cs
index 3c018f9ab0..1c3efd3893 100644
--- a/src/BlazorUI/Bit.BlazorUI/Extensions/JsInterop/IJSRuntimeFastExtensions.cs
+++ b/src/BlazorUI/Bit.BlazorUI/Extensions/JsInterop/IJSRuntimeFastExtensions.cs
@@ -1,19 +1,197 @@
 using System.Text.Json;
+using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
+using Microsoft.JSInterop;
 using Microsoft.JSInterop.Infrastructure;
+using static Bit.BlazorUI.JsInteropConstants;
 
 namespace Bit.BlazorUI;
 
-[SuppressMessage("Trimming", "IL2026:Members annotated with 'RequiresUnreferencedCodeAttribute' require dynamic access otherwise can break functionality when trimming application code", Justification = "<Pending>", Scope = "member", Target = "~M:Bit.BlazorUI.IJSRuntimeFastExtensions.FastInvokeVoid(Microsoft.JSInterop.IJSRuntime,System.String,System.Threading.CancellationToken,System.Object[])~System.Threading.Tasks.ValueTask")]
+/// <summary>
+/// Extension methods that invoke JavaScript with the least possible overhead by using the synchronous
+/// <see cref="IJSInProcessRuntime"/> path when it is available (Blazor WebAssembly), and falling back to the
+/// regular asynchronous invocation otherwise (Blazor Server, Hybrid, and prerendering).
+/// </summary>
+/// <remarks>
+/// Threading caveat (multithreaded WebAssembly): the synchronous in-process path uses
+/// <see cref="IJSInProcessRuntime"/>, which on a multithreaded WebAssembly runtime
+/// (<c>&lt;WasmEnableThreads&gt;</c>) can only be used on the main thread. Invoking these methods from a
+/// background/pool thread (for example after <c>ConfigureAwait(false)</c>) would throw in that configuration.
+/// Default single-threaded WebAssembly is unaffected. Call these methods on the renderer's synchronization
+/// context (the default for component lifecycle and event callbacks).
+/// A best-effort <c>DEBUG</c>-only assertion (see <c>AssertInProcessInteropThread</c>) flags the common
+/// thread-pool case during development; it is compiled out of shipping builds so the fast path stays
+/// branch-free, and the framework still throws its own exception in that configuration at runtime.
+/// </remarks>
+[SuppressMessage("Trimming", "IL2026:Members annotated with 'RequiresUnreferencedCodeAttribute' require dynamic access otherwise can break functionality when trimming application code", Justification = "Interop arguments are JSON-serializable types owned by the framework/components; the JSON metadata they require is preserved by the [DynamicallyAccessedMembers(JsonSerialized)] annotations on the generic overloads and by the component models themselves, so the void path is safe to invoke under trimming.", Scope = "member", Target = "~M:Bit.BlazorUI.IJSRuntimeFastExtensions.FastInvokeVoid(Microsoft.JSInterop.IJSRuntime,System.String,System.Threading.CancellationToken,System.Object[])~System.Threading.Tasks.ValueTask")]
 public static class IJSRuntimeFastExtensions
 {
-    public const DynamicallyAccessedMemberTypes JsonSerialized = DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.PublicProperties;
+
+    /// <summary>
+    /// Optional handler for errors swallowed by the fast (in-process) invocation path on Blazor WebAssembly,
+    /// and for unexpected-null results reported via <see cref="ReportIfUnexpectedNull{T}"/> on any runtime.
+    /// </summary>
+    /// <remarks>
+    /// When a <see cref="JsonException"/> or <see cref="JSException"/> occurs while invoking JavaScript
+    /// synchronously, the call is not re-thrown (the operation returns its default result) so a single bad
+    /// interop call can't tear down the component, and the error is reported here so it remains observable.
+    /// <para>
+    /// Important: <see cref="JSException"/> covers more than a missing/unwired function. A correctly wired
+    /// synchronous JavaScript function whose own body throws (a real logic bug in the script) surfaces as the
+    /// same <see cref="JSException"/> and is therefore swallowed too - the call returns its default result and
+    /// the only signal is this report. Such errors previously propagated and tore down the call loudly; on the
+    /// fast path they no longer do. The default reporter (see <c>ReportError</c>) classifies the cause - a
+    /// missing/unwired function, an error thrown inside the function (a script bug), a serialization issue, or
+    /// an unexpected null - so the distinction is preserved in the message even without a custom handler.
+    /// Because of this, wiring <see cref="OnError"/> to a real logger should be treated as required in
+    /// production, not optional - it is the single channel through which both missing functions and in-body
+    /// logic errors remain visible.
+    /// </para>
+    /// <para>
+    /// This is a <em>process-global</em> hook. Assign it exactly once during application startup (before any
+    /// component renders) to route the report to a real logger (e.g. an <c>ILogger</c>); when left
+    /// <see langword="null"/> the error is written to <see cref="System.Console.Error"/> and a one-time warning
+    /// is emitted recommending that a handler be wired. The setter is not synchronized and the handler is shared
+    /// by every consumer in the process, so on Blazor Server it cannot carry per-circuit/per-user context -
+    /// capture any ambient state inside the handler accordingly. The handler receives the invoked identifier and
+    /// the caught exception, and must not throw (a throwing handler is caught and ignored).
+    /// </para>
+    /// </remarks>
+    public static Action<string, Exception>? OnError { get; set; }
+
+    // Tracks whether the "no OnError handler wired" warning has already been emitted, so the default reporter
+    // nags about observability exactly once instead of flooding the console on every swallowed error.
+    private static int _missingHandlerWarned;
+
+    private static void ReportError(string identifier, Exception exception)
+    {
+        var handler = OnError;
+        if (handler is null)
+        {
+            System.Console.Error.WriteLine(
+                $"Error invoking '{identifier}': {DescribeCause(exception)} {exception.Message}");
+
+            // Emit the "wire up OnError" guidance once. Without a handler these errors (including genuine
+            // in-body script bugs) are only visible on the console, so surface the recommendation a single time.
+            if (Interlocked.Exchange(ref _missingHandlerWarned, 1) == 0)
+            {
+                System.Console.Error.WriteLine(
+                    $"{nameof(IJSRuntimeFastExtensions)}.{nameof(OnError)} is not set. Swallowed fast-invoke interop " +
+                    "errors - including JavaScript functions that throw in their own body - are only reported to the " +
+                    "console. Assign a handler during startup to route them to a real logger.");
+            }
+
+            return;
+        }
+
+        try
+        {
+            handler(identifier, exception);
+        }
+        catch
+        {
+            // A faulty error handler must never escape the interop call and break the caller.
+        }
+    }
+
+    // Classifies a swallowed interop failure so the default console report distinguishes a missing/unwired
+    // function from a real script bug (a present function that threw), a serialization problem, or an
+    // unexpected null. This keeps the most actionable case - an in-body logic error - from hiding behind the
+    // same generic text as a simple typo'd identifier.
+    private static string DescribeCause(Exception exception) => exception switch
+    {
+        JsonException => "a JSON serialization issue occurred:",
+        JSException jsException when IsMissingFunctionError(jsException) => "the JavaScript function is missing or unwired:",
+        JSException => "the JavaScript function threw while executing (a script bug):",
+        InvalidOperationException => "the interop call produced an unexpected result:",
+        _ => "an unexpected error occurred:",
+    };
+
+    // Heuristic that recognizes the framework's "function not found" JSException by the phrasing the
+    // in-process runtime uses. It is intentionally conservative: when it can't tell, the cause is reported as
+    // an in-body script error (the louder, more actionable classification) rather than as a missing function.
+    private static bool IsMissingFunctionError(JSException jsException)
+    {
+        var message = jsException.Message;
+        return message.Contains("is not a function", StringComparison.OrdinalIgnoreCase)
+            || message.Contains("was undefined", StringComparison.OrdinalIgnoreCase)
+            || message.Contains("Could not find", StringComparison.OrdinalIgnoreCase);
+    }
+
+    /// <summary>
+    /// DEBUG-only guard for the synchronous in-process interop path. On a multithreaded WebAssembly runtime
+    /// (<c>&lt;WasmEnableThreads&gt;</c>) <see cref="IJSInProcessRuntime"/> may only be used on the main thread,
+    /// so running it from a thread-pool (background) thread - the usual outcome of a preceding
+    /// <c>ConfigureAwait(false)</c> - throws. This fails fast with an actionable message ahead of the
+    /// framework's lower-level exception. It is a heuristic: it covers the thread-pool case (not custom
+    /// background threads) and only runs in the browser, where single-threaded WASM has no thread pool so it
+    /// never false-fires. Marked <c>[Conditional("DEBUG")]</c> so the call and its argument evaluation are
+    /// removed entirely from shipping builds, keeping the fast path overhead-free.
+    /// </summary>
+    [Conditional("DEBUG")]
+    private static void AssertInProcessInteropThread(string identifier)
+    {
+        // Format the message only on failure: Debug.Assert(bool, string) evaluates its message argument
+        // eagerly, and these methods are hot paths, so building the string on every passing call would
+        // add needless allocations to DEBUG builds.
+        if (OperatingSystem.IsBrowser() && Thread.CurrentThread.IsThreadPoolThread)
+        {
+            Debug.Fail(
+                $"FastInvoke('{identifier}') ran synchronous in-process JS interop on a thread-pool thread. " +
+                "On multithreaded WebAssembly (<WasmEnableThreads>) this is only valid on the main thread and will throw. " +
+                "Invoke it on the renderer's synchronization context (component lifecycle/event callbacks) without a " +
+                "preceding ConfigureAwait(false), or use the regular asynchronous invocation instead.");
+        }
+    }
+
+    /// <summary>
+    /// When a FastInvoke call returns <see langword="null"/> and the runtime can service interop, reports the
+    /// missing result so component setup (drag/drop, pointer handlers, JS disposables, etc.) is not completely
+    /// silent. Skipped when <see cref="IJSRuntimeExtensions.IsRuntimeInvalid"/> is <see langword="true"/> (prerender,
+    /// disconnected circuit) where <see langword="null"/> is expected.
+    /// </summary>
+    /// <remarks>
+    /// Scope (deliberate asymmetry): the <c>where T : class</c> constraint means this only covers reference-type
+    /// results (<see cref="IJSObjectReference"/>, <see cref="string"/>, <c>BitFileInfo[]</c>). Value-type returns
+    /// that call sites request as nullable (<c>bool?</c>, <c>double?</c>, <c>float?</c>, <c>decimal?</c> in
+    /// Splitter, Utils, Chart, MarkdownViewer) are not routed through here; they are coalesced at the call site
+    /// (<c>?? 0</c>, <c>is true</c>), so a valid runtime that returns <see langword="null"/> <em>without</em> an
+    /// exception is silently treated as the default value rather than reported. This gap is narrow: the
+    /// <see cref="IJSRuntimeExtensions.IsRuntimeInvalid"/> case is legitimately silent for both reference and value
+    /// types (the <see langword="null"/> is expected), and a swallowed <see cref="JsonException"/> or
+    /// <see cref="JSException"/> is still reported via <see cref="OnError"/> for both. The only unreported case for
+    /// value types is "valid runtime, no exception, but the result was <see langword="null"/>", which is accepted
+    /// because a nullable value-type return is already distinguishable from a legitimate <c>false</c>/zero at the
+    /// call site (see the <c>FastInvoke</c> return remarks).
+    /// </remarks>
+    /// <remarks>
+    /// Only call this for identifiers whose JavaScript function is expected to <em>always</em> return a non-null
+    /// reference on a healthy runtime (e.g. <c>setup</c>/<c>init</c> helpers that hand back an id or a JS object
+    /// reference). A function that can legitimately return <see langword="null"/> on a valid runtime would be
+    /// reported here as a false positive; route those through a plain <c>FastInvoke</c> without this helper.
+    /// The report is raised as an <see cref="InvalidOperationException"/> so a wired <see cref="OnError"/> handler
+    /// can filter unexpected-null reports apart from <see cref="JSException"/>/<see cref="JsonException"/> ones.
+    /// </remarks>
+    public static T? ReportIfUnexpectedNull<T>(this IJSRuntime jsRuntime, string identifier, T? result)
+        where T : class
+    {
+        if (result is not null || jsRuntime.IsRuntimeInvalid()) return result;
+
+        ReportError(identifier, new InvalidOperationException("The interop call completed without a result."));
+        return null;
+    }
 
 
 
     /// <summary>
     /// Invokes the specified JavaScript function with the fastest speed possible.
     /// </summary>
+    /// <remarks>
+    /// In Blazor WebAssembly the call runs synchronously through <see cref="IJSInProcessRuntime"/>, so the
+    /// target JavaScript function must be synchronous. Targeting an asynchronous (Promise-returning) function
+    /// turns this into a fire-and-forget call: the caller continues before the work finishes and any error is lost.
+    /// Use the regular asynchronous invocation for asynchronous JavaScript functions.
+    /// </remarks>
     /// <param name="identifier">An identifier for the function to invoke. For example, the value <c>"someScope.someFunction"</c> will invoke the function <c>window.someScope.someFunction</c>.</param>
     /// <param name="args">JSON-serializable arguments.</param>
     public static ValueTask FastInvokeVoid(this IJSRuntime jsRuntime, string identifier, params object?[]? args)
@@ -24,20 +202,39 @@ public static ValueTask FastInvokeVoid(this IJSRuntime jsRuntime, string identif
     /// <summary>
     /// Invokes the specified JavaScript function with the fastest speed possible.
     /// </summary>
+    /// <remarks>
+    /// In Blazor WebAssembly the call runs synchronously through <see cref="IJSInProcessRuntime"/>, so the
+    /// target JavaScript function must be synchronous. Targeting an asynchronous (Promise-returning) function
+    /// turns this into a fire-and-forget call: the caller continues before the work finishes and any error is lost.
+    /// Use the regular asynchronous invocation for asynchronous JavaScript functions.
+    /// </remarks>
     /// <param name="identifier">An identifier for the function to invoke. For example, the value <c>"someScope.someFunction"</c> will invoke the function <c>window.someScope.someFunction</c>.</param>
     /// <param name="timeout">The duration after which to cancel the async operation. Overrides default timeouts (<see cref="JSRuntime.DefaultAsyncTimeout"/>).</param>
     /// <param name="args">JSON-serializable arguments.</param>
-    public static ValueTask FastInvokeVoid(this IJSRuntime jsRuntime, string identifier, TimeSpan timeout, params object?[]? args)
+    public static async ValueTask FastInvokeVoid(this IJSRuntime jsRuntime, string identifier, TimeSpan timeout, params object?[]? args)
     {
+        // The CancellationTokenSource must stay alive until the underlying invocation completes.
+        // Awaiting here (instead of returning the ValueTask) keeps the `using` scope open for the
+        // full duration of the async path, so the timeout can actually fire and the source isn't
+        // disposed while a callback is still registered on its token.
+        // Note: the timeout only has an effect on the asynchronous fallback path (Server/Hybrid). On
+        // WebAssembly the call runs synchronously through IJSInProcessRuntime, which ignores the token, so
+        // the CancellationTokenSource is created but never observed there.
         using var cancellationTokenSource = timeout == Timeout.InfiniteTimeSpan ? null : new CancellationTokenSource(timeout);
         var cancellationToken = cancellationTokenSource?.Token ?? CancellationToken.None;
 
-        return FastInvokeVoid(jsRuntime, identifier, cancellationToken, args);
+        await FastInvokeVoid(jsRuntime, identifier, cancellationToken, args);
     }
 
     /// <summary>
     /// Invokes the specified JavaScript function with the fastest speed possible.
     /// </summary>
+    /// <remarks>
+    /// In Blazor WebAssembly the call runs synchronously through <see cref="IJSInProcessRuntime"/>, so the
+    /// target JavaScript function must be synchronous. Targeting an asynchronous (Promise-returning) function
+    /// turns this into a fire-and-forget call: the caller continues before the work finishes and any error is lost.
+    /// Use the regular asynchronous invocation for asynchronous JavaScript functions.
+    /// </remarks>
     /// <param name="identifier">An identifier for the function to invoke. For example, the value <c>"someScope.someFunction"</c> will invoke the function <c>window.someScope.someFunction</c>.</param>
     /// <param name="cancellationToken">
     /// A cancellation token to signal the cancellation of the operation. Specifying this parameter will override any default cancellations such as due to timeouts
@@ -46,22 +243,36 @@ public static ValueTask FastInvokeVoid(this IJSRuntime jsRuntime, string identif
     /// <param name="args">JSON-serializable arguments.</param>
     public static ValueTask FastInvokeVoid(this IJSRuntime jsRuntime, string identifier, CancellationToken cancellationToken, params object?[]? args)
     {
+        // Hold both invocation paths to the same contract: skip the call when the runtime can't service
+        // interop (prerendering, an uninitialized Blazor Server circuit, or a disposed WebView). The async
+        // fallback already guards this inside InvokeVoid; checking here means the synchronous in-process
+        // path no-ops too instead of throwing. For a normal WASM runtime this is a cheap, false-returning
+        // check. A missing JS function - and any error thrown inside a present synchronous JS function - then
+        // surfaces as a swallowed <see cref="JSException"/> routed through <see cref="OnError"/> rather than
+        // an unhandled synchronous throw.
+        if (jsRuntime.IsRuntimeInvalid()) return ValueTask.CompletedTask;
+
         if (jsRuntime is IJSInProcessRuntime jsInProcessRuntime)
         {
+            AssertInProcessInteropThread(identifier);
             try
             {
                 jsInProcessRuntime.Invoke<IJSVoidResult>(identifier, args);
                 return ValueTask.CompletedTask;
             }
-            catch (JsonException ex)
+            // Swallows both a missing/unwired function and an error thrown inside a present synchronous JS
+            // function (a real script bug) - they arrive as the same JSException. See OnError remarks.
+            catch (Exception ex) when (ex is JsonException or JSException)
             {
-                System.Console.Error.WriteLine($"Error invoking '{identifier}' using {nameof(IJSInProcessRuntime)}. A JSON-related issue occurred: {ex.Message}.");
+                ReportError(identifier, ex);
                 return ValueTask.CompletedTask;
             }
         }
         else
         {
-            return jsRuntime.InvokeVoid(identifier, cancellationToken, args);
+            // The runtime-validity guard already ran above, so skip the re-checking bit InvokeVoid
+            // extension and call the framework's asynchronous interop directly.
+            return jsRuntime.InvokeVoidAsync(identifier, cancellationToken, args);
         }
     }
 
@@ -69,12 +280,22 @@ public static ValueTask FastInvokeVoid(this IJSRuntime jsRuntime, string identif
 
     /// <summary>
     /// Invokes the specified JavaScript function with the fastest speed possible.
-    /// Note: In Blazor WebAssembly mode, use this method only for synchronous JavaScript functions.
     /// </summary>
+    /// <remarks>
+    /// In Blazor WebAssembly the call runs synchronously through <see cref="IJSInProcessRuntime"/>, so the
+    /// target JavaScript function must be synchronous. Targeting an asynchronous (Promise-returning) function
+    /// turns this into a fire-and-forget call: the caller continues before the work finishes and any error is lost.
+    /// Use the regular asynchronous invocation for asynchronous JavaScript functions.
+    /// </remarks>
     /// <typeparam name="TValue">The JSON-serializable return type.</typeparam>
     /// <param name="identifier">An identifier for the function to invoke. For example, the value <c>"someScope.someFunction"</c> will invoke the function <c>window.someScope.someFunction</c>.</param>
     /// <param name="args">JSON-serializable arguments.</param>
-    /// <returns>An instance of <typeparamref name="TValue"/> obtained by JSON-deserializing the return value.</returns>
+    /// <returns>
+    /// An instance of <typeparamref name="TValue"/> obtained by JSON-deserializing the return value.
+    /// When <typeparamref name="TValue"/> is a non-nullable value type, prefer a nullable form (e.g. <see cref="bool"/> → <see cref="Nullable{T}"/>)
+    /// at call sites so a swallowed interop error (<see langword="default"/>, which is <see langword="null"/> for nullable value types)
+    /// is distinguishable from a legitimate JavaScript return of <see langword="false"/> or zero.
+    /// </returns>
     public static ValueTask<TValue> FastInvoke<[DynamicallyAccessedMembers(JsonSerialized)] TValue>(this IJSRuntime jsRuntime, string identifier, params object?[]? args)
     {
         return FastInvoke<TValue>(jsRuntime, identifier, CancellationToken.None, args);
@@ -82,25 +303,42 @@ public static ValueTask FastInvokeVoid(this IJSRuntime jsRuntime, string identif
 
     /// <summary>
     /// Invokes the specified JavaScript function with the fastest speed possible.
-    /// Note: In Blazor WebAssembly mode, use this method only for synchronous JavaScript functions.
     /// </summary>
+    /// <remarks>
+    /// In Blazor WebAssembly the call runs synchronously through <see cref="IJSInProcessRuntime"/>, so the
+    /// target JavaScript function must be synchronous. Targeting an asynchronous (Promise-returning) function
+    /// turns this into a fire-and-forget call: the caller continues before the work finishes and any error is lost.
+    /// Use the regular asynchronous invocation for asynchronous JavaScript functions.
+    /// </remarks>
     /// <typeparam name="TValue">The JSON-serializable return type.</typeparam>
     /// <param name="identifier">An identifier for the function to invoke. For example, the value <c>"someScope.someFunction"</c> will invoke the function <c>window.someScope.someFunction</c>.</param>
     /// <param name="timeout">The duration after which to cancel the async operation. Overrides default timeouts (<see cref="JSRuntime.DefaultAsyncTimeout"/>).</param>
     /// <param name="args">JSON-serializable arguments.</param>
-    /// <returns>An instance of <typeparamref name="TValue"/> obtained by JSON-deserializing the return value.</returns>
-    public static ValueTask<TValue> FastInvoke<[DynamicallyAccessedMembers(JsonSerialized)] TValue>(this IJSRuntime jsRuntime, string identifier, TimeSpan timeout, params object?[]? args)
+    /// <inheritdoc cref="FastInvoke{TValue}(IJSRuntime, string, object?[])"/>
+    public static async ValueTask<TValue> FastInvoke<[DynamicallyAccessedMembers(JsonSerialized)] TValue>(this IJSRuntime jsRuntime, string identifier, TimeSpan timeout, params object?[]? args)
     {
+        // The CancellationTokenSource must stay alive until the underlying invocation completes.
+        // Awaiting here (instead of returning the ValueTask) keeps the `using` scope open for the
+        // full duration of the async path, so the timeout can actually fire and the source isn't
+        // disposed while a callback is still registered on its token.
+        // Note: the timeout only has an effect on the asynchronous fallback path (Server/Hybrid). On
+        // WebAssembly the call runs synchronously through IJSInProcessRuntime, which ignores the token, so
+        // the CancellationTokenSource is created but never observed there.
         using var cancellationTokenSource = timeout == Timeout.InfiniteTimeSpan ? null : new CancellationTokenSource(timeout);
         var cancellationToken = cancellationTokenSource?.Token ?? CancellationToken.None;
 
-        return FastInvoke<TValue>(jsRuntime, identifier, cancellationToken, args);
+        return await FastInvoke<TValue>(jsRuntime, identifier, cancellationToken, args);
     }
 
     /// <summary>
     /// Invokes the specified JavaScript function with the fastest speed possible.
-    /// Note: In Blazor WebAssembly mode, use this method only for synchronous JavaScript functions.
     /// </summary>
+    /// <remarks>
+    /// In Blazor WebAssembly the call runs synchronously through <see cref="IJSInProcessRuntime"/>, so the
+    /// target JavaScript function must be synchronous. Targeting an asynchronous (Promise-returning) function
+    /// turns this into a fire-and-forget call: the caller continues before the work finishes and any error is lost.
+    /// Use the regular asynchronous invocation for asynchronous JavaScript functions.
+    /// </remarks>
     /// <typeparam name="TValue">The JSON-serializable return type.</typeparam>
     /// <param name="identifier">An identifier for the function to invoke. For example, the value <c>"someScope.someFunction"</c> will invoke the function <c>window.someScope.someFunction</c>.</param>
     /// <param name="cancellationToken">
@@ -108,24 +346,33 @@ public static ValueTask FastInvokeVoid(this IJSRuntime jsRuntime, string identif
     /// (<see cref="JSRuntime.DefaultAsyncTimeout"/>) from being applied.
     /// </param>
     /// <param name="args">JSON-serializable arguments.</param>
-    /// <returns>An instance of <typeparamref name="TValue"/> obtained by JSON-deserializing the return value.</returns>
+    /// <inheritdoc cref="FastInvoke{TValue}(IJSRuntime, string, object?[])"/>
     public static ValueTask<TValue> FastInvoke<[DynamicallyAccessedMembers(JsonSerialized)] TValue>(this IJSRuntime jsRuntime, string identifier, CancellationToken cancellationToken, params object?[]? args)
     {
+        // See FastInvokeVoid for the rationale: keep the synchronous in-process path and the async
+        // fallback consistent by skipping the call when the runtime can't service interop.
+        if (jsRuntime.IsRuntimeInvalid()) return ValueTask.FromResult(default(TValue)!);
+
         if (jsRuntime is IJSInProcessRuntime jsInProcessRuntime)
         {
+            AssertInProcessInteropThread(identifier);
             try
             {
                 return ValueTask.FromResult(jsInProcessRuntime.Invoke<TValue>(identifier, args));
             }
-            catch (JsonException ex)
+            // Swallows both a missing/unwired function and an error thrown inside a present synchronous JS
+            // function (a real script bug) - they arrive as the same JSException. See OnError remarks.
+            catch (Exception ex) when (ex is JsonException or JSException)
             {
-                System.Console.Error.WriteLine($"Error invoking '{identifier}' using {nameof(IJSInProcessRuntime)}. A JSON-related issue occurred: {ex.Message}.");
+                ReportError(identifier, ex);
                 return ValueTask.FromResult(default(TValue)!);
             }
         }
         else
         {
-            return jsRuntime.Invoke<TValue>(identifier, cancellationToken, args);
+            // The runtime-validity guard already ran above, so skip the re-checking bit Invoke
+            // extension and call the framework's asynchronous interop directly.
+            return jsRuntime.InvokeAsync<TValue>(identifier, cancellationToken, args);
         }
     }
 }
diff --git a/src/BlazorUI/Bit.BlazorUI/Extensions/JsInterop/JsInteropConstants.cs b/src/BlazorUI/Bit.BlazorUI/Extensions/JsInterop/JsInteropConstants.cs
new file mode 100644
index 0000000000..d0379cb0f0
--- /dev/null
+++ b/src/BlazorUI/Bit.BlazorUI/Extensions/JsInterop/JsInteropConstants.cs
@@ -0,0 +1,12 @@
+using System.Diagnostics.CodeAnalysis;
+
+namespace Bit.BlazorUI;
+
+internal static class JsInteropConstants
+{
+    /// <summary>
+    /// The set of <see cref="DynamicallyAccessedMemberTypes"/> required to preserve the JSON metadata
+    /// of types that are serialized/deserialized across JS interop, so they survive trimming.
+    /// </summary>
+    public const DynamicallyAccessedMemberTypes JsonSerialized = DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.PublicProperties;
+}
diff --git a/src/BlazorUI/Bit.BlazorUI/Extensions/JsInterop/UtilsJsRuntimeExtensions.cs b/src/BlazorUI/Bit.BlazorUI/Extensions/JsInterop/UtilsJsRuntimeExtensions.cs
index b57f48cdf7..c1e217af40 100644
--- a/src/BlazorUI/Bit.BlazorUI/Extensions/JsInterop/UtilsJsRuntimeExtensions.cs
+++ b/src/BlazorUI/Bit.BlazorUI/Extensions/JsInterop/UtilsJsRuntimeExtensions.cs
@@ -2,55 +2,57 @@
 
 internal static class UtilsJsRuntimeExtensions
 {
-    internal static ValueTask<decimal> BitUtilsGetBodyWidth(this IJSRuntime jsRuntime)
+    // FastInvoke returns null when the runtime can't service interop or a JSON/JS interop error is
+    // swallowed on the in-process (WASM) path. Nullable distinguishes that from a legitimate 0 width.
+    internal static ValueTask<decimal?> BitUtilsGetBodyWidth(this IJSRuntime jsRuntime)
     {
-        return jsRuntime.Invoke<decimal>("BitBlazorUI.Utils.getBodyWidth");
+        return jsRuntime.FastInvoke<decimal?>("BitBlazorUI.Utils.getBodyWidth");
     }
 
 
     internal static ValueTask BitUtilsSetProperty(this IJSRuntime jsRuntime, ElementReference element, string property, object? value)
     {
-        return jsRuntime.InvokeVoid("BitBlazorUI.Utils.setProperty", element, property, value);
+        return jsRuntime.FastInvokeVoid("BitBlazorUI.Utils.setProperty", element, property, value);
     }
 
 
-    internal static ValueTask<string> BitUtilsGetProperty(this IJSRuntime jsRuntime, ElementReference element, string property)
+    internal static ValueTask<string?> BitUtilsGetProperty(this IJSRuntime jsRuntime, ElementReference element, string property)
     {
-        return jsRuntime.Invoke<string>("BitBlazorUI.Utils.getProperty", element, property);
+        return jsRuntime.FastInvoke<string?>("BitBlazorUI.Utils.getProperty", element, property);
     }
 
 
-    internal static ValueTask<BoundingClientRect> BitUtilsGetBoundingClientRect(this IJSRuntime jsRuntime, ElementReference element)
+    internal static ValueTask<BoundingClientRect?> BitUtilsGetBoundingClientRect(this IJSRuntime jsRuntime, ElementReference element)
     {
-        return jsRuntime.Invoke<BoundingClientRect>("BitBlazorUI.Utils.getBoundingClientRect", element);
+        return jsRuntime.FastInvoke<BoundingClientRect?>("BitBlazorUI.Utils.getBoundingClientRect", element);
     }
 
 
     internal static ValueTask BitUtilsScrollElementIntoView(this IJSRuntime jsRuntime, string targetElementId)
     {
-        return jsRuntime.InvokeVoid("BitBlazorUI.Utils.scrollElementIntoView", targetElementId);
+        return jsRuntime.FastInvokeVoid("BitBlazorUI.Utils.scrollElementIntoView", targetElementId);
     }
 
 
     internal static ValueTask BitUtilsSelectText(this IJSRuntime jsRuntime, ElementReference element)
     {
-        return jsRuntime.InvokeVoid("BitBlazorUI.Utils.selectText", element);
+        return jsRuntime.FastInvokeVoid("BitBlazorUI.Utils.selectText", element);
     }
 
 
     internal static ValueTask BitUtilsSetStyle(this IJSRuntime jsRuntime, ElementReference element, string key, string value)
     {
-        return jsRuntime.InvokeVoid("BitBlazorUI.Utils.setStyle", element, key, value);
+        return jsRuntime.FastInvokeVoid("BitBlazorUI.Utils.setStyle", element, key, value);
     }
 
 
-    internal static ValueTask<float> BitUtilsToggleOverflow(this IJSRuntime jsRuntime, string scrollerSelector, bool isHidden)
+    internal static ValueTask<float?> BitUtilsToggleOverflow(this IJSRuntime jsRuntime, string scrollerSelector, bool isHidden)
     {
-        return jsRuntime.Invoke<float>("BitBlazorUI.Utils.toggleOverflow", scrollerSelector, isHidden);
+        return jsRuntime.FastInvoke<float?>("BitBlazorUI.Utils.toggleOverflow", scrollerSelector, isHidden);
     }
 
-    internal static ValueTask<float> BitUtilsToggleOverflow(this IJSRuntime jsRuntime, ElementReference scrollerElement, bool isHidden)
+    internal static ValueTask<float?> BitUtilsToggleOverflow(this IJSRuntime jsRuntime, ElementReference scrollerElement, bool isHidden)
     {
-        return jsRuntime.Invoke<float>("BitBlazorUI.Utils.toggleOverflow", scrollerElement, isHidden);
+        return jsRuntime.FastInvoke<float?>("BitBlazorUI.Utils.toggleOverflow", scrollerElement, isHidden);
     }
 }
diff --git a/src/BlazorUI/Bit.BlazorUI/Scripts/PageVisibility.ts b/src/BlazorUI/Bit.BlazorUI/Scripts/PageVisibility.ts
index 9cb7646fdf..6b4fc826d9 100644
--- a/src/BlazorUI/Bit.BlazorUI/Scripts/PageVisibility.ts
+++ b/src/BlazorUI/Bit.BlazorUI/Scripts/PageVisibility.ts
@@ -1,13 +1,27 @@
 namespace BitBlazorUI {
     export class PageVisibility {
         private static _isInitialized = false;
+        private static _handler?: () => void;
 
         public static init(dotnetObj: DotNetObject) {
             if (PageVisibility._isInitialized) return;
 
             PageVisibility._isInitialized = true;
 
-            document.addEventListener('visibilitychange', () => dotnetObj.invokeMethodAsync('VisibilityChanged', document.hidden));
+            PageVisibility._handler = () => dotnetObj.invokeMethodAsync('VisibilityChanged', document.hidden);
+
+            document.addEventListener('visibilitychange', PageVisibility._handler);
+        }
+
+        public static dispose() {
+            if (!PageVisibility._isInitialized) return;
+
+            if (PageVisibility._handler) {
+                document.removeEventListener('visibilitychange', PageVisibility._handler);
+                PageVisibility._handler = undefined;
+            }
+
+            PageVisibility._isInitialized = false;
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/BlazorUI/Bit.BlazorUI/Scripts/Swipes.ts b/src/BlazorUI/Bit.BlazorUI/Scripts/Swipes.ts
index f20da89bec..46eaac9920 100644
--- a/src/BlazorUI/Bit.BlazorUI/Scripts/Swipes.ts
+++ b/src/BlazorUI/Bit.BlazorUI/Scripts/Swipes.ts
@@ -256,8 +256,14 @@
 
         public dispose() {
             this.disposer();
-            this.dotnetObj?.dispose();
-            this.dotnetObj = undefined;
+            // Let any teardown failure from dotnetObj.dispose() surface (consistent with the other disposal
+            // paths in this cohort) instead of swallowing it, but still clear the reference afterwards so the
+            // failure signal is preserved before dotnetObj is set to undefined.
+            try {
+                this.dotnetObj?.dispose();
+            } finally {
+                this.dotnetObj = undefined;
+            }
         }
     }
 
diff --git a/src/BlazorUI/Bit.BlazorUI/Scripts/Utils.ts b/src/BlazorUI/Bit.BlazorUI/Scripts/Utils.ts
index 796ee99413..2624771b8a 100644
--- a/src/BlazorUI/Bit.BlazorUI/Scripts/Utils.ts
+++ b/src/BlazorUI/Bit.BlazorUI/Scripts/Utils.ts
@@ -83,14 +83,18 @@
             }
         }
 
-        public static getBoundingClientRect(element: HTMLElement): Partial<DOMRect> {
-            if (!element) return {};
+        public static getBoundingClientRect(element: HTMLElement): DOMRect | null {
+            // Returns null (not {}) on any failure. The C# signature is BoundingClientRect?, and an empty
+            // object would deserialize into a non-null rect with all-zero dimensions, defeating the caller's
+            // null checks and letting components (Carousel, ColorPicker, CircularTimePicker, ...) proceed
+            // with bogus geometry. Null makes a JS-side failure indistinguishable from "no element".
+            if (!element || typeof element.getBoundingClientRect !== 'function') return null;
 
             try {
-                return element.getBoundingClientRect?.();
+                return element.getBoundingClientRect();
             } catch (e) {
                 console.error("BitBlazorUI.Utils.getBoundingClientRect:", e);
-                return {};
+                return null;
             }
         }
 
diff --git a/src/BlazorUI/Bit.BlazorUI/Utils/BitPageVisibility.cs b/src/BlazorUI/Bit.BlazorUI/Utils/BitPageVisibility.cs
index 2dc975095f..2d900fb8e9 100644
--- a/src/BlazorUI/Bit.BlazorUI/Utils/BitPageVisibility.cs
+++ b/src/BlazorUI/Bit.BlazorUI/Utils/BitPageVisibility.cs
@@ -5,7 +5,7 @@
 /// <br />
 /// <see href="https://developer.mozilla.org/en-US/docs/Web/API/Page_Visibility_API"/>
 /// </summary>
-public class BitPageVisibility(IJSRuntime js)
+public class BitPageVisibility(IJSRuntime js) : IAsyncDisposable
 {
     private bool _isInitialized;
     private DotNetObjectReference<BitPageVisibility>? _dotnetObj;
@@ -45,4 +45,30 @@ public async Task _VisibilityChanged(bool hidden)
         }
     }
 
+
+
+    public async ValueTask DisposeAsync()
+    {
+        if (_isInitialized)
+        {
+            // Awaits the JS teardown so the global visibilitychange listener is actually cleared and any
+            // failure surfaces instead of being swallowed by a fire-and-forget call. The JS-side init guard
+            // is reset too, so a future instance can re-init.
+            try
+            {
+                await js.InvokeVoid("BitBlazorUI.PageVisibility.dispose");
+            }
+            catch (JSDisconnectedException) { } // circuit already gone; nothing to clean up on the JS side
+            finally
+            {
+                // Local cleanup runs in finally so it always executes even if the JS teardown throws
+                // something other than JSDisconnectedException (e.g. JSException, OperationCanceledException,
+                // InvalidOperationException), guaranteeing deterministic disposal.
+                _isInitialized = false;
+                _dotnetObj?.Dispose();
+            }
+        }
+
+        GC.SuppressFinalize(this);
+    }
 }
diff --git a/src/BlazorUI/Tests/Bit.BlazorUI.Tests/Bit.BlazorUI.Tests.csproj b/src/BlazorUI/Tests/Bit.BlazorUI.Tests/Bit.BlazorUI.Tests.csproj
index 7715a1ee5c..9ea44472d4 100644
--- a/src/BlazorUI/Tests/Bit.BlazorUI.Tests/Bit.BlazorUI.Tests.csproj
+++ b/src/BlazorUI/Tests/Bit.BlazorUI.Tests/Bit.BlazorUI.Tests.csproj
@@ -17,9 +17,17 @@
       <Compile Include="..\..\Bit.BlazorUI\Extensions\StringExtensions.cs" Link="Extensions\StringExtensions.cs" />
     </ItemGroup>
 
+    <ItemGroup>
+        <FrameworkReference Include="Microsoft.AspNetCore.App" />
+    </ItemGroup>
+
     <ItemGroup>
         <PackageReference Include="bunit.web" Version="1.40.0" />
         <PackageReference Include="MSTest" Version="4.2.3" />
+        <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.14.0" />
+        <PackageReference Condition="'$(TargetFramework)' == 'net8.0'" Include="Microsoft.AspNetCore.Components.WebView" Version="8.0.0" />
+        <PackageReference Condition="'$(TargetFramework)' == 'net9.0'" Include="Microsoft.AspNetCore.Components.WebView" Version="9.0.0" />
+        <PackageReference Condition="'$(TargetFramework)' == 'net10.0'" Include="Microsoft.AspNetCore.Components.WebView" Version="10.0.0" />
     </ItemGroup>
 
     <ItemGroup>
diff --git a/src/BlazorUI/Tests/Bit.BlazorUI.Tests/Components/Extras/AppShell/BitAppShellTests.cs b/src/BlazorUI/Tests/Bit.BlazorUI.Tests/Components/Extras/AppShell/BitAppShellTests.cs
index 56fc3ef9a1..e97b776c45 100644
--- a/src/BlazorUI/Tests/Bit.BlazorUI.Tests/Components/Extras/AppShell/BitAppShellTests.cs
+++ b/src/BlazorUI/Tests/Bit.BlazorUI.Tests/Components/Extras/AppShell/BitAppShellTests.cs
@@ -486,9 +486,9 @@ public void BitAppShellShouldRespectVisibilityChangingAfterRender()
     [TestMethod]
     public void BitAppShellShouldPersistScroll()
     {
-        Context.JSInterop.SetupVoid("BitBlazorUI.AppShell.initScroll");
+        Context.JSInterop.SetupVoid("BitBlazorUI.AppShell.initScroll").SetVoidResult();
         Context.JSInterop.SetupVoid("BitBlazorUI.AppShell.locationChangedScroll");
-        Context.JSInterop.SetupVoid("BitBlazorUI.AppShell.afterRenderScroll");
+        Context.JSInterop.SetupVoid("BitBlazorUI.AppShell.afterRenderScroll").SetVoidResult();
 
         var component = RenderComponent<BitAppShell>(parameters =>
         {
@@ -509,7 +509,7 @@ public void BitAppShellShouldPersistScroll()
     [TestMethod]
     public void BitAppShellShouldNotCallLocationChangedScrollWhenNotYetRendered()
     {
-        Context.JSInterop.SetupVoid("BitBlazorUI.AppShell.initScroll");
+        Context.JSInterop.SetupVoid("BitBlazorUI.AppShell.initScroll").SetVoidResult();
         Context.JSInterop.SetupVoid("BitBlazorUI.AppShell.locationChangedScroll");
 
         // We need to verify that locationChangedScroll is only called after the component has rendered
@@ -544,7 +544,7 @@ public void BitAppShellShouldGoToTopWhenAutoGoToTop()
     public void BitAppShellShouldNotSubscribeToLocationChangedWhenBothAutoGoToTopAndPersistScrollAreFalse()
     {
         Context.JSInterop.SetupVoid("BitBlazorUI.Extras.goToTop");
-        Context.JSInterop.SetupVoid("BitBlazorUI.AppShell.initScroll");
+        Context.JSInterop.SetupVoid("BitBlazorUI.AppShell.initScroll").SetVoidResult();
         Context.JSInterop.SetupVoid("BitBlazorUI.AppShell.locationChangedScroll");
 
         var component = RenderComponent<BitAppShell>(parameters =>
@@ -722,7 +722,7 @@ public void BitAppShellMainContainerShouldHaveCorrectId()
     [TestMethod]
     public void BitAppShellShouldCallInitScrollOnFirstRenderWithPersistScroll()
     {
-        Context.JSInterop.SetupVoid("BitBlazorUI.AppShell.initScroll");
+        Context.JSInterop.SetupVoid("BitBlazorUI.AppShell.initScroll").SetVoidResult();
 
         var component = RenderComponent<BitAppShell>(parameters =>
         {
@@ -735,8 +735,8 @@ public void BitAppShellShouldCallInitScrollOnFirstRenderWithPersistScroll()
     [TestMethod]
     public void BitAppShellShouldDisposeCorrectly()
     {
-        Context.JSInterop.SetupVoid("BitBlazorUI.AppShell.initScroll");
-        Context.JSInterop.SetupVoid("BitBlazorUI.AppShell.disposeScroll");
+        Context.JSInterop.SetupVoid("BitBlazorUI.AppShell.initScroll").SetVoidResult();
+        Context.JSInterop.SetupVoid("BitBlazorUI.AppShell.disposeScroll").SetVoidResult();
 
         var component = RenderComponent<BitAppShell>(parameters =>
         {
@@ -863,7 +863,7 @@ public void BitAppShellShouldNotGoToTopWhenAutoGoToTopIsFalse()
     [TestMethod]
     public void BitAppShellShouldNotPersistScrollWhenPersistScrollIsFalse()
     {
-        Context.JSInterop.SetupVoid("BitBlazorUI.AppShell.initScroll");
+        Context.JSInterop.SetupVoid("BitBlazorUI.AppShell.initScroll").SetVoidResult();
         Context.JSInterop.SetupVoid("BitBlazorUI.AppShell.locationChangedScroll");
 
         var component = RenderComponent<BitAppShell>(parameters =>
@@ -881,7 +881,7 @@ public void BitAppShellShouldNotPersistScrollWhenPersistScrollIsFalse()
     [TestMethod]
     public void BitAppShellShouldPrioritizePersistScrollOverAutoGoToTop()
     {
-        Context.JSInterop.SetupVoid("BitBlazorUI.AppShell.initScroll");
+        Context.JSInterop.SetupVoid("BitBlazorUI.AppShell.initScroll").SetVoidResult();
         Context.JSInterop.SetupVoid("BitBlazorUI.AppShell.locationChangedScroll");
         Context.JSInterop.SetupVoid("BitBlazorUI.Extras.goToTop");
 
diff --git a/src/BlazorUI/Tests/Bit.BlazorUI.Tests/Extensions/JsInterop/FastInvokeSyncContractTests.cs b/src/BlazorUI/Tests/Bit.BlazorUI.Tests/Extensions/JsInterop/FastInvokeSyncContractTests.cs
new file mode 100644
index 0000000000..db68dcbe50
--- /dev/null
+++ b/src/BlazorUI/Tests/Bit.BlazorUI.Tests/Extensions/JsInterop/FastInvokeSyncContractTests.cs
@@ -0,0 +1,282 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Text.RegularExpressions;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Bit.BlazorUI.Tests.Extensions.JsInterop;
+
+/// <summary>
+/// Guards the "FastInvoke targets must be synchronous JavaScript" contract.
+///
+/// On Blazor WebAssembly, <c>FastInvoke</c>/<c>FastInvokeVoid</c> run through <c>IJSInProcessRuntime</c>
+/// synchronously. If the target JavaScript function returns a Promise, the call becomes fire-and-forget.
+/// This test links every <c>FastInvoke</c> call site to its TypeScript definition via
+/// <see cref="TsPromiseMethodScanner"/> and fails on any match.
+///
+/// <para>
+/// The scanner prioritizes reliable <c>async</c> / <c>: Promise&lt;...&gt;</c> detection; a conservative body
+/// scan covers only the residual unannotated-direct-return case. See <see cref="TsPromiseMethodScanner"/> for
+/// the full tradeoff and limitations.
+/// </para>
+/// </summary>
+[TestClass]
+public class FastInvokeSyncContractTests
+{
+    // Matches FastInvoke(...) / FastInvokeVoid(...) / FastInvoke<T>(...) capturing the JS identifier passed
+    // as the first argument. The identifier can be either a quoted string literal (captured in 'id') or a
+    // bare variable reference (captured in 'var'), e.g. when a method does
+    // `const string identifier = "BitBlazorUI.X.y"; jsRuntime.FastInvoke<T>(identifier, ...)`. Variable
+    // references are resolved separately via ResolveConstStringIdentifier; anything that doesn't resolve to
+    // a const string (e.g. the 'this'/'jsRuntime' parameters in the extension definitions themselves) is
+    // dropped, so it never produces a false positive.
+    private static readonly Regex FastInvokeCallRegex =
+        new(@"FastInvoke(?:Void)?\s*(?:<[^>]+>)?\s*\(\s*(?:""(?<id>[^""]+)""|(?<var>[A-Za-z_]\w*))", RegexOptions.Compiled);
+
+    [TestMethod]
+    public void FastInvoke_CallSites_ShouldNotTargetAsyncJavaScriptFunctions()
+    {
+        var blazorUiRoot = TryFindBlazorUiRoot();
+        if (blazorUiRoot is null)
+        {
+            // This test reads the .cs/.ts sources from disk. When the tests run from packaged binaries
+            // without the source tree present, there is nothing to scan, so report inconclusive rather
+            // than failing. In the repo/CI the sources are present and the contract is fully enforced.
+            Assert.Inconclusive(
+                "Skipped: could not locate the BlazorUI source root (the folder containing 'Bit.BlazorUI' " +
+                "and 'Bit.BlazorUI.Extras'). The source tree is required to scan FastInvoke call sites.");
+            return;
+        }
+
+        var csharpDirs = new[]
+        {
+            Path.Combine(blazorUiRoot, "Bit.BlazorUI"),
+            Path.Combine(blazorUiRoot, "Bit.BlazorUI.Extras"),
+        };
+
+        var fastInvokeTargets = new List<(string ClassMethod, string Identifier, string File)>();
+        foreach (var dir in csharpDirs)
+        {
+            foreach (var file in EnumerateSourceFiles(dir, "*.cs"))
+            {
+                var text = File.ReadAllText(file);
+
+                // Parsed lazily and reused for every variable-identifier resolution in this file.
+                CompilationUnitSyntax? syntaxRoot = null;
+
+                foreach (Match match in FastInvokeCallRegex.Matches(text))
+                {
+                    string? identifier;
+                    if (match.Groups["id"].Success)
+                    {
+                        identifier = match.Groups["id"].Value;
+                    }
+                    else
+                    {
+                        // The identifier was passed as a variable (e.g. `const string identifier = "...";`).
+                        // Resolve it from the const string declaration that is actually visible at the call
+                        // site; skip the call when it can't be resolved (not a contract-relevant literal target).
+                        syntaxRoot ??= CSharpSyntaxTree.ParseText(text).GetCompilationUnitRoot();
+                        identifier = ResolveConstStringIdentifier(syntaxRoot, match.Groups["var"].Value, match.Index);
+                        if (identifier is null) continue;
+                    }
+
+                    // Reduce "BitBlazorUI.Utils.getBodyWidth" to "Utils.getBodyWidth" for TS class.method lookup.
+                    // This assumes TS class names are unique across the scanned sources: two classes with the
+                    // same name in different namespaces would collapse to the same key and could produce a false
+                    // positive. That's acceptable for the current single-project layout (one class per file,
+                    // distinct class names), so the simpler last-two-segments match is preferred over tracking
+                    // full namespaces. Revisit if the TypeScript sources ever introduce duplicate class names.
+                    var classMethod = LastTwoSegments(identifier);
+                    if (classMethod is null) continue;
+
+                    fastInvokeTargets.Add((classMethod, identifier, file));
+                }
+            }
+        }
+
+        Assert.IsTrue(fastInvokeTargets.Count > 0,
+            "Expected to find FastInvoke call sites to validate, but none were found. " +
+            "The scanning logic in this test is likely broken or the source layout changed.");
+
+        var asyncJsMethods = CollectAsyncJsMethods(csharpDirs);
+
+        Assert.IsTrue(asyncJsMethods.Count > 0,
+            "Expected to find async/Promise-returning TypeScript methods (e.g. BitBlazorUI.PdfReader.renderPage), but none were found. " +
+            "The TypeScript parsing in this test is likely broken or the source layout changed.");
+
+        var violations = fastInvokeTargets
+            .Where(t => asyncJsMethods.Contains(t.ClassMethod))
+            .Select(t => $"  - '{t.Identifier}' (async/Promise-returning JS) invoked via FastInvoke in {Path.GetFileName(t.File)}")
+            .Distinct()
+            .ToList();
+
+        Assert.AreEqual(0, violations.Count,
+            "FastInvoke/FastInvokeVoid must only target synchronous JavaScript functions. " +
+            "On Blazor WebAssembly these calls run synchronously and discard the returned Promise (fire-and-forget), " +
+            "so the following async targets must use the regular asynchronous invocation instead:" +
+            Environment.NewLine + string.Join(Environment.NewLine, violations));
+    }
+
+    private static HashSet<string> CollectAsyncJsMethods(IEnumerable<string> roots)
+    {
+        var result = new HashSet<string>(StringComparer.Ordinal);
+
+        foreach (var root in roots)
+        foreach (var file in EnumerateSourceFiles(root, "*.ts"))
+        {
+            if (file.EndsWith(".d.ts", StringComparison.OrdinalIgnoreCase)) continue;
+
+            foreach (var key in TsPromiseMethodScanner.CollectFromSource(File.ReadAllText(file)))
+            {
+                result.Add(key);
+            }
+        }
+
+        return result;
+    }
+
+    private static IEnumerable<string> EnumerateSourceFiles(string root, string pattern)
+    {
+        if (!Directory.Exists(root)) yield break;
+
+        foreach (var file in Directory.EnumerateFiles(root, pattern, SearchOption.AllDirectories))
+        {
+            // Exclude build outputs.
+            if (file.Contains($"{Path.DirectorySeparatorChar}bin{Path.DirectorySeparatorChar}") ||
+                file.Contains($"{Path.DirectorySeparatorChar}obj{Path.DirectorySeparatorChar}"))
+            {
+                continue;
+            }
+
+            yield return file;
+        }
+    }
+
+    private static string? ResolveConstStringIdentifier(CompilationUnitSyntax root, string variableName, int callPosition)
+    {
+        // Resolve the variable to the 'const string <variableName> = "...";' declaration that is actually
+        // visible at the call site, using the parsed C# syntax tree rather than raw text scanning. Walking the
+        // real syntax ancestry means braces, comments, and string literals can never be miscounted, and a
+        // same-named const declared in an unrelated method or type can never be bound by mistake.
+        var node = root.FindToken(callPosition).Parent;
+
+        for (var current = node; current is not null; current = current.Parent)
+        {
+            // Local consts: visible from their declaration to the end of the enclosing block, so only a
+            // declaration that textually precedes the call site counts.
+            foreach (var statement in EnumerateLocalConstStatements(current))
+            {
+                foreach (var v in statement.Declaration.Variables)
+                {
+                    if (v.Identifier.ValueText != variableName) continue;
+                    if (v.SpanStart >= callPosition) continue;
+
+                    var value = TryGetStringLiteral(v);
+                    if (value is not null) return value;
+                }
+            }
+
+            // Type-level const fields: visible anywhere within the declaring type regardless of source order.
+            // Scoping resolution to the containing type (rather than a file-wide name match) prevents binding a
+            // same-named const from an unrelated type.
+            if (current is TypeDeclarationSyntax typeDecl)
+            {
+                foreach (var field in typeDecl.Members.OfType<FieldDeclarationSyntax>())
+                {
+                    if (!field.Modifiers.Any(SyntaxKind.ConstKeyword)) continue;
+                    if (!IsStringType(field.Declaration.Type)) continue;
+
+                    foreach (var v in field.Declaration.Variables)
+                    {
+                        if (v.Identifier.ValueText != variableName) continue;
+
+                        var value = TryGetStringLiteral(v);
+                        if (value is not null) return value;
+                    }
+                }
+            }
+        }
+
+        return null;
+    }
+
+    private static IEnumerable<LocalDeclarationStatementSyntax> EnumerateLocalConstStatements(SyntaxNode scope)
+    {
+        // Only inspect statements that belong directly to this scope's own statement list (block or
+        // switch-section). Descendant blocks are handled when the walk reaches them as their own scope.
+        var statements = scope switch
+        {
+            BlockSyntax block => block.Statements,
+            SwitchSectionSyntax section => section.Statements,
+            _ => default
+        };
+
+        foreach (var statement in statements)
+        {
+            if (statement is LocalDeclarationStatementSyntax local &&
+                local.IsConst &&
+                IsStringType(local.Declaration.Type))
+            {
+                yield return local;
+            }
+        }
+    }
+
+    private static bool IsStringType(TypeSyntax type) => type switch
+    {
+        PredefinedTypeSyntax predefined => predefined.Keyword.IsKind(SyntaxKind.StringKeyword),
+        IdentifierNameSyntax { Identifier.ValueText: "String" } => true,
+        QualifiedNameSyntax { Right.Identifier.ValueText: "String" } => true,
+        _ => false
+    };
+
+    private static string? TryGetStringLiteral(VariableDeclaratorSyntax declarator)
+    {
+        if (declarator.Initializer?.Value is LiteralExpressionSyntax literal &&
+            literal.IsKind(SyntaxKind.StringLiteralExpression))
+        {
+            return literal.Token.ValueText;
+        }
+
+        return null;
+    }
+
+    private static string? LastTwoSegments(string identifier)
+    {
+        var segments = identifier.Split('.');
+        if (segments.Length < 2) return null;
+
+        return $"{segments[^2]}.{segments[^1]}";
+    }
+
+    private static string? TryFindBlazorUiRoot([CallerFilePath] string callerFilePath = "")
+    {
+        // callerFilePath points at this test file; walk up to the BlazorUI source root, which is the
+        // directory that contains both the Bit.BlazorUI and Bit.BlazorUI.Extras projects. Returns null
+        // when the source tree isn't present (e.g. running from packaged binaries) so the caller can
+        // report the test as inconclusive instead of throwing.
+        var directoryName = Path.GetDirectoryName(callerFilePath);
+        if (string.IsNullOrEmpty(directoryName) || !Directory.Exists(directoryName)) return null;
+
+        var dir = new DirectoryInfo(directoryName);
+
+        while (dir is not null)
+        {
+            if (Directory.Exists(Path.Combine(dir.FullName, "Bit.BlazorUI")) &&
+                Directory.Exists(Path.Combine(dir.FullName, "Bit.BlazorUI.Extras")))
+            {
+                return dir.FullName;
+            }
+
+            dir = dir.Parent;
+        }
+
+        return null;
+    }
+}
diff --git a/src/BlazorUI/Tests/Bit.BlazorUI.Tests/Extensions/JsInterop/IJSRuntimeFastExtensionsTests.cs b/src/BlazorUI/Tests/Bit.BlazorUI.Tests/Extensions/JsInterop/IJSRuntimeFastExtensionsTests.cs
new file mode 100644
index 0000000000..70e576a092
--- /dev/null
+++ b/src/BlazorUI/Tests/Bit.BlazorUI.Tests/Extensions/JsInterop/IJSRuntimeFastExtensionsTests.cs
@@ -0,0 +1,515 @@
+using System;
+using System.Collections.Generic;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.JSInterop;
+using Microsoft.JSInterop.Infrastructure;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Bit.BlazorUI.Tests.Extensions.JsInterop;
+
+[TestClass]
+// These tests mutate the process-global IJSRuntimeFastExtensions.OnError hook. The assembly does not opt
+// into MSTest parallelization today, so this is defensive: it keeps the tests serialized (and prevents
+// cross-class bleed) should parallelization ever be enabled. Note that Interlocked/Volatile would NOT make
+// this parallel-safe; reference writes are already atomic and the real issue is a single shared slot.
+// If more global interop state like this accumulates, replace the global with a per-context test seam
+// (e.g. an AsyncLocal overlay exposed via a scoped IDisposable override) and drop this attribute.
+[DoNotParallelize]
+public class IJSRuntimeFastExtensionsTests
+{
+    [TestCleanup]
+    public void ResetErrorHandler()
+    {
+        // OnError is a process-global hook; reset it so tests don't leak into one another.
+        IJSRuntimeFastExtensions.OnError = null;
+    }
+
+    [TestMethod]
+    public void FastInvokeVoid_WhenInProcessRuntime_ShouldInvokeSynchronously()
+    {
+        var jsRuntime = new FakeInProcessJsRuntime();
+
+        var task = jsRuntime.FastInvokeVoid("BitBlazorUI.Test.doStuff", "arg1", 2);
+
+        // The in-process path runs synchronously, so the returned task must already be completed.
+        Assert.IsTrue(task.IsCompleted);
+        Assert.AreEqual(1, jsRuntime.SyncInvocations.Count);
+        Assert.AreEqual("BitBlazorUI.Test.doStuff", jsRuntime.SyncInvocations[0].Identifier);
+        CollectionAssert.AreEqual(new object?[] { "arg1", 2 }, jsRuntime.SyncInvocations[0].Args);
+        Assert.AreEqual(0, jsRuntime.AsyncInvocations.Count);
+    }
+
+    [TestMethod]
+    public async Task FastInvoke_WhenInProcessRuntime_ShouldReturnSynchronousResult()
+    {
+        var jsRuntime = new FakeInProcessJsRuntime { ResultFactory = _ => true };
+
+        var task = jsRuntime.FastInvoke<bool>("BitBlazorUI.Test.getStuff", "x");
+
+        Assert.IsTrue(task.IsCompleted);
+        Assert.IsTrue(await task);
+        Assert.AreEqual(1, jsRuntime.SyncInvocations.Count);
+        Assert.AreEqual("BitBlazorUI.Test.getStuff", jsRuntime.SyncInvocations[0].Identifier);
+        Assert.AreEqual(0, jsRuntime.AsyncInvocations.Count);
+    }
+
+    [TestMethod]
+    public void FastInvokeVoid_WhenInProcessRuntimeThrowsJsonException_ShouldSwallowAndComplete()
+    {
+        var jsRuntime = new FakeInProcessJsRuntime { ExceptionFactory = _ => new JsonException("bad json") };
+
+        var task = jsRuntime.FastInvokeVoid("BitBlazorUI.Test.doStuff");
+
+        // A JsonException from the in-process runtime is swallowed; the call still completes successfully.
+        Assert.IsTrue(task.IsCompleted);
+        Assert.IsFalse(task.IsFaulted);
+    }
+
+    [TestMethod]
+    public async Task FastInvoke_WhenInProcessRuntimeThrowsJsonException_ShouldReturnDefault()
+    {
+        var jsRuntime = new FakeInProcessJsRuntime { ExceptionFactory = _ => new JsonException("bad json") };
+
+        var task = jsRuntime.FastInvoke<bool>("BitBlazorUI.Test.getStuff");
+
+        Assert.IsTrue(task.IsCompleted);
+        Assert.IsFalse(task.IsFaulted);
+        Assert.AreEqual(default, await task);
+    }
+
+    [TestMethod]
+    public void FastInvokeVoid_WhenJsonExceptionAndOnErrorSet_ShouldRouteToHandler()
+    {
+        var reported = new List<(string Identifier, Exception Exception)>();
+        IJSRuntimeFastExtensions.OnError = (identifier, exception) => reported.Add((identifier, exception));
+
+        var jsRuntime = new FakeInProcessJsRuntime { ExceptionFactory = _ => new JsonException("bad json") };
+
+        var task = jsRuntime.FastInvokeVoid("BitBlazorUI.Test.doStuff");
+
+        Assert.IsTrue(task.IsCompleted);
+        Assert.IsFalse(task.IsFaulted);
+        Assert.AreEqual(1, reported.Count);
+        Assert.AreEqual("BitBlazorUI.Test.doStuff", reported[0].Identifier);
+        Assert.IsInstanceOfType(reported[0].Exception, typeof(JsonException));
+    }
+
+    [TestMethod]
+    public async Task FastInvoke_WhenJsonExceptionAndOnErrorSet_ShouldRouteToHandlerAndReturnDefault()
+    {
+        var reported = new List<(string Identifier, Exception Exception)>();
+        IJSRuntimeFastExtensions.OnError = (identifier, exception) => reported.Add((identifier, exception));
+
+        var jsRuntime = new FakeInProcessJsRuntime { ExceptionFactory = _ => new JsonException("bad json") };
+
+        var task = jsRuntime.FastInvoke<bool>("BitBlazorUI.Test.getStuff");
+
+        Assert.IsTrue(task.IsCompleted);
+        Assert.IsFalse(task.IsFaulted);
+        Assert.AreEqual(default, await task);
+        Assert.AreEqual(1, reported.Count);
+        Assert.AreEqual("BitBlazorUI.Test.getStuff", reported[0].Identifier);
+    }
+
+    [TestMethod]
+    public void ReportIfUnexpectedNull_WhenResultIsNullAndRuntimeIsValid_ShouldRouteToOnError()
+    {
+        var reported = new List<(string Identifier, Exception Exception)>();
+        IJSRuntimeFastExtensions.OnError = (identifier, exception) => reported.Add((identifier, exception));
+
+        var jsRuntime = new FakeInProcessJsRuntime();
+
+        var result = jsRuntime.ReportIfUnexpectedNull("BitBlazorUI.Test.getStuff", (string?)null);
+
+        Assert.IsNull(result);
+        Assert.AreEqual(1, reported.Count);
+        Assert.AreEqual("BitBlazorUI.Test.getStuff", reported[0].Identifier);
+        Assert.IsInstanceOfType(reported[0].Exception, typeof(InvalidOperationException));
+    }
+
+    [TestMethod]
+    public void ReportIfUnexpectedNull_WhenRuntimeIsInvalid_ShouldNotReport()
+    {
+        var reported = new List<(string Identifier, Exception Exception)>();
+        IJSRuntimeFastExtensions.OnError = (identifier, exception) => reported.Add((identifier, exception));
+
+        var jsRuntime = new UnsupportedJavaScriptRuntime();
+
+        var result = jsRuntime.ReportIfUnexpectedNull("BitBlazorUI.Test.getStuff", (string?)null);
+
+        Assert.IsNull(result);
+        Assert.AreEqual(0, reported.Count);
+    }
+
+    [TestMethod]
+    public void ReportIfUnexpectedNull_WhenResultIsPresent_ShouldNotReport()
+    {
+        var reported = new List<(string Identifier, Exception Exception)>();
+        IJSRuntimeFastExtensions.OnError = (identifier, exception) => reported.Add((identifier, exception));
+
+        var jsRuntime = new FakeInProcessJsRuntime();
+
+        var result = jsRuntime.ReportIfUnexpectedNull("BitBlazorUI.Test.getStuff", "controller-id");
+
+        Assert.AreEqual("controller-id", result);
+        Assert.AreEqual(0, reported.Count);
+    }
+
+    [TestMethod]
+    public void FastInvokeVoid_WhenOnErrorHandlerThrows_ShouldNotPropagate()
+    {
+        IJSRuntimeFastExtensions.OnError = (_, _) => throw new InvalidOperationException("faulty handler");
+
+        var jsRuntime = new FakeInProcessJsRuntime { ExceptionFactory = _ => new JsonException("bad json") };
+
+        // A throwing error handler must never escape the interop call.
+        var task = jsRuntime.FastInvokeVoid("BitBlazorUI.Test.doStuff");
+
+        Assert.IsTrue(task.IsCompleted);
+        Assert.IsFalse(task.IsFaulted);
+    }
+
+    [TestMethod]
+    public void FastInvokeVoid_WhenInProcessRuntimeThrowsJSException_ShouldSwallowAndComplete()
+    {
+        var jsRuntime = new FakeInProcessJsRuntime { ExceptionFactory = _ => new JSException("js error") };
+
+        var task = jsRuntime.FastInvokeVoid("BitBlazorUI.Test.doStuff");
+
+        Assert.IsTrue(task.IsCompleted);
+        Assert.IsFalse(task.IsFaulted);
+    }
+
+    [TestMethod]
+    public async Task FastInvoke_WhenInProcessRuntimeThrowsJSException_ShouldReturnDefault()
+    {
+        var jsRuntime = new FakeInProcessJsRuntime { ExceptionFactory = _ => new JSException("js error") };
+
+        var task = jsRuntime.FastInvoke<bool>("BitBlazorUI.Test.getStuff");
+
+        Assert.IsTrue(task.IsCompleted);
+        Assert.IsFalse(task.IsFaulted);
+        Assert.AreEqual(default, await task);
+    }
+
+    [TestMethod]
+    public void FastInvokeVoid_WhenJSExceptionAndOnErrorSet_ShouldRouteToHandler()
+    {
+        var reported = new List<(string Identifier, Exception Exception)>();
+        IJSRuntimeFastExtensions.OnError = (identifier, exception) => reported.Add((identifier, exception));
+
+        var jsRuntime = new FakeInProcessJsRuntime { ExceptionFactory = _ => new JSException("js error") };
+
+        var task = jsRuntime.FastInvokeVoid("BitBlazorUI.Test.doStuff");
+
+        Assert.IsTrue(task.IsCompleted);
+        Assert.IsFalse(task.IsFaulted);
+        Assert.AreEqual(1, reported.Count);
+        Assert.AreEqual("BitBlazorUI.Test.doStuff", reported[0].Identifier);
+        Assert.IsInstanceOfType(reported[0].Exception, typeof(JSException));
+    }
+
+    [TestMethod]
+    public void FastInvokeVoid_WhenNotInProcessRuntime_ShouldFallBackToAsync()
+    {
+        var jsRuntime = new FakeJsRuntime();
+
+        _ = jsRuntime.FastInvokeVoid("BitBlazorUI.Test.doStuff", "arg1");
+
+        Assert.AreEqual(1, jsRuntime.AsyncInvocations.Count);
+        Assert.AreEqual("BitBlazorUI.Test.doStuff", jsRuntime.AsyncInvocations[0].Identifier);
+    }
+
+    [TestMethod]
+    public void FastInvoke_WhenNotInProcessRuntime_ShouldFallBackToAsync()
+    {
+        var jsRuntime = new FakeJsRuntime();
+
+        _ = jsRuntime.FastInvoke<bool>("BitBlazorUI.Test.getStuff", "arg1");
+
+        Assert.AreEqual(1, jsRuntime.AsyncInvocations.Count);
+        Assert.AreEqual("BitBlazorUI.Test.getStuff", jsRuntime.AsyncInvocations[0].Identifier);
+    }
+
+
+    [TestMethod]
+    public void FastInvokeVoid_WhenInProcessRuntimeIsInvalid_ShouldNotInvoke()
+    {
+        // The fake is in-process but its type name matches the prerendering runtime, so IsRuntimeInvalid
+        // is true. The synchronous path must now honor that guard and skip the call instead of invoking.
+        var jsRuntime = new UnsupportedJavaScriptRuntime();
+
+        var task = jsRuntime.FastInvokeVoid("BitBlazorUI.Test.doStuff", "arg1");
+
+        Assert.IsTrue(task.IsCompleted);
+        Assert.IsFalse(task.IsFaulted);
+        Assert.AreEqual(0, jsRuntime.SyncInvocations.Count);
+        Assert.AreEqual(0, jsRuntime.AsyncInvocations.Count);
+    }
+
+    [TestMethod]
+    public async Task FastInvoke_WhenInProcessRuntimeIsInvalid_ShouldReturnDefaultWithoutInvoking()
+    {
+        var jsRuntime = new UnsupportedJavaScriptRuntime { ResultFactory = _ => true };
+
+        var task = jsRuntime.FastInvoke<bool>("BitBlazorUI.Test.getStuff");
+
+        Assert.IsTrue(task.IsCompleted);
+        Assert.AreEqual(default, await task);
+        Assert.AreEqual(0, jsRuntime.SyncInvocations.Count);
+        Assert.AreEqual(0, jsRuntime.AsyncInvocations.Count);
+    }
+
+
+    [TestMethod]
+    public void FastInvokeVoid_WhenServerRuntimeNotInitialized_ShouldNotInvoke()
+    {
+        // Blazor Server: an uninitialized circuit (RemoteJSRuntime.IsInitialized == false) is invalid,
+        // so the call must be skipped rather than attempted against a disconnected circuit.
+        var jsRuntime = new RemoteJSRuntime { IsInitialized = false };
+
+        var task = jsRuntime.FastInvokeVoid("BitBlazorUI.Test.doStuff", "arg1");
+
+        Assert.IsTrue(task.IsCompleted);
+        Assert.IsFalse(task.IsFaulted);
+        Assert.AreEqual(0, jsRuntime.AsyncInvocations.Count);
+    }
+
+    [TestMethod]
+    public void FastInvokeVoid_WhenServerRuntimeInitialized_ShouldFallBackToAsync()
+    {
+        // An initialized Blazor Server circuit is a valid, non-in-process runtime, so the call must take
+        // the regular asynchronous path.
+        var jsRuntime = new RemoteJSRuntime { IsInitialized = true };
+
+        _ = jsRuntime.FastInvokeVoid("BitBlazorUI.Test.doStuff", "arg1");
+
+        Assert.AreEqual(1, jsRuntime.AsyncInvocations.Count);
+        Assert.AreEqual("BitBlazorUI.Test.doStuff", jsRuntime.AsyncInvocations[0].Identifier);
+    }
+
+    [TestMethod]
+    public void FastInvoke_WhenServerRuntimeInitialized_ShouldFallBackToAsync()
+    {
+        var jsRuntime = new RemoteJSRuntime { IsInitialized = true };
+
+        _ = jsRuntime.FastInvoke<bool>("BitBlazorUI.Test.getStuff", "arg1");
+
+        Assert.AreEqual(1, jsRuntime.AsyncInvocations.Count);
+        Assert.AreEqual("BitBlazorUI.Test.getStuff", jsRuntime.AsyncInvocations[0].Identifier);
+    }
+
+    [TestMethod]
+    public void FastInvokeVoid_WhenHybridRuntimeDisconnected_ShouldNotInvoke()
+    {
+        // Blazor Hybrid: a disposed/disconnected WebView has a null _ipcSender, which marks the runtime
+        // invalid, so the call must be skipped.
+        var jsRuntime = new WebViewJSRuntime();
+        jsRuntime.SetConnected(false);
+
+        var task = jsRuntime.FastInvokeVoid("BitBlazorUI.Test.doStuff", "arg1");
+
+        Assert.IsTrue(task.IsCompleted);
+        Assert.IsFalse(task.IsFaulted);
+        Assert.AreEqual(0, jsRuntime.AsyncInvocations.Count);
+    }
+
+    [TestMethod]
+    public void FastInvokeVoid_WhenHybridRuntimeConnected_ShouldFallBackToAsync()
+    {
+        var jsRuntime = new WebViewJSRuntime();
+        jsRuntime.SetConnected(true);
+
+        _ = jsRuntime.FastInvokeVoid("BitBlazorUI.Test.doStuff", "arg1");
+
+        Assert.AreEqual(1, jsRuntime.AsyncInvocations.Count);
+        Assert.AreEqual("BitBlazorUI.Test.doStuff", jsRuntime.AsyncInvocations[0].Identifier);
+    }
+
+    [TestMethod]
+    public async Task FastInvokeVoid_WithTimeout_WhenInProcessRuntime_ShouldInvokeSynchronously()
+    {
+        var jsRuntime = new FakeInProcessJsRuntime();
+
+        await jsRuntime.FastInvokeVoid("BitBlazorUI.Test.doStuff", TimeSpan.FromSeconds(30), "arg1");
+
+        // The timeout overload still routes to the synchronous in-process path for a valid WASM runtime.
+        Assert.AreEqual(1, jsRuntime.SyncInvocations.Count);
+        Assert.AreEqual("BitBlazorUI.Test.doStuff", jsRuntime.SyncInvocations[0].Identifier);
+        Assert.AreEqual(0, jsRuntime.AsyncInvocations.Count);
+    }
+
+    [TestMethod]
+    public async Task FastInvoke_WithTimeout_WhenInProcessRuntime_ShouldReturnSynchronousResult()
+    {
+        var jsRuntime = new FakeInProcessJsRuntime { ResultFactory = _ => true };
+
+        var result = await jsRuntime.FastInvoke<bool>("BitBlazorUI.Test.getStuff", TimeSpan.FromSeconds(30), "x");
+
+        Assert.IsTrue(result);
+        Assert.AreEqual(1, jsRuntime.SyncInvocations.Count);
+        Assert.AreEqual(0, jsRuntime.AsyncInvocations.Count);
+    }
+
+    [TestMethod]
+    public async Task FastInvokeVoid_WithInfiniteTimeout_WhenInProcessRuntime_ShouldInvokeSynchronously()
+    {
+        var jsRuntime = new FakeInProcessJsRuntime();
+
+        // Timeout.InfiniteTimeSpan means "no CancellationTokenSource"; the call must still run synchronously.
+        await jsRuntime.FastInvokeVoid("BitBlazorUI.Test.doStuff", Timeout.InfiniteTimeSpan, "arg1");
+
+        Assert.AreEqual(1, jsRuntime.SyncInvocations.Count);
+        Assert.AreEqual(0, jsRuntime.AsyncInvocations.Count);
+    }
+
+    [TestMethod]
+    public void FastInvokeVoid_WithTimeout_WhenServerRuntimeNotInitialized_ShouldNotInvoke()
+    {
+        var jsRuntime = new RemoteJSRuntime { IsInitialized = false };
+
+        var task = jsRuntime.FastInvokeVoid("BitBlazorUI.Test.doStuff", TimeSpan.FromSeconds(30), "arg1");
+
+        Assert.IsTrue(task.IsCompleted);
+        Assert.IsFalse(task.IsFaulted);
+        Assert.AreEqual(0, jsRuntime.AsyncInvocations.Count);
+    }
+
+
+    private record Invocation(string Identifier, object?[]? Args);
+
+    /// <summary>
+    /// A fake <see cref="IJSInProcessRuntime"/> that records synchronous invocations and can be
+    /// configured to return a value or throw, mirroring how the real WebAssembly runtime behaves.
+    /// </summary>
+    private sealed class FakeInProcessJsRuntime : IJSInProcessRuntime
+    {
+        public List<Invocation> SyncInvocations { get; } = [];
+        public List<Invocation> AsyncInvocations { get; } = [];
+        public Func<string, object?>? ResultFactory { get; set; }
+        public Func<string, Exception>? ExceptionFactory { get; set; }
+
+        public TResult Invoke<TResult>(string identifier, params object?[]? args)
+        {
+            SyncInvocations.Add(new Invocation(identifier, args));
+
+            if (ExceptionFactory is not null) throw ExceptionFactory(identifier);
+
+            return ResultFactory is null ? default! : (TResult)ResultFactory(identifier)!;
+        }
+
+        public ValueTask<TValue> InvokeAsync<TValue>(string identifier, object?[]? args)
+        {
+            AsyncInvocations.Add(new Invocation(identifier, args));
+            return new ValueTask<TValue>(default(TValue)!);
+        }
+
+        public ValueTask<TValue> InvokeAsync<TValue>(string identifier, CancellationToken cancellationToken, object?[]? args)
+        {
+            AsyncInvocations.Add(new Invocation(identifier, args));
+            return new ValueTask<TValue>(default(TValue)!);
+        }
+    }
+
+    /// <summary>
+    /// A fake <see cref="IJSRuntime"/> that is NOT in-process, used to verify the async fallback path.
+    /// </summary>
+    private sealed class FakeJsRuntime : IJSRuntime
+    {
+        public List<Invocation> AsyncInvocations { get; } = [];
+
+        public ValueTask<TValue> InvokeAsync<TValue>(string identifier, object?[]? args)
+        {
+            AsyncInvocations.Add(new Invocation(identifier, args));
+            return new ValueTask<TValue>(default(TValue)!);
+        }
+
+        public ValueTask<TValue> InvokeAsync<TValue>(string identifier, CancellationToken cancellationToken, object?[]? args)
+        {
+            AsyncInvocations.Add(new Invocation(identifier, args));
+            return new ValueTask<TValue>(default(TValue)!);
+        }
+    }
+
+    /// <summary>
+    /// A fake <see cref="IJSInProcessRuntime"/> whose type name matches the framework's prerendering
+    /// runtime, so <c>IsRuntimeInvalid</c> reports it as invalid. Used to verify the synchronous
+    /// in-process path now honors the runtime-validity guard and skips the call.
+    /// </summary>
+    private sealed class UnsupportedJavaScriptRuntime : IJSInProcessRuntime
+    {
+        public List<Invocation> SyncInvocations { get; } = [];
+        public List<Invocation> AsyncInvocations { get; } = [];
+        public Func<string, object?>? ResultFactory { get; set; }
+
+        public TResult Invoke<TResult>(string identifier, params object?[]? args)
+        {
+            SyncInvocations.Add(new Invocation(identifier, args));
+            return ResultFactory is null ? default! : (TResult)ResultFactory(identifier)!;
+        }
+
+        public ValueTask<TValue> InvokeAsync<TValue>(string identifier, object?[]? args)
+        {
+            AsyncInvocations.Add(new Invocation(identifier, args));
+            return new ValueTask<TValue>(default(TValue)!);
+        }
+
+        public ValueTask<TValue> InvokeAsync<TValue>(string identifier, CancellationToken cancellationToken, object?[]? args)
+        {
+            AsyncInvocations.Add(new Invocation(identifier, args));
+            return new ValueTask<TValue>(default(TValue)!);
+        }
+    }
+
+    /// <summary>
+    /// A fake whose type name matches Blazor Server's <c>RemoteJSRuntime</c>. <c>IsRuntimeInvalid</c>
+    /// reflects its public <c>IsInitialized</c> property: <see langword="false"/> models a circuit that
+    /// is not yet connected (invalid), <see langword="true"/> a live circuit (valid, async path).
+    /// </summary>
+    private sealed class RemoteJSRuntime : IJSRuntime
+    {
+        public List<Invocation> AsyncInvocations { get; } = [];
+        public bool IsInitialized { get; set; }
+
+        public ValueTask<TValue> InvokeAsync<TValue>(string identifier, object?[]? args)
+        {
+            AsyncInvocations.Add(new Invocation(identifier, args));
+            return new ValueTask<TValue>(default(TValue)!);
+        }
+
+        public ValueTask<TValue> InvokeAsync<TValue>(string identifier, CancellationToken cancellationToken, object?[]? args)
+        {
+            AsyncInvocations.Add(new Invocation(identifier, args));
+            return new ValueTask<TValue>(default(TValue)!);
+        }
+    }
+
+    /// <summary>
+    /// A fake whose type name matches Blazor Hybrid's <c>WebViewJSRuntime</c>. <c>IsRuntimeInvalid</c>
+    /// reflects its private <c>_ipcSender</c> field: a null sender models a disposed/disconnected WebView
+    /// (invalid), a non-null sender a live one (valid, async path).
+    /// </summary>
+    private sealed class WebViewJSRuntime : IJSRuntime
+    {
+        public List<Invocation> AsyncInvocations { get; } = [];
+
+        // Name must match the framework field that IsRuntimeInvalid reflects.
+        private object? _ipcSender;
+
+        public void SetConnected(bool connected) => _ipcSender = connected ? new object() : null;
+
+        public ValueTask<TValue> InvokeAsync<TValue>(string identifier, object?[]? args)
+        {
+            AsyncInvocations.Add(new Invocation(identifier, args));
+            return new ValueTask<TValue>(default(TValue)!);
+        }
+
+        public ValueTask<TValue> InvokeAsync<TValue>(string identifier, CancellationToken cancellationToken, object?[]? args)
+        {
+            AsyncInvocations.Add(new Invocation(identifier, args));
+            return new ValueTask<TValue>(default(TValue)!);
+        }
+    }
+}
diff --git a/src/BlazorUI/Tests/Bit.BlazorUI.Tests/Extensions/JsInterop/IsRuntimeInvalidFrameworkContractTests.cs b/src/BlazorUI/Tests/Bit.BlazorUI.Tests/Extensions/JsInterop/IsRuntimeInvalidFrameworkContractTests.cs
new file mode 100644
index 0000000000..d7ad2ef4f4
--- /dev/null
+++ b/src/BlazorUI/Tests/Bit.BlazorUI.Tests/Extensions/JsInterop/IsRuntimeInvalidFrameworkContractTests.cs
@@ -0,0 +1,115 @@
+using System;
+using System.Linq;
+using System.Reflection;
+using Bit.BlazorUI;
+using Microsoft.JSInterop;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Bit.BlazorUI.Tests.Extensions.JsInterop;
+
+/// <summary>
+/// Guards <see cref="IJSRuntimeExtensions.IsRuntimeInvalid"/> against silent breakage when ASP.NET Core
+/// renames internal <see cref="IJSRuntime"/> implementations or the reflection targets they rely on.
+/// </summary>
+[TestClass]
+public class IsRuntimeInvalidFrameworkContractTests
+{
+    [TestMethod]
+    public void FrameworkRuntimeTypes_ShouldMatchIsRuntimeInvalidReflectionContract()
+    {
+        AssertFrameworkTypeContract(
+            assemblyName: "Microsoft.AspNetCore.Components.Endpoints",
+            typeName: "UnsupportedJavaScriptRuntime",
+            upstreamSource: "https://github.com/dotnet/aspnetcore/blob/main/src/Components/Endpoints/src/DependencyInjection/UnsupportedJavaScriptRuntime.cs");
+
+        AssertFrameworkTypeContract(
+            assemblyName: "Microsoft.AspNetCore.Components.Server",
+            typeName: "RemoteJSRuntime",
+            propertyName: "IsInitialized",
+            propertyType: typeof(bool),
+            upstreamSource: "https://github.com/dotnet/aspnetcore/blob/main/src/Components/Server/src/Circuits/RemoteJSRuntime.cs");
+
+        AssertFrameworkTypeContract(
+            assemblyName: "Microsoft.AspNetCore.Components.WebView",
+            typeName: "WebViewJSRuntime",
+            fieldName: "_ipcSender",
+            upstreamSource: "https://github.com/dotnet/aspnetcore/blob/main/src/Components/WebView/WebView/src/Services/WebViewJSRuntime.cs");
+    }
+
+    [TestMethod]
+    public void IsRuntimeInvalid_WhenFrameworkPrerenderRuntime_ShouldReturnTrue()
+    {
+        var runtime = CreateFrameworkRuntime("Microsoft.AspNetCore.Components.Endpoints", "UnsupportedJavaScriptRuntime");
+
+        Assert.IsTrue(((IJSRuntime)runtime).IsRuntimeInvalid());
+    }
+
+    [TestMethod]
+    public void IsRuntimeInvalid_WhenFrameworkHybridRuntimeNotAttached_ShouldReturnTrue()
+    {
+        var runtime = CreateFrameworkRuntime("Microsoft.AspNetCore.Components.WebView", "WebViewJSRuntime");
+
+        Assert.IsTrue(((IJSRuntime)runtime).IsRuntimeInvalid());
+    }
+
+    private static void AssertFrameworkTypeContract(
+        string assemblyName,
+        string typeName,
+        string upstreamSource,
+        string? propertyName = null,
+        Type? propertyType = null,
+        string? fieldName = null)
+    {
+        var type = ResolveFrameworkRuntimeType(assemblyName, typeName);
+
+        Assert.AreEqual(typeName, type.Name,
+            $"Expected the framework runtime simple name to remain '{typeName}'. " +
+            $"If ASP.NET Core renamed it, update IsRuntimeInvalid and this test. Source: {upstreamSource}");
+
+        if (propertyName is not null)
+        {
+            var property = type.GetProperty(propertyName);
+            Assert.IsNotNull(property,
+                $"Expected '{type.FullName}' to expose '{propertyName}'. " +
+                $"If ASP.NET Core removed or renamed it, update IsRuntimeInvalid. Source: {upstreamSource}");
+
+            if (propertyType is not null)
+            {
+                Assert.AreEqual(propertyType, property!.PropertyType,
+                    $"Expected '{type.FullName}.{propertyName}' to remain '{propertyType.Name}'. Source: {upstreamSource}");
+            }
+        }
+
+        if (fieldName is not null)
+        {
+            var field = type.GetField(fieldName, BindingFlags.NonPublic | BindingFlags.Instance);
+            Assert.IsNotNull(field,
+                $"Expected '{type.FullName}' to expose private field '{fieldName}'. " +
+                $"If ASP.NET Core removed or renamed it, update IsRuntimeInvalid. Source: {upstreamSource}");
+        }
+    }
+
+    private static object CreateFrameworkRuntime(string assemblyName, string typeName)
+    {
+        var type = ResolveFrameworkRuntimeType(assemblyName, typeName);
+        return Activator.CreateInstance(type, nonPublic: true)
+            ?? throw new InvalidOperationException($"Could not create an instance of '{type.FullName}'.");
+    }
+
+    private static Type ResolveFrameworkRuntimeType(string assemblyName, string typeName)
+    {
+        var assembly = AppDomain.CurrentDomain.GetAssemblies()
+            .FirstOrDefault(a => string.Equals(a.GetName().Name, assemblyName, StringComparison.Ordinal))
+            ?? Assembly.Load(assemblyName);
+
+        var type = assembly.GetTypes().SingleOrDefault(t => t.Name == typeName);
+        Assert.IsNotNull(type,
+            $"Could not find framework runtime '{typeName}' in assembly '{assemblyName}'. " +
+            "Ensure the test project references the matching ASP.NET Core Components package.");
+
+        Assert.IsTrue(typeof(IJSRuntime).IsAssignableFrom(type!),
+            $"Expected '{type!.FullName}' to implement {nameof(IJSRuntime)}.");
+
+        return type;
+    }
+}
diff --git a/src/BlazorUI/Tests/Bit.BlazorUI.Tests/Extensions/JsInterop/TsPromiseMethodScanner.cs b/src/BlazorUI/Tests/Bit.BlazorUI.Tests/Extensions/JsInterop/TsPromiseMethodScanner.cs
new file mode 100644
index 0000000000..511a975e0c
--- /dev/null
+++ b/src/BlazorUI/Tests/Bit.BlazorUI.Tests/Extensions/JsInterop/TsPromiseMethodScanner.cs
@@ -0,0 +1,682 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Text.RegularExpressions;
+
+namespace Bit.BlazorUI.Tests.Extensions.JsInterop;
+
+/// <summary>
+/// Best-effort static scan of TypeScript implementation files for static methods that return a Promise.
+///
+/// <para>
+/// Primary detection is cheap and reliable: <c>async</c> modifier or <c>: Promise&lt;...&gt;</c> return type.
+/// A secondary body scan catches the residual case where a method is neither annotated nor async but returns
+/// <c>fetch(...)</c>, <c>Promise.*</c>, or <c>new Promise(...)</c> at the top level. That scan is intentionally
+/// conservative (false negatives over false positives) because it gates CI.
+/// </para>
+///
+/// <para>
+/// Same-class delegation (e.g. <c>return Extras.loadResource(...)</c>) is propagated transitively from
+/// explicitly annotated/async callees through multi-hop wrapper chains — body-detected methods do not
+/// participate in the fixpoint, so heuristic false positives cannot compound through delegation chains.
+/// </para>
+///
+/// <para>
+/// Not modeled: cross-file delegation, local-variable indirection (<c>const p = fetch(); return p;</c>),
+/// static getters/setters (<c>static get foo()</c> — the method-header regex requires a parameter list),
+/// regex literals and division in backward token scanning, and nested-closure returns (ignored by design).
+/// </para>
+///
+/// <para>
+/// The riskiest logic is reverse scanning in <see cref="IsNestedFunctionBodyOpen"/>; it exists solely to
+/// support the speculative body scan and does not affect primary async/: Promise detection.
+/// </para>
+/// </summary>
+internal static class TsPromiseMethodScanner
+{
+    private static readonly Regex TsClassRegex =
+        new(@"\bclass\s+(?<class>\w+)", RegexOptions.Compiled);
+
+    // Matches a static method header up to (and including) its opening parameter parenthesis.
+    // Requires "(" so static fields and arrow-function properties like "static foo = () => {}" are excluded,
+    // and static getters/setters ("static get foo()") are not matched.
+    private static readonly Regex TsStaticMethodHeaderRegex =
+        new(@"\bstatic\s+(?<async>async\s+)?(?<method>\w+)\s*(?:<[^>]+>)?\s*\(", RegexOptions.Compiled);
+
+    private sealed record TsStaticMethod(string Class, string Method, string Body, bool DeclaredAsync, bool AnnotatedPromise);
+
+    /// <summary>
+    /// Returns every static method in <paramref name="text"/> considered promise-returning.
+    /// </summary>
+    public static HashSet<string> CollectFromSource(string text)
+    {
+        // The class/static-method header regexes run against a copy of the source with all comment and string
+        // content blanked out (positions preserved). This prevents commented-out or quoted signatures like
+        // "// static async foo()" or "'class Bar { static baz() }'" from being matched as real declarations and
+        // adding bogus Class.Method entries. Body extraction below still uses the original text (FindMatching /
+        // SkipReturnAnnotation already skip non-code), and the masked indices map 1:1 onto the original.
+        var scanText = MaskNonCode(text);
+
+        var classMatches = TsClassRegex.Matches(scanText)
+            .Select(m => (Name: m.Groups["class"].Value, Index: m.Index))
+            .OrderBy(c => c.Index)
+            .ToList();
+
+        var methods = new List<TsStaticMethod>();
+
+        foreach (Match header in TsStaticMethodHeaderRegex.Matches(scanText))
+        {
+            var openParen = header.Index + header.Length - 1;
+            var closeParen = FindMatching(text, openParen, '(', ')');
+            if (closeParen < 0) continue;
+
+            var bodyOpenBrace = SkipReturnAnnotation(text, closeParen + 1, out var returnAnnotation);
+            if (bodyOpenBrace >= text.Length || text[bodyOpenBrace] != '{') continue;
+
+            var bodyCloseBrace = FindMatching(text, bodyOpenBrace, '{', '}');
+            if (bodyCloseBrace < 0) continue;
+
+            var declaredAsync = header.Groups["async"].Success;
+            var annotatedPromise = AnnotationHasTopLevelPromise(returnAnnotation);
+
+            var owningClass = classMatches.LastOrDefault(c => c.Index < header.Index);
+            if (owningClass.Name is null) continue;
+
+            var body = text.Substring(bodyOpenBrace, bodyCloseBrace - bodyOpenBrace + 1);
+            methods.Add(new TsStaticMethod(
+                owningClass.Name,
+                header.Groups["method"].Value,
+                body,
+                declaredAsync,
+                annotatedPromise));
+        }
+
+        var promiseMethods = new HashSet<string>(StringComparer.Ordinal);
+
+        foreach (var method in methods)
+        {
+            if (!method.DeclaredAsync && !method.AnnotatedPromise) continue;
+
+            var key = $"{method.Class}.{method.Method}";
+            promiseMethods.Add(key);
+        }
+
+        // Propagate delegation transitively from explicit async/: Promise sources (per-file; one class per file
+        // today). The fixpoint checks against the growing promiseMethods set (seeded with explicitPromiseMethods)
+        // so multi-hop wrapper chains rooted at an explicit source are followed across multiple iterations.
+        // Body-scanned methods are still excluded here because they are only added after this loop, so heuristic
+        // false positives cannot compound through delegation chains.
+        var changed = true;
+        while (changed)
+        {
+            changed = false;
+
+            foreach (var method in methods)
+            {
+                var key = $"{method.Class}.{method.Method}";
+                if (promiseMethods.Contains(key)) continue;
+
+                if (!BodyDelegatesToKnownMethods(method.Body, method.Class, promiseMethods)) continue;
+
+                promiseMethods.Add(key);
+                changed = true;
+            }
+        }
+
+        foreach (var method in methods)
+        {
+            var key = $"{method.Class}.{method.Method}";
+            if (promiseMethods.Contains(key)) continue;
+
+            if (BodyHasDirectTopLevelPromiseReturn(method.Body))
+            {
+                promiseMethods.Add(key);
+            }
+        }
+
+        // promiseMethods is the fully-populated result set; return it directly rather than copying.
+        return promiseMethods;
+    }
+
+    /// <summary>
+    /// True when the body has a top-level <c>return fetch(...)</c>, <c>return Promise.*</c>, or
+    /// <c>return new Promise(...)</c>. Returns inside nested functions/closures are ignored.
+    /// </summary>
+    public static bool BodyHasDirectTopLevelPromiseReturn(string body) =>
+        ScanTopLevelReturns(body, expressionStart => IsDirectPromiseReturnExpression(body, expressionStart));
+
+    /// <summary>
+    /// True when the body has a top-level <c>return</c> that delegates to a method in
+    /// <paramref name="knownPromiseMethods"/>. Returns inside nested functions/closures are ignored.
+    /// </summary>
+    public static bool BodyDelegatesToKnownMethods(string body, string className, HashSet<string> knownPromiseMethods) =>
+        ScanTopLevelReturns(body, (expressionStart) =>
+            ReturnExpressionDelegatesToPromiseMethod(body, expressionStart, className, knownPromiseMethods));
+
+    private static bool ScanTopLevelReturns(string body, Func<int, bool> expressionMatches)
+    {
+        var nestedFunctionDepth = 0;
+        var braceStack = new Stack<bool>();
+
+        for (var i = 0; i < body.Length; i++)
+        {
+            i = SkipNonCode(body, i, out var skipped);
+            if (skipped) { i--; continue; }
+            if (i >= body.Length) break;
+
+            var c = body[i];
+
+            if (c == '{')
+            {
+                var isFunctionBody = i > 0 && IsNestedFunctionBodyOpen(body, i);
+                braceStack.Push(isFunctionBody);
+                if (isFunctionBody) nestedFunctionDepth++;
+                continue;
+            }
+
+            if (c == '}')
+            {
+                if (braceStack.Count > 0 && braceStack.Pop())
+                {
+                    nestedFunctionDepth--;
+                }
+
+                continue;
+            }
+
+            if (nestedFunctionDepth > 0) continue;
+
+            if (!IsIdentifierAt(body, i, "return")) continue;
+
+            i += "return".Length;
+
+            // Automatic Semicolon Insertion: in JS/TS a line terminator between `return` and its operand
+            // turns the statement into a bare `return;` (void) - the following token starts a new, separate
+            // (unreachable) statement and is NOT the returned expression. Treat such a return as void so a
+            // promise expression on the next line isn't misclassified as a returned value.
+            var sawLineTerminator = false;
+            while (i < body.Length && char.IsWhiteSpace(body[i]))
+            {
+                if (body[i] is '\r' or '\n') sawLineTerminator = true;
+                i++;
+            }
+            if (i >= body.Length) continue;
+            if (sawLineTerminator)
+            {
+                // Re-scan the next token as an ordinary statement rather than a returned expression
+                // (the for-loop's i++ would otherwise step over its first character).
+                i--;
+                continue;
+            }
+
+            if (expressionMatches(i)) return true;
+
+            // Non-promise return expressions (e.g. object literals) must not leave inner '{' unpaired on the stack.
+            SkipNonMatchingReturnExpression(body, ref i);
+            continue;
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    /// Advances <paramref name="index"/> past a non-matching return expression so inner braces/parens are not
+    /// mistaken for method structure during the outer scan.
+    /// </summary>
+    private static void SkipNonMatchingReturnExpression(string body, ref int index)
+    {
+        if (index >= body.Length) return;
+
+        index = SkipNonCode(body, index, out var skipped);
+        if (skipped)
+        {
+            SkipNonMatchingReturnExpression(body, ref index);
+            return;
+        }
+
+        if (index >= body.Length) return;
+
+        if (body[index] == '{')
+        {
+            var closeBrace = FindMatching(body, index, '{', '}');
+            if (closeBrace >= 0) index = closeBrace;
+            return;
+        }
+
+        if (body[index] == '(')
+        {
+            var closeParen = FindMatching(body, index, '(', ')');
+            if (closeParen >= 0) index = closeParen;
+        }
+    }
+
+    private static bool IsDirectPromiseReturnExpression(string body, int expressionStart)
+    {
+        if (IsIdentifierAt(body, expressionStart, "fetch") &&
+            expressionStart + "fetch".Length < body.Length &&
+            body[expressionStart + "fetch".Length] == '(')
+        {
+            return true;
+        }
+
+        if (IsIdentifierAt(body, expressionStart, "Promise") &&
+            expressionStart + "Promise".Length < body.Length &&
+            body[expressionStart + "Promise".Length] == '.')
+        {
+            return true;
+        }
+
+        if (IsIdentifierAt(body, expressionStart, "new"))
+        {
+            var i = expressionStart + "new".Length;
+            while (i < body.Length && char.IsWhiteSpace(body[i])) i++;
+            if (IsIdentifierAt(body, i, "Promise")) return true;
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    /// Heuristically decides whether the <c>{</c> at <paramref name="braceIndex"/> opens a function body
+    /// (arrow <c>=&gt;</c>, <c>function (...)</c>, or <c>async function (...)</c>) rather than an object literal
+    /// or block. This is a secondary check used only to skip returns inside nested closures — it never drives the
+    /// primary async/Promise detection, which relies on explicit annotations.
+    /// <para>
+    /// It scans backward via <see cref="SkipNonCodeBackward"/> and <see cref="FindMatchingBackward"/>, which, as
+    /// documented on <see cref="SkipNonCodeBackward"/>, cannot reliably distinguish regex literals (e.g.
+    /// <c>/pattern/</c>) from division, template literals with embedded <c>${...}</c> expressions, or other
+    /// edge-case token boundaries. Such ambiguity can misclassify a brace here.
+    /// </para>
+    /// <para>
+    /// The tradeoff is deliberate: prefer false negatives (occasionally missing a nested function, so a few inner
+    /// returns get scanned) over false positives (wrongly treating real code as a nested body and silently
+    /// dropping a valid top-level return). Maintainers should not "fix" this with more aggressive backward parsing,
+    /// since that trades safe misses for incorrect matches.
+    /// </para>
+    /// </summary>
+    private static bool IsNestedFunctionBodyOpen(string text, int braceIndex)
+    {
+        var i = braceIndex - 1;
+        while (i >= 0)
+        {
+            i = SkipNonCodeBackward(text, i, out var skipped);
+            if (skipped) continue;
+            break;
+        }
+
+        if (i < 0) return false;
+
+        if (text[i] == '>' && i > 0 && text[i - 1] == '=') return true;
+
+        if (text[i] != ')') return false;
+
+        var openParen = FindMatchingBackward(text, i, '(', ')');
+        if (openParen < 0) return false;
+
+        i = openParen - 1;
+        while (i >= 0)
+        {
+            i = SkipNonCodeBackward(text, i, out var skipped);
+            if (skipped) continue;
+            break;
+        }
+
+        if (i >= 0 && IsIdentifierEndingAt(text, i, "function")) return true;
+
+        if (i >= 0 && IsIdentifierEndingAt(text, i, "async"))
+        {
+            i -= "async".Length;
+            while (i >= 0)
+            {
+                i = SkipNonCodeBackward(text, i, out var skippedBeforeAsync);
+                if (skippedBeforeAsync) continue;
+                break;
+            }
+
+            if (i >= 0 && IsIdentifierEndingAt(text, i, "function")) return true;
+        }
+
+        return false;
+    }
+
+    private static bool ReturnExpressionDelegatesToPromiseMethod(string body, int expressionStart, string className, HashSet<string> knownPromiseMethods)
+    {
+        var i = expressionStart;
+
+        string? qualifier = null;
+        if (char.IsLetter(body[i]) || body[i] == '_')
+        {
+            var identifierStart = i;
+            while (i < body.Length && (char.IsLetterOrDigit(body[i]) || body[i] == '_')) i++;
+
+            if (i < body.Length && body[i] == '.')
+            {
+                qualifier = body.Substring(identifierStart, i - identifierStart);
+                i++;
+                while (i < body.Length && char.IsWhiteSpace(body[i])) i++;
+            }
+            else
+            {
+                i = identifierStart;
+            }
+        }
+
+        if (i >= body.Length || !(char.IsLetter(body[i]) || body[i] == '_')) return false;
+
+        var methodStart = i;
+        while (i < body.Length && (char.IsLetterOrDigit(body[i]) || body[i] == '_')) i++;
+        var methodName = body.Substring(methodStart, i - methodStart);
+
+        while (i < body.Length && char.IsWhiteSpace(body[i])) i++;
+        if (i >= body.Length || body[i] != '(') return false;
+
+        if (qualifier is null)
+        {
+            return knownPromiseMethods.Contains($"{className}.{methodName}");
+        }
+
+        if (string.Equals(qualifier, "this", StringComparison.Ordinal) ||
+            string.Equals(qualifier, className, StringComparison.Ordinal))
+        {
+            return knownPromiseMethods.Contains($"{className}.{methodName}");
+        }
+
+        return false;
+    }
+
+    private static bool IsIdentifierEndingAt(string text, int index, string identifier)
+    {
+        var start = index - identifier.Length + 1;
+        if (start < 0) return false;
+
+        return IsIdentifierAt(text, start, identifier);
+    }
+
+    private static bool IsIdentifierAt(string text, int index, string identifier)
+    {
+        if (index < 0 || index >= text.Length || !text.AsSpan(index).StartsWith(identifier)) return false;
+
+        var end = index + identifier.Length;
+        if (index > 0 && (char.IsLetterOrDigit(text[index - 1]) || text[index - 1] == '_')) return false;
+        if (end < text.Length && (char.IsLetterOrDigit(text[end]) || text[end] == '_')) return false;
+
+        return true;
+    }
+
+    private static int FindMatching(string text, int openIndex, char open, char close)
+    {
+        var depth = 0;
+        for (var i = openIndex; i < text.Length; i++)
+        {
+            i = SkipNonCode(text, i, out var skipped);
+            if (skipped) { i--; continue; }
+            if (i >= text.Length) break;
+
+            var c = text[i];
+            if (c == open) depth++;
+            else if (c == close)
+            {
+                depth--;
+                if (depth == 0) return i;
+            }
+        }
+
+        return -1;
+    }
+
+    private static int FindMatchingBackward(string text, int closeIndex, char open, char close)
+    {
+        var depth = 0;
+        for (var i = closeIndex; i >= 0; i--)
+        {
+            i = SkipNonCodeBackward(text, i, out var skipped);
+            if (skipped) { i++; continue; }
+            if (i < 0) break;
+
+            var c = text[i];
+            if (c == close) depth++;
+            else if (c == open)
+            {
+                depth--;
+                if (depth == 0) return i;
+            }
+        }
+
+        return -1;
+    }
+
+    /// <summary>
+    /// Best-effort backward skip used only by <see cref="IsNestedFunctionBodyOpen"/> (the speculative body scan).
+    /// This is the riskiest part of the scanner: reverse scanning cannot reliably classify comments, string
+    /// literals, regex literals, or division. Misclassification affects nested-function heuristics only —
+    /// explicit <c>async</c> / <c>: Promise&lt;...&gt;</c> annotations are unaffected.
+    /// </summary>
+    private static int SkipNonCodeBackward(string text, int i, out bool skipped)
+    {
+        skipped = false;
+        if (i >= text.Length) return i;
+
+        while (i >= 0 && char.IsWhiteSpace(text[i])) i--;
+        if (i < 0) return i;
+
+        if (i >= 1 && text[i - 1] == '/' && text[i] == '/')
+        {
+            skipped = true;
+            i -= 2;
+            while (i >= 0 && text[i] != '\n') i--;
+            return i;
+        }
+
+        if (i >= 1 && text[i] == '/' && text[i - 1] == '*')
+        {
+            skipped = true;
+            i -= 2;
+            while (i >= 1 && !(text[i - 1] == '/' && text[i] == '*')) i--;
+            return Math.Max(-1, i - 2);
+        }
+
+        var c = text[i];
+        if (c is '"' or '\'' or '`')
+        {
+            skipped = true;
+            var quote = c;
+            i--;
+            while (i >= 0 && text[i] != quote)
+            {
+                if (text[i] == '\\') i--;
+                i--;
+            }
+
+            return i - 1;
+        }
+
+        return i;
+    }
+
+    /// <summary>
+    /// True when the standalone token <c>Promise</c> appears at the top level of the return type — i.e. the
+    /// method itself returns a Promise. Promise tokens nested inside object-literal type members
+    /// (<c>{ p: Promise&lt;void&gt; }</c>), generic arguments (<c>Array&lt;Promise&lt;void&gt;&gt;</c>), or the
+    /// return type of a returned function type (<c>() =&gt; Promise&lt;void&gt;</c>) are intentionally ignored,
+    /// since in those cases the method does not return a Promise itself.
+    /// </summary>
+    private static bool AnnotationHasTopLevelPromise(string annotation)
+    {
+        var depth = 0;
+        for (var i = 0; i < annotation.Length; i++)
+        {
+            i = SkipNonCode(annotation, i, out var skipped);
+            if (skipped) { i--; continue; }
+            if (i >= annotation.Length) break;
+
+            var c = annotation[i];
+
+            if (c is '(' or '[' or '{' or '<')
+            {
+                depth++;
+                continue;
+            }
+
+            if (c is ')' or ']' or '}' or '>')
+            {
+                if (depth > 0) depth--;
+                continue;
+            }
+
+            if (depth != 0) continue;
+
+            // A top-level "=>" means the return type is a function type; whatever it returns (possibly a
+            // Promise) is not this method's own return value, so stop scanning.
+            if (c == '=' && i + 1 < annotation.Length && annotation[i + 1] == '>') break;
+
+            if (IsIdentifierAt(annotation, i, "Promise")) return true;
+        }
+
+        return false;
+    }
+
+    private static int SkipReturnAnnotation(string text, int start, out string annotation)
+    {
+        annotation = string.Empty;
+
+        var i = start;
+        while (i < text.Length && char.IsWhiteSpace(text[i])) i++;
+
+        if (i >= text.Length || text[i] != ':')
+        {
+            return i;
+        }
+
+        var annotationStart = ++i;
+
+        // Walk the return-type annotation while tracking the nesting depth of (), [] and <> so that a '{'
+        // belonging to the type rather than the method body is not mistaken for the body's opening brace.
+        // Two cases must be skipped: a top-level object-literal return type (e.g. "{ [id: string]: GlState }")
+        // and a '{' nested inside a generic argument (e.g. "Promise<{ x: number }>"). We use an "expecting type"
+        // flag (true right after ':' and after the type operators '<', '(', '|', '&', ',') to recognize an
+        // object-literal type and skip the whole balanced { ... }; the first '{' reached once a complete type has
+        // been read (at depth zero) is the actual method body.
+        var depth = 0;
+        var expectingType = true;
+        while (i < text.Length)
+        {
+            i = SkipNonCode(text, i, out var skipped);
+            if (skipped) continue;
+            if (i >= text.Length) break;
+
+            var c = text[i];
+
+            if (char.IsWhiteSpace(c)) { i++; continue; }
+
+            if (c is '(' or '[' or '<')
+            {
+                depth++;
+                expectingType = true;
+                i++;
+                continue;
+            }
+
+            if (c is ')' or ']' or '>')
+            {
+                if (depth > 0) depth--;
+                expectingType = false;
+                i++;
+                continue;
+            }
+
+            if (depth == 0)
+            {
+                if (c == ';') break;
+
+                if (c == '{')
+                {
+                    if (!expectingType) break; // the method body's opening brace
+
+                    // Object-literal type in return position: skip the whole balanced { ... } and keep scanning.
+                    var close = FindMatching(text, i, '{', '}');
+                    if (close < 0) break;
+                    i = close + 1;
+                    expectingType = false;
+                    continue;
+                }
+            }
+
+            expectingType = c is '|' or '&' or ',';
+            i++;
+        }
+
+        annotation = text.Substring(annotationStart, Math.Max(0, i - annotationStart));
+        return i;
+    }
+
+    /// <summary>
+    /// Returns a copy of <paramref name="text"/> with all comment and string-literal content replaced by spaces
+    /// (line breaks preserved, length and all code-token positions unchanged). Running the structural regexes
+    /// against this masked text keeps commented-out or quoted class/method signatures from being misread as real
+    /// declarations, while the 1:1 index mapping lets body extraction continue against the original source.
+    /// </summary>
+    private static string MaskNonCode(string text)
+    {
+        var sb = new StringBuilder(text);
+
+        var i = 0;
+        while (i < text.Length)
+        {
+            var start = i;
+            i = SkipNonCode(text, i, out var skipped);
+            if (skipped)
+            {
+                for (var j = start; j < i && j < sb.Length; j++)
+                {
+                    if (sb[j] is not ('\n' or '\r')) sb[j] = ' ';
+                }
+            }
+            else
+            {
+                i++;
+            }
+        }
+
+        return sb.ToString();
+    }
+
+    private static int SkipNonCode(string text, int i, out bool skipped)
+    {
+        skipped = false;
+        if (i >= text.Length) return i;
+
+        var c = text[i];
+
+        if (c == '/' && i + 1 < text.Length && text[i + 1] == '/')
+        {
+            skipped = true;
+            i += 2;
+            while (i < text.Length && text[i] != '\n') i++;
+            return i;
+        }
+
+        if (c == '/' && i + 1 < text.Length && text[i + 1] == '*')
+        {
+            skipped = true;
+            i += 2;
+            while (i + 1 < text.Length && !(text[i] == '*' && text[i + 1] == '/')) i++;
+            return Math.Min(text.Length, i + 2);
+        }
+
+        if (c is '"' or '\'' or '`')
+        {
+            skipped = true;
+            var quote = c;
+            i++;
+            while (i < text.Length && text[i] != quote)
+            {
+                if (text[i] == '\\') i++;
+                i++;
+            }
+            return Math.Min(text.Length, i + 1);
+        }
+
+        return i;
+    }
+}
diff --git a/src/BlazorUI/Tests/Bit.BlazorUI.Tests/Extensions/JsInterop/TsPromiseMethodScannerTests.cs b/src/BlazorUI/Tests/Bit.BlazorUI.Tests/Extensions/JsInterop/TsPromiseMethodScannerTests.cs
new file mode 100644
index 0000000000..ebd7339dd9
--- /dev/null
+++ b/src/BlazorUI/Tests/Bit.BlazorUI.Tests/Extensions/JsInterop/TsPromiseMethodScannerTests.cs
@@ -0,0 +1,302 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Bit.BlazorUI.Tests.Extensions.JsInterop;
+
+[TestClass]
+public class TsPromiseMethodScannerTests
+{
+    [TestMethod]
+    public void BodyScan_IgnoresPromiseReturnInsideClosureWithControlFlowBlock()
+    {
+        var body = """
+            {
+              const cb = () => {
+                if (x) {
+                  doThing();
+                }
+                return fetch(url);
+              };
+              return 1;
+            }
+            """;
+
+        Assert.IsFalse(TsPromiseMethodScanner.BodyHasDirectTopLevelPromiseReturn(body));
+    }
+
+    [TestMethod]
+    public void BodyScan_DetectsTopLevelFetchReturnInsideControlFlowBlock()
+    {
+        var body = """
+            {
+              if (x) {
+                return fetch(url);
+              }
+              return 1;
+            }
+            """;
+
+        Assert.IsTrue(TsPromiseMethodScanner.BodyHasDirectTopLevelPromiseReturn(body));
+    }
+
+    [TestMethod]
+    public void BodyScan_IgnoresLocalVariableIndirection()
+    {
+        var body = """
+            {
+              const p = fetch(url);
+              return p;
+            }
+            """;
+
+        Assert.IsFalse(TsPromiseMethodScanner.BodyHasDirectTopLevelPromiseReturn(body));
+    }
+
+    [TestMethod]
+    public void BodyScan_ReturnObjectLiteralDoesNotDesyncBraceStack()
+    {
+        var body = """
+            {
+              return { ok: true };
+              return fetch(url);
+            }
+            """;
+
+        Assert.IsTrue(TsPromiseMethodScanner.BodyHasDirectTopLevelPromiseReturn(body));
+    }
+
+    [TestMethod]
+    public void BodyScan_TreatsReturnFollowedByNewlineAsVoidReturn()
+    {
+        // Automatic Semicolon Insertion: `return` then a newline parses as `return;`, so the fetch(...) on
+        // the next line is a separate (unreachable) statement, not the returned value. The method returns
+        // void, so it must NOT be classified as promise-returning.
+        var body = """
+            {
+              return
+              fetch(url);
+            }
+            """;
+
+        Assert.IsFalse(TsPromiseMethodScanner.BodyHasDirectTopLevelPromiseReturn(body));
+    }
+
+    [TestMethod]
+    public void CollectFromSource_DetectsAsyncModifier()
+    {
+        var ts = """
+            namespace BitBlazorUI {
+              class Sample {
+                public static async loadAsync() { await Promise.resolve(); }
+              }
+            }
+            """;
+
+        var promiseMethods = TsPromiseMethodScanner.CollectFromSource(ts);
+
+        Assert.IsTrue(promiseMethods.Contains("Sample.loadAsync"));
+    }
+
+    [TestMethod]
+    public void CollectFromSource_DetectsPromiseReturnTypeAnnotation()
+    {
+        var ts = """
+            namespace BitBlazorUI {
+              class Sample {
+                public static loadAsync(): Promise<void> { return Promise.resolve(); }
+              }
+            }
+            """;
+
+        var promiseMethods = TsPromiseMethodScanner.CollectFromSource(ts);
+
+        Assert.IsTrue(promiseMethods.Contains("Sample.loadAsync"));
+    }
+
+    [TestMethod]
+    public void CollectFromSource_PropagatesSameClassDelegationFromAnnotatedCallee()
+    {
+        var ts = """
+            namespace BitBlazorUI {
+              class Sample {
+                private static loadAsync(): Promise<void> { return Promise.resolve(); }
+                public static setup() { return Sample.loadAsync('x'); }
+              }
+            }
+            """;
+
+        var promiseMethods = TsPromiseMethodScanner.CollectFromSource(ts);
+
+        Assert.IsTrue(promiseMethods.Contains("Sample.loadAsync"));
+        Assert.IsTrue(promiseMethods.Contains("Sample.setup"));
+    }
+
+    [TestMethod]
+    public void CollectFromSource_DetectsUnannotatedDirectFetchReturn()
+    {
+        var ts = """
+            namespace BitBlazorUI {
+              class Sample {
+                public static loadViaFetch(url: string) { return fetch(url); }
+              }
+            }
+            """;
+
+        var promiseMethods = TsPromiseMethodScanner.CollectFromSource(ts);
+
+        Assert.IsTrue(promiseMethods.Contains("Sample.loadViaFetch"));
+    }
+
+    [TestMethod]
+    public void CollectFromSource_PropagatesTwoHopDelegationFromAnnotatedSource()
+    {
+        var ts = """
+            namespace BitBlazorUI {
+              class Sample {
+                private static loadAsync(): Promise<void> { return Promise.resolve(); }
+                private static wrap() { return Sample.loadAsync(); }
+                public static setup() { return Sample.wrap(); }
+              }
+            }
+            """;
+
+        var promiseMethods = TsPromiseMethodScanner.CollectFromSource(ts);
+
+        Assert.IsTrue(promiseMethods.Contains("Sample.loadAsync"));
+        Assert.IsTrue(promiseMethods.Contains("Sample.wrap"),
+            "First-hop wrapper of an explicit Promise source must be detected.");
+        Assert.IsTrue(promiseMethods.Contains("Sample.setup"),
+            "Second-hop wrapper must be detected via transitive delegation through the fixpoint.");
+    }
+
+    [TestMethod]
+    public void CollectFromSource_DoesNotPropagateDelegationToBodyScannedCallee()
+    {
+        var ts = """
+            namespace BitBlazorUI {
+              class Sample {
+                private static loadViaFetch(url: string) { return fetch(url); }
+                public static setup(url: string) { return Sample.loadViaFetch(url); }
+              }
+            }
+            """;
+
+        var promiseMethods = TsPromiseMethodScanner.CollectFromSource(ts);
+
+        Assert.IsTrue(promiseMethods.Contains("Sample.loadViaFetch"));
+        Assert.IsFalse(promiseMethods.Contains("Sample.setup"),
+            "Delegation fixpoint must not chain from body-scanned methods to avoid compounding heuristic false positives.");
+    }
+
+    [TestMethod]
+    public void CollectFromSource_IgnoresPromiseNestedInsideObjectLiteralReturnType()
+    {
+        var ts = """
+            namespace BitBlazorUI {
+              class Sample {
+                public static makeState(): { pending: Promise<void> } { return { pending: Promise.resolve() }; }
+              }
+            }
+            """;
+
+        var promiseMethods = TsPromiseMethodScanner.CollectFromSource(ts);
+
+        Assert.IsFalse(promiseMethods.Contains("Sample.makeState"),
+            "A Promise nested inside an object-literal return type must not flag the method as promise-returning.");
+    }
+
+    [TestMethod]
+    public void CollectFromSource_IgnoresPromiseNestedInsideReturnedFunctionType()
+    {
+        var ts = """
+            namespace BitBlazorUI {
+              class Sample {
+                public static makeLoader(): () => Promise<void> { return () => Promise.resolve(); }
+              }
+            }
+            """;
+
+        var promiseMethods = TsPromiseMethodScanner.CollectFromSource(ts);
+
+        Assert.IsFalse(promiseMethods.Contains("Sample.makeLoader"),
+            "A method returning a function that returns a Promise does not itself return a Promise.");
+    }
+
+    [TestMethod]
+    public void CollectFromSource_IgnoresPromiseNestedInsideGenericArgumentReturnType()
+    {
+        var ts = """
+            namespace BitBlazorUI {
+              class Sample {
+                public static collect(): Array<Promise<void>> { return []; }
+              }
+            }
+            """;
+
+        var promiseMethods = TsPromiseMethodScanner.CollectFromSource(ts);
+
+        Assert.IsFalse(promiseMethods.Contains("Sample.collect"),
+            "A Promise nested inside a generic argument must not flag the method as promise-returning.");
+    }
+
+    [TestMethod]
+    public void CollectFromSource_DetectsTopLevelPromiseWithNestedTypeArgument()
+    {
+        var ts = """
+            namespace BitBlazorUI {
+              class Sample {
+                public static loadAsync(): Promise<{ ok: boolean }> { return Promise.resolve({ ok: true }); }
+              }
+            }
+            """;
+
+        var promiseMethods = TsPromiseMethodScanner.CollectFromSource(ts);
+
+        Assert.IsTrue(promiseMethods.Contains("Sample.loadAsync"),
+            "A top-level Promise return type must still be detected even when its type argument is complex.");
+    }
+
+    [TestMethod]
+    public void CollectFromSource_IgnoresCommentedOutSignatures()
+    {
+        var ts = """
+            namespace BitBlazorUI {
+              class Sample {
+                // public static async ghostAsync() { await Promise.resolve(); }
+                /* public static realGhost(): Promise<void> { return Promise.resolve(); } */
+                public static loadAsync(): Promise<void> { return Promise.resolve(); }
+              }
+            }
+            """;
+
+        var promiseMethods = TsPromiseMethodScanner.CollectFromSource(ts);
+
+        Assert.IsTrue(promiseMethods.Contains("Sample.loadAsync"));
+        Assert.IsFalse(promiseMethods.Contains("Sample.ghostAsync"),
+            "A signature inside a line comment must not be treated as a real declaration.");
+        Assert.IsFalse(promiseMethods.Contains("Sample.realGhost"),
+            "A signature inside a block comment must not be treated as a real declaration.");
+    }
+
+    [TestMethod]
+    public void CollectFromSource_IgnoresSignaturesInsideStringLiterals()
+    {
+        var ts = """
+            namespace BitBlazorUI {
+              class Sample {
+                public static describe(): string {
+                  return "class Ghost { static async hauntAsync() { await Promise.resolve(); } }";
+                }
+              }
+            }
+            """;
+
+        var promiseMethods = TsPromiseMethodScanner.CollectFromSource(ts);
+
+        Assert.IsFalse(promiseMethods.Contains("Ghost.hauntAsync"),
+            "A class/method signature embedded in a string literal must not be treated as a real declaration.");
+        Assert.IsFalse(promiseMethods.Contains("Sample.describe"),
+            "A method returning a plain string must not be flagged as promise-returning.");
+    }
+}