@n-dx/core 0.1.0

package/packages/web/dist/viewer/polling/tick-visibility-gate.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Tick visibility gate — pauses elapsed time timer updates during tab inactivity.
+ *
+ * Bridges the Page Visibility API (via tab-visibility) to the tick timer's
+ * suspend/resume lifecycle. When the browser tab is backgrounded, the tick
+ * timer's shared setInterval is cleared to conserve CPU and battery. When the
+ * tab returns to the foreground, the timer is resumed with an immediate
+ * catch-up tick so elapsed time displays jump to the correct current value.
+ *
+ * Pipeline position:
+ *
+ *   tab-visibility → **tick-visibility-gate** → tick-timer → batched-tick-dispatcher → useTick → render
+ *
+ * When visible:  tick timer runs normally (1s interval)
+ * When hidden:   tick timer is suspended (no interval, no ticks, zero CPU)
+ * On resume:     immediate catch-up tick → restart interval
+ *
+ * Lifecycle:
+ *
+ *   Tab goes hidden:
+ *     1. Immediately suspend the tick timer (clearInterval).
+ *     2. No ticks fire while the tab is hidden — zero overhead.
+ *
+ *   Tab becomes visible (after resume debounce):
+ *     1. Resume the tick timer — fires an immediate tick for catch-up,
+ *        then restarts the 1-second interval.
+ *     2. The immediate tick causes all elapsed time displays to recompute
+ *        from their absolute startedAt timestamps, jumping to the correct
+ *        current value without waiting up to 1 second.
+ *
+ * The resume is debounced (100ms default) to prevent thrashing during rapid
+ * tab switching (e.g. quick alt-tab sequences). Suspension is always immediate
+ * to stop unnecessary work as fast as possible.
+ *
+ * This module complements the polling-manager (which manages its own set of
+ * registered pollers) and the DOM update gate (which gates state updates).
+ * Together they form a complete tab-inactivity optimization pipeline.
+ *
+ * Designed as a standalone module with zero framework dependencies.
+ */
+/** Configuration for the tick visibility gate. */
+export interface TickVisibilityGateConfig {
+    /**
+     * Debounce delay in milliseconds before resuming the tick timer after
+     * the tab becomes visible. Prevents thrashing on rapid tab switches.
+     * Default: 100ms (matches polling-manager and DOM update gate debounce).
+     */
+    resumeDebounceMs?: number | undefined;
+    /**
+     * Called when the tick timer is suspended (tab went hidden).
+     * Optional — useful for monitoring and debugging.
+     */
+    onSuspend?: (() => void) | undefined;
+    /**
+     * Called when the tick timer is resumed (tab became visible, after debounce).
+     * Optional — useful for monitoring and debugging.
+     */
+    onResume?: (() => void) | undefined;
+}
+/** Read-only snapshot of the gate's current state. */
+export interface TickVisibilityGateSnapshot {
+    /** Whether the tick timer is currently running (gate is open). */
+    readonly isRunning: boolean;
+    /** Number of times the timer has been suspended. */
+    readonly suspensionCount: number;
+    /** Number of times the timer has been resumed (after debounce). */
+    readonly resumeCount: number;
+    /** Whether the gate has been disposed. */
+    readonly disposed: boolean;
+}
+/** A tick visibility gate instance. */
+export interface TickVisibilityGate {
+    /** Whether the tick timer is currently running. */
+    isRunning(): boolean;
+    /** Get a snapshot of the gate's current state. */
+    getSnapshot(): TickVisibilityGateSnapshot;
+    /** Dispose: unsubscribe from visibility events, clear debounce timer. */
+    dispose(): void;
+}
+/**
+ * Create a new tick visibility gate.
+ *
+ * Usage:
+ * ```ts
+ * // During app initialization (after startTabVisibilityMonitor):
+ * const gate = createTickVisibilityGate();
+ *
+ * // On app shutdown:
+ * gate.dispose();
+ * ```
+ */
+export declare function createTickVisibilityGate(config?: TickVisibilityGateConfig): TickVisibilityGate;

package/packages/web/dist/viewer/polling/tick-visibility-gate.js

@@ -0,0 +1,146 @@
+/**
+ * Tick visibility gate — pauses elapsed time timer updates during tab inactivity.
+ *
+ * Bridges the Page Visibility API (via tab-visibility) to the tick timer's
+ * suspend/resume lifecycle. When the browser tab is backgrounded, the tick
+ * timer's shared setInterval is cleared to conserve CPU and battery. When the
+ * tab returns to the foreground, the timer is resumed with an immediate
+ * catch-up tick so elapsed time displays jump to the correct current value.
+ *
+ * Pipeline position:
+ *
+ *   tab-visibility → **tick-visibility-gate** → tick-timer → batched-tick-dispatcher → useTick → render
+ *
+ * When visible:  tick timer runs normally (1s interval)
+ * When hidden:   tick timer is suspended (no interval, no ticks, zero CPU)
+ * On resume:     immediate catch-up tick → restart interval
+ *
+ * Lifecycle:
+ *
+ *   Tab goes hidden:
+ *     1. Immediately suspend the tick timer (clearInterval).
+ *     2. No ticks fire while the tab is hidden — zero overhead.
+ *
+ *   Tab becomes visible (after resume debounce):
+ *     1. Resume the tick timer — fires an immediate tick for catch-up,
+ *        then restarts the 1-second interval.
+ *     2. The immediate tick causes all elapsed time displays to recompute
+ *        from their absolute startedAt timestamps, jumping to the correct
+ *        current value without waiting up to 1 second.
+ *
+ * The resume is debounced (100ms default) to prevent thrashing during rapid
+ * tab switching (e.g. quick alt-tab sequences). Suspension is always immediate
+ * to stop unnecessary work as fast as possible.
+ *
+ * This module complements the polling-manager (which manages its own set of
+ * registered pollers) and the DOM update gate (which gates state updates).
+ * Together they form a complete tab-inactivity optimization pipeline.
+ *
+ * Designed as a standalone module with zero framework dependencies.
+ */
+import { onVisibilityChange, isTabVisible, } from "./tab-visibility.js";
+import { suspendTickTimer, resumeTickTimer } from "./tick-timer.js";
+// ─── Constants ───────────────────────────────────────────────────────────────
+const DEFAULT_RESUME_DEBOUNCE_MS = 100;
+// ─── Factory ─────────────────────────────────────────────────────────────────
+/**
+ * Create a new tick visibility gate.
+ *
+ * Usage:
+ * ```ts
+ * // During app initialization (after startTabVisibilityMonitor):
+ * const gate = createTickVisibilityGate();
+ *
+ * // On app shutdown:
+ * gate.dispose();
+ * ```
+ */
+export function createTickVisibilityGate(config = {}) {
+    const resumeDebounceMs = config.resumeDebounceMs ?? DEFAULT_RESUME_DEBOUNCE_MS;
+    const onSuspend = config.onSuspend;
+    const onResume = config.onResume;
+    let running = true;
+    let suspensionCount = 0;
+    let resumeCount = 0;
+    let resumeTimer = null;
+    let disposed = false;
+    // ─── Internal helpers ─────────────────────────────────────────────
+    function clearResumeTimer() {
+        if (resumeTimer !== null) {
+            clearTimeout(resumeTimer);
+            resumeTimer = null;
+        }
+    }
+    function suspend() {
+        if (!running)
+            return;
+        running = false;
+        suspensionCount++;
+        suspendTickTimer();
+        if (onSuspend) {
+            try {
+                onSuspend();
+            }
+            catch {
+                // Swallow errors from the suspend callback.
+            }
+        }
+    }
+    function resume() {
+        if (running)
+            return;
+        running = true;
+        resumeCount++;
+        resumeTickTimer();
+        if (onResume) {
+            try {
+                onResume();
+            }
+            catch {
+                // Swallow errors from the resume callback.
+            }
+        }
+    }
+    function handleVisibilityChange(snapshot) {
+        if (disposed)
+            return;
+        if (snapshot.isVisible) {
+            // Tab became visible — resume with debounce to prevent thrash.
+            clearResumeTimer();
+            resumeTimer = setTimeout(() => {
+                resumeTimer = null;
+                resume();
+            }, resumeDebounceMs);
+        }
+        else {
+            // Tab became hidden — suspend immediately.
+            clearResumeTimer();
+            suspend();
+        }
+    }
+    // Subscribe to tab visibility changes.
+    const unsubVisibility = onVisibilityChange(handleVisibilityChange);
+    // If the tab is currently hidden, suspend immediately.
+    if (!isTabVisible()) {
+        suspend();
+    }
+    // ─── Public methods ─────────────────────────────────────────────────
+    function isRunning() {
+        return running;
+    }
+    function getSnapshot() {
+        return {
+            isRunning: running,
+            suspensionCount,
+            resumeCount,
+            disposed,
+        };
+    }
+    function dispose() {
+        disposed = true;
+        clearResumeTimer();
+        unsubVisibility();
+    }
+    return { isRunning, getSnapshot, dispose };
+}
+//# sourceMappingURL=tick-visibility-gate.js.map

package/packages/web/dist/viewer/polling/tick-visibility-gate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tick-visibility-gate.js","sourceRoot":"","sources":["../../../src/viewer/polling/tick-visibility-gate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,OAAO,EACL,kBAAkB,EAClB,YAAY,GAEb,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAkDpE,gFAAgF;AAEhF,MAAM,0BAA0B,GAAG,GAAG,CAAC;AAEvC,gFAAgF;AAEhF;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,wBAAwB,CACtC,SAAmC,EAAE;IAErC,MAAM,gBAAgB,GAAG,MAAM,CAAC,gBAAgB,IAAI,0BAA0B,CAAC;IAC/E,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,CAAC;IACnC,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC;IAEjC,IAAI,OAAO,GAAG,IAAI,CAAC;IACnB,IAAI,eAAe,GAAG,CAAC,CAAC;IACxB,IAAI,WAAW,GAAG,CAAC,CAAC;IACpB,IAAI,WAAW,GAAyC,IAAI,CAAC;IAC7D,IAAI,QAAQ,GAAG,KAAK,CAAC;IAErB,qEAAqE;IAErE,SAAS,gBAAgB;QACvB,IAAI,WAAW,KAAK,IAAI,EAAE,CAAC;YACzB,YAAY,CAAC,WAAW,CAAC,CAAC;YAC1B,WAAW,GAAG,IAAI,CAAC;QACrB,CAAC;IACH,CAAC;IAED,SAAS,OAAO;QACd,IAAI,CAAC,OAAO;YAAE,OAAO;QAErB,OAAO,GAAG,KAAK,CAAC;QAChB,eAAe,EAAE,CAAC;QAElB,gBAAgB,EAAE,CAAC;QAEnB,IAAI,SAAS,EAAE,CAAC;YACd,IAAI,CAAC;gBACH,SAAS,EAAE,CAAC;YACd,CAAC;YAAC,MAAM,CAAC;gBACP,4CAA4C;YAC9C,CAAC;QACH,CAAC;IACH,CAAC;IAED,SAAS,MAAM;QACb,IAAI,OAAO;YAAE,OAAO;QAEpB,OAAO,GAAG,IAAI,CAAC;QACf,WAAW,EAAE,CAAC;QAEd,eAAe,EAAE,CAAC;QAElB,IAAI,QAAQ,EAAE,CAAC;YACb,IAAI,CAAC;gBACH,QAAQ,EAAE,CAAC;YACb,CAAC;YAAC,MAAM,CAAC;gBACP,2CAA2C;YAC7C,CAAC;QACH,CAAC;IACH,CAAC;IAED,SAAS,sBAAsB,CAAC,QAA+B;QAC7D,IAAI,QAAQ;YAAE,OAAO;QAErB,IAAI,QAAQ,CAAC,SAAS,EAAE,CAAC;YACvB,+DAA+D;YAC/D,gBAAgB,EAAE,CAAC;YACnB,WAAW,GAAG,UAAU,CAAC,GAAG,EAAE;gBAC5B,WAAW,GAAG,IAAI,CAAC;gBACnB,MAAM,EAAE,CAAC;YACX,CAAC,EAAE,gBAAgB,CAAC,CAAC;QACvB,CAAC;aAAM,CAAC;YACN,2CAA2C;YAC3C,gBAAgB,EAAE,CAAC;YACnB,OAAO,EAAE,CAAC;QACZ,CAAC;IACH,CAAC;IAED,uCAAuC;IACvC,MAAM,eAAe,GAAG,kBAAkB,CAAC,sBAAsB,CAAC,CAAC;IAEnE,uDAAuD;IACvD,IAAI,CAAC,YAAY,EAAE,EAAE,CAAC;QACpB,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,uEAAuE;IAEvE,SAAS,SAAS;QAChB,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,SAAS,WAAW;QAClB,OAAO;YACL,SAAS,EAAE,OAAO;YAClB,eAAe;YACf,WAAW;YACX,QAAQ;SACT,CAAC;IACJ,CAAC;IAED,SAAS,OAAO;QACd,QAAQ,GAAG,IAAI,CAAC;QAChB,gBAAgB,EAAE,CAAC;QACnB,eAAe,EAAE,CAAC;IACpB,CAAC;IAED,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,OAAO,EAAE,CAAC;AAC7C,CAAC"}

package/packages/web/dist/viewer/polling-manager.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Centralized polling manager with tab visibility integration.
+ *
+ * Provides a registry for all polling intervals across the application.
+ * When the browser tab is backgrounded, all registered pollers are
+ * suspended to conserve resources. When the tab regains focus, pollers
+ * are resumed with their original intervals.
+ *
+ * Rapid visibility changes (e.g. quick alt-tab sequences) are debounced
+ * to avoid thrashing interval creation/destruction.
+ *
+ * Designed as a standalone module with zero framework dependencies —
+ * the Preact hook (`usePolling`) is provided separately.
+ */
+/** Read-only view of a registered poller for external inspection. */
+export interface PollerInfo {
+    readonly key: string;
+    readonly intervalMs: number;
+    readonly active: boolean;
+}
+/**
+ * Start the polling manager. Subscribes to tab visibility changes
+ * and enables automatic suspend/resume of registered pollers.
+ *
+ * Safe to call multiple times — restarts cleanly.
+ */
+export declare function startPollingManager(): void;
+/**
+ * Stop the polling manager. Unsubscribes from visibility changes
+ * but does NOT clear registered pollers or their timers.
+ */
+export declare function stopPollingManager(): void;
+/**
+ * Register a polling interval. The callback will be called every
+ * `intervalMs` milliseconds while the tab is visible.
+ *
+ * If the tab is currently hidden and the manager is started,
+ * the poller is registered but not activated until the tab becomes visible.
+ *
+ * Returns an unregister function for cleanup.
+ *
+ * @param key - Unique identifier for this poller. Re-registering with the
+ *              same key replaces the previous entry.
+ * @param callback - Function to call on each tick.
+ * @param intervalMs - Polling interval in milliseconds.
+ */
+export declare function registerPoller(key: string, callback: () => void, intervalMs: number): () => void;
+/**
+ * Remove a poller from the registry and clear its interval.
+ */
+export declare function unregisterPoller(key: string): void;
+/**
+ * Suspend all registered pollers. Clears their interval timers
+ * but keeps them in the registry for later resumption.
+ */
+export declare function suspendAll(): void;
+/**
+ * Resume all registered pollers. Restarts their interval timers
+ * with their original intervals.
+ */
+export declare function resumeAll(): void;
+/**
+ * Check if the polling manager is currently in a suspended state.
+ */
+export declare function isSuspended(): boolean;
+/**
+ * Check if a specific poller is actively running (has a timer).
+ */
+export declare function isPollerActive(key: string): boolean;
+/**
+ * Get read-only information about all registered pollers.
+ */
+export declare function getRegisteredPollers(): readonly PollerInfo[];
+/**
+ * Get the number of registered pollers.
+ */
+export declare function getPollerCount(): number;
+/**
+ * Reset all module state (for testing). Clears all pollers, stops the
+ * manager, and resets the suspended flag.
+ */
+export declare function resetPollingManager(): void;

package/packages/web/dist/viewer/polling-manager.js

@@ -0,0 +1,254 @@
+/**
+ * Centralized polling manager with tab visibility integration.
+ *
+ * Provides a registry for all polling intervals across the application.
+ * When the browser tab is backgrounded, all registered pollers are
+ * suspended to conserve resources. When the tab regains focus, pollers
+ * are resumed with their original intervals.
+ *
+ * Rapid visibility changes (e.g. quick alt-tab sequences) are debounced
+ * to avoid thrashing interval creation/destruction.
+ *
+ * Designed as a standalone module with zero framework dependencies —
+ * the Preact hook (`usePolling`) is provided separately.
+ */
+import { onVisibilityChange, isTabVisible, } from "./tab-visibility.js";
+import { registerPollingSource, } from "./polling-state.js";
+// ─── Constants ───────────────────────────────────────────────────────────────
+/**
+ * Debounce delay for visibility-triggered resume (ms).
+ * Prevents thrashing when the user rapidly switches between tabs.
+ * Suspension is immediate (no debounce) to stop work quickly.
+ */
+const RESUME_DEBOUNCE_MS = 100;
+// ─── Constants (polling-state integration) ───────────────────────────────────
+const POLLING_STATE_KEY = "polling-manager";
+// ─── Module state ────────────────────────────────────────────────────────────
+const pollers = new Map();
+let visibilityUnsub = null;
+let stateUnsub = null;
+let started = false;
+let suspended = false;
+let resumeDebounceTimer = null;
+// ─── Internal helpers ────────────────────────────────────────────────────────
+/**
+ * Clean up the polling manager's own resources (visibility subscription,
+ * debounce timer, poller intervals). Does NOT touch polling-state
+ * registration — callers are responsible for that coordination.
+ */
+function cleanupOwnResources() {
+    if (visibilityUnsub) {
+        visibilityUnsub();
+        visibilityUnsub = null;
+    }
+    if (resumeDebounceTimer !== null) {
+        clearTimeout(resumeDebounceTimer);
+        resumeDebounceTimer = null;
+    }
+}
+/** Start a poller's interval timer. */
+function activatePoller(entry) {
+    if (entry.timerId !== null)
+        return; // already active
+    entry.timerId = setInterval(entry.callback, entry.intervalMs);
+}
+/** Stop a poller's interval timer without removing it from the registry. */
+function deactivatePoller(entry) {
+    if (entry.timerId === null)
+        return; // already inactive
+    clearInterval(entry.timerId);
+    entry.timerId = null;
+}
+/** Handle visibility change events from the tab-visibility module. */
+function handleVisibilityChange(snapshot) {
+    if (snapshot.isVisible) {
+        // Tab became visible — resume with debounce to handle rapid toggling.
+        if (resumeDebounceTimer !== null) {
+            clearTimeout(resumeDebounceTimer);
+        }
+        resumeDebounceTimer = setTimeout(() => {
+            resumeDebounceTimer = null;
+            resumeAll();
+        }, RESUME_DEBOUNCE_MS);
+    }
+    else {
+        // Tab became hidden — suspend immediately.
+        // Cancel any pending resume first.
+        if (resumeDebounceTimer !== null) {
+            clearTimeout(resumeDebounceTimer);
+            resumeDebounceTimer = null;
+        }
+        suspendAll();
+    }
+}
+// ─── Public API ──────────────────────────────────────────────────────────────
+/**
+ * Start the polling manager. Subscribes to tab visibility changes
+ * and enables automatic suspend/resume of registered pollers.
+ *
+ * Safe to call multiple times — restarts cleanly.
+ */
+export function startPollingManager() {
+    if (started)
+        stopPollingManager();
+    started = true;
+    suspended = false;
+    // Subscribe to tab visibility changes.
+    visibilityUnsub = onVisibilityChange(handleVisibilityChange);
+    // If the tab is currently hidden, start in suspended state.
+    if (!isTabVisible()) {
+        suspended = true;
+    }
+    // Register with centralized polling state for coordinated lifecycle.
+    // The dispose callback cleans up own resources without calling
+    // stopPollingManager (which would re-entrantly unregister from
+    // polling-state, causing a loop).
+    stateUnsub = registerPollingSource(POLLING_STATE_KEY, {
+        suspend: () => suspendAll(),
+        resume: () => resumeAll(),
+        dispose: () => {
+            for (const entry of pollers.values()) {
+                deactivatePoller(entry);
+            }
+            cleanupOwnResources();
+            started = false;
+            stateUnsub = null; // Already being disposed by polling-state.
+        },
+        getStatus: () => {
+            if (!started)
+                return "idle";
+            return suspended ? "suspended" : "active";
+        },
+    });
+}
+/**
+ * Stop the polling manager. Unsubscribes from visibility changes
+ * but does NOT clear registered pollers or their timers.
+ */
+export function stopPollingManager() {
+    cleanupOwnResources();
+    started = false;
+    // Deregister from centralized polling state. Nullify stateUnsub first
+    // to prevent re-entrant dispose (unregisterPollingSource calls dispose,
+    // which would otherwise try to call stateUnsub again).
+    if (stateUnsub) {
+        const unsub = stateUnsub;
+        stateUnsub = null;
+        unsub();
+    }
+}
+/**
+ * Register a polling interval. The callback will be called every
+ * `intervalMs` milliseconds while the tab is visible.
+ *
+ * If the tab is currently hidden and the manager is started,
+ * the poller is registered but not activated until the tab becomes visible.
+ *
+ * Returns an unregister function for cleanup.
+ *
+ * @param key - Unique identifier for this poller. Re-registering with the
+ *              same key replaces the previous entry.
+ * @param callback - Function to call on each tick.
+ * @param intervalMs - Polling interval in milliseconds.
+ */
+export function registerPoller(key, callback, intervalMs) {
+    // If a poller with this key already exists, clean it up first.
+    const existing = pollers.get(key);
+    if (existing) {
+        deactivatePoller(existing);
+    }
+    const entry = {
+        key,
+        callback,
+        intervalMs,
+        timerId: null,
+    };
+    pollers.set(key, entry);
+    // Only activate if the manager is started and not suspended.
+    if (started && !suspended) {
+        activatePoller(entry);
+    }
+    else if (!started) {
+        // Manager not started — activate immediately (unmanaged mode).
+        activatePoller(entry);
+    }
+    return () => unregisterPoller(key);
+}
+/**
+ * Remove a poller from the registry and clear its interval.
+ */
+export function unregisterPoller(key) {
+    const entry = pollers.get(key);
+    if (!entry)
+        return;
+    deactivatePoller(entry);
+    pollers.delete(key);
+}
+/**
+ * Suspend all registered pollers. Clears their interval timers
+ * but keeps them in the registry for later resumption.
+ */
+export function suspendAll() {
+    suspended = true;
+    for (const entry of pollers.values()) {
+        deactivatePoller(entry);
+    }
+}
+/**
+ * Resume all registered pollers. Restarts their interval timers
+ * with their original intervals.
+ */
+export function resumeAll() {
+    suspended = false;
+    for (const entry of pollers.values()) {
+        activatePoller(entry);
+    }
+}
+/**
+ * Check if the polling manager is currently in a suspended state.
+ */
+export function isSuspended() {
+    return suspended;
+}
+/**
+ * Check if a specific poller is actively running (has a timer).
+ */
+export function isPollerActive(key) {
+    const entry = pollers.get(key);
+    return entry !== null && entry !== undefined && entry.timerId !== null;
+}
+/**
+ * Get read-only information about all registered pollers.
+ */
+export function getRegisteredPollers() {
+    const result = [];
+    for (const entry of pollers.values()) {
+        result.push({
+            key: entry.key,
+            intervalMs: entry.intervalMs,
+            active: entry.timerId !== null,
+        });
+    }
+    return result;
+}
+/**
+ * Get the number of registered pollers.
+ */
+export function getPollerCount() {
+    return pollers.size;
+}
+/**
+ * Reset all module state (for testing). Clears all pollers, stops the
+ * manager, and resets the suspended flag.
+ */
+export function resetPollingManager() {
+    // Clear all pollers.
+    for (const entry of pollers.values()) {
+        deactivatePoller(entry);
+    }
+    pollers.clear();
+    // Stop the manager.
+    stopPollingManager();
+    suspended = false;
+}
+//# sourceMappingURL=polling-manager.js.map

package/packages/web/dist/viewer/polling-manager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"polling-manager.js","sourceRoot":"","sources":["../../src/viewer/polling-manager.ts"],"names":[],"mappings":"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"}

package/packages/web/dist/viewer/polling-restart.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Polling restart coordinator.
+ *
+ * Bridges the graceful-degradation system to the centralized polling-state
+ * manager. When memory pressure disables the `autoRefresh` feature, this
+ * module calls `suspendAllSources()` to halt all non-essential polling
+ * sources in one atomic operation. When pressure subsides and `autoRefresh`
+ * is re-enabled, it calls `resumeAllSources()` to restart everything at
+ * original intervals.
+ *
+ * This provides a safety net that ensures **all** polling loops stop and
+ * restart together, even if an individual component forgets to handle
+ * degradation on its own. Components that also track degradation individually
+ * (e.g. status-indicators, use-app-data) coexist harmlessly — suspending
+ * an already-suspended source or resuming an already-active one is a no-op
+ * in both polling-state and polling-manager.
+ *
+ * Flow:
+ *
+ *   memory-monitor  →  graceful-degradation  →  polling-restart
+ *                                                     ↓
+ *                                               polling-state
+ *                                                ↓         ↓
+ *                                          polling-manager  tick-timer
+ *
+ * Designed as a standalone module with zero framework dependencies.
+ */
+/**
+ * Start the polling restart coordinator.
+ *
+ * Subscribes to degradation changes and evaluates the current state
+ * immediately. If `autoRefresh` is already disabled (e.g. the coordinator
+ * is started after memory pressure began), sources are suspended at once.
+ *
+ * Safe to call multiple times — restarts cleanly.
+ */
+export declare function startPollingRestart(): void;
+/**
+ * Stop the polling restart coordinator.
+ *
+ * Unsubscribes from degradation changes. If the coordinator had
+ * triggered a global suspension, sources are resumed to avoid
+ * leaving polling permanently frozen.
+ */
+export declare function stopPollingRestart(): void;
+/**
+ * Check if the coordinator is currently running.
+ */
+export declare function isPollingRestartStarted(): boolean;
+/**
+ * Check if the coordinator has triggered a global suspension.
+ */
+export declare function isCoordinatorSuspended(): boolean;
+/**
+ * Reset all module state (for testing).
+ */
+export declare function resetPollingRestart(): void;