fix(map): pause AIS push timer while tab is hidden

Helm:
> Chrome seems to put the tab into sleep when its in background.
> Then the page is reported as unresponsive when opened again.

A long-hidden tab queued 3 s aisTimer ticks under Chrome's background
throttle. On resume the renderer drained the backlog plus a 200+ vessel
CPA / COLREGS rebuild back-to-back on the single WASM thread, blocked
past 5 s, and Chrome painted "page unresponsive".

visibility.js gains attachVisibilityEdges + detachVisibilityEdges:
one subscriber at a time with both-edges callbacks, fires the hidden
edge synchronously if the tab is already hidden at attach time (covers
helm navigating to /map from another tab and switching away before
the page finishes mounting).

Map.razor pauses aisTimer on the hidden edge via Change(Infinite),
re-arms on the visible edge with AisPushInitialDelayMs so Blazor's
layout pass settles before the JSInterop push hits the same frame.
Detach + dispose mirror the deadmanModule pattern in DisposeAsync.

WebSocket stays connected throughout so anchor / CPA / MOB alarm
rules keep evaluating from live SK data; only the visual push that
a hidden chart can't render is suppressed.

Author: msallin

OnaPlotter/Components/Pages/Map.razor

@@ -593,6 +593,17 @@
     // reuse this without needing to re-attach, and so dispose can detach
     // BEFORE disposing the main module.
     private IJSObjectReference? deadmanModule;
+    // Module handle for the visibilitychange-edges listener (see
+    // wwwroot/js/visibility.js). Drives aisTimer pause/resume so a
+    // long-hidden tab doesn't queue a fire-storm of pushes that blocks
+    // the renderer past Chrome's 5 s "page unresponsive" threshold on
+    // wake.
+    private IJSObjectReference? visibilityEdgesModule;
+    // Tracks whether the tab is currently visible to the helm. Updated
+    // by OnPageHidden / OnPageVisible JSInvokables; gates aisTimer's
+    // Change calls so a no-op transition (already hidden, still hidden)
+    // doesn't churn the timer.
+    private bool _pageIsVisible = true;
     private DotNetObjectReference<Map>? dotNetRef;
     private bool follow;
     private bool nightMode;
@@ -682,6 +693,40 @@
         colregsHelpOpen = true;
         StateHasChanged();
     }
+
+    /// <summary>Fired from wwwroot/js/visibility.js when the tab goes
+    /// hidden. Pauses the AIS push timer so a long-hidden tab doesn't
+    /// queue backlogged ticks that drain back-to-back on resume and
+    /// trip Chrome's "page unresponsive" dialog. Idempotent: a no-op
+    /// when already hidden.</summary>
+    [JSInvokable]
+    public void OnPageHidden()
+    {
+        if (!_pageIsVisible) return;
+        _pageIsVisible = false;
+        // ObjectDisposedException can race with DisposeAsync: the
+        // detach call in DisposeAsync runs before aisTimer.DisposeAsync,
+        // but a visibilitychange that JS already dispatched can still
+        // be in flight on the WASM scheduler. Swallow the race; the
+        // page is going away anyway.
+        try { aisTimer?.Change(Timeout.Infinite, Timeout.Infinite); }
+        catch (ObjectDisposedException) { }
+    }
+
+    /// <summary>Fired from wwwroot/js/visibility.js when the tab
+    /// becomes visible. Re-arms the AIS push timer with the standard
+    /// initial-delay so the first push lands ~1 s after wake-up,
+    /// giving Blazor's render scheduler room to settle the layout pass
+    /// before the JSInterop payload hits the same frame. Idempotent.
+    /// </summary>
+    [JSInvokable]
+    public void OnPageVisible()
+    {
+        if (_pageIsVisible) return;
+        _pageIsVisible = true;
+        try { aisTimer?.Change(AisPushInitialDelayMs, AisPushIntervalMs); }
+        catch (ObjectDisposedException) { }
+    }
     // Per-tick frame-building state (previous position, laylines
     // throttle counter, course-line-drawn flag) lives in this builder
     // so the decision tree in HandleDataChanged stays small and the
@@ -1479,6 +1524,32 @@
         deadmanModule = await JS.InvokeAsync<IJSObjectReference>("import", "./js/deadman.js");
         await deadmanModule.InvokeVoidAsync("attachDeadman", dotNetRef, nameof(OnDeadmanTouch));
 
+        // Pause the AIS push timer when the tab goes hidden. The
+        // WebSocket stays connected so anchor / CPA / MOB alarms keep
+        // evaluating from live SK data, but the 3 s push (200+ vessel
+        // CPA/COLREGS compute + JSInterop payload) is wasted work on
+        // an invisible chart. Without this, a long-hidden tab queues
+        // backlogged ticks under Chrome's background throttle and on
+        // resume drains them back-to-back on the single WASM thread,
+        // blocking the renderer past 5 s and tripping the "page
+        // unresponsive" dialog.
+        try
+        {
+            visibilityEdgesModule = await JS.InvokeAsync<IJSObjectReference>(
+                "import", "./js/visibility.js");
+            await visibilityEdgesModule.InvokeVoidAsync(
+                "attachVisibilityEdges", dotNetRef,
+                nameof(OnPageVisible), nameof(OnPageHidden));
+        }
+        catch (JSDisconnectedException) { }
+        catch (Exception ex)
+        {
+            // Best-effort: a missing module file or a JSDisconnected at
+            // boot leaves the page running its previous wake-up shape
+            // rather than failing the whole Map mount.
+            Console.Error.WriteLine($"[map] visibility-edges hook failed: {ex.Message}");
+        }
+
         // Hand the loaded module to the radar overlay host so the
         // manager can drive it. Wired here (not in DI) because the
         // module reference only exists after the import resolves.
@@ -4936,6 +5007,19 @@
             }
             catch (JSDisconnectedException) { }
         }
+        // Same shape as the deadman teardown above: detach the JS-side
+        // visibility-edges listener BEFORE the dotNetRef is disposed so
+        // a visibilitychange firing mid-dispose doesn't try to invoke
+        // OnPageHidden/Visible on a torn-down proxy.
+        if (visibilityEdgesModule is not null)
+        {
+            try
+            {
+                await visibilityEdgesModule.InvokeVoidAsync("detachVisibilityEdges");
+                await visibilityEdgesModule.DisposeAsync();
+            }
+            catch (JSDisconnectedException) { }
+        }
         if (module is not null)
         {
             // Bare interop: MarkDisposed above already gates the typed

OnaPlotter/wwwroot/js/visibility.js

@@ -1,13 +1,20 @@
-// Tab-visibility hook used by MainLayout's auth chip: when the
-// helm switches away to the SK admin tab to log in and switches
-// back, we want to re-probe /skServer/loginStatus immediately so
-// the "Not logged in" chip clears without waiting up to 5 minutes
-// for the next poll. Without this, the chip is a UX dead-end -
-// the helm fixed the underlying problem but the warning insists
-// otherwise.
+// Tab-visibility hooks.
 //
-// Browser support: visibilitychange is universal in modern
-// browsers (every browser shipping in 2024+). No polyfill needed.
+// `attachVisibilityListener` is the one-shot visible-edge hook used by
+// MainLayout's auth chip: when the helm switches away to the SK admin
+// tab to log in and switches back, we re-probe /skServer/loginStatus
+// immediately so the "Not logged in" chip clears without waiting up to
+// 5 minutes for the next poll.
+//
+// `attachVisibilityEdges` is the both-edges hook used by Map.razor to
+// pause the AIS push timer while hidden. A long-hidden tab otherwise
+// queues 3 s ticks at heavy throttle; on resume Chrome unleashes the
+// backlog plus a 200+ vessel CPA/COLREGS compute through the single
+// WASM thread, blocks the renderer past 5 s, and trips Chrome's "page
+// unresponsive" dialog.
+//
+// Browser support: visibilitychange is universal in modern browsers
+// (every browser shipping in 2024+). No polyfill needed.
 
 let _attached = false;
 
@@ -35,3 +42,51 @@ export function attachVisibilityListener(dotNetRef, methodName) {
         dotNetRef.invokeMethodAsync(methodName).catch(() => {});
     });
 }
+
+// State for attachVisibilityEdges. Separate from the auth-chip flag
+// above because the page-edges hook follows Map.razor's lifecycle and
+// needs detach on nav-away, while the auth chip listener stays for
+// the life of the app (MainLayout never unmounts).
+let _edgesListener = null;
+
+/**
+ * Register a document listener that fires one of two [JSInvokable]
+ * methods on every visibility transition, depending on direction.
+ * One subscriber at a time - calling attach again replaces the
+ * previous handler so an OnAfterRenderAsync re-run (re-mount on
+ * browser back / forward) doesn't stack listeners.
+ *
+ * Also fires the hidden-edge callback synchronously if the tab is
+ * already hidden at attach time - covers the case where the helm
+ * navigated to /map from another tab and switched away before the
+ * page finished mounting; without this, the AIS timer the page just
+ * armed would tick uselessly until the helm returns and the visible-
+ * edge fires.
+ *
+ * @param dotNetRef        DotNetObjectReference<Map> from C# side
+ * @param onVisibleMethod  [JSInvokable] name to invoke on visible-edge
+ * @param onHiddenMethod   [JSInvokable] name to invoke on hidden-edge
+ */
+export function attachVisibilityEdges(dotNetRef, onVisibleMethod, onHiddenMethod) {
+    detachVisibilityEdges();
+    _edgesListener = () => {
+        const method = document.visibilityState === 'visible'
+            ? onVisibleMethod : onHiddenMethod;
+        if (!method || !dotNetRef) return;
+        dotNetRef.invokeMethodAsync(method).catch(() => {});
+    };
+    document.addEventListener('visibilitychange', _edgesListener);
+    if (document.visibilityState === 'hidden' && onHiddenMethod && dotNetRef) {
+        dotNetRef.invokeMethodAsync(onHiddenMethod).catch(() => {});
+    }
+}
+
+/**
+ * Tear down the listener set up by attachVisibilityEdges. Safe to
+ * call when no listener is attached (idempotent).
+ */
+export function detachVisibilityEdges() {
+    if (!_edgesListener) return;
+    document.removeEventListener('visibilitychange', _edgesListener);
+    _edgesListener = null;
+}