@n-dx/core 0.1.0

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

@@ -0,0 +1,98 @@
+/**
+ * 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.
+ */
+import { suspendAllSources, resumeAllSources, } from "./polling-state.js";
+import { onDegradationChange, isFeatureDisabled, } from "../performance/graceful-degradation.js";
+// ─── Module state ────────────────────────────────────────────────────────────
+let unsubscribeDegradation = null;
+let started = false;
+/**
+ * Whether the coordinator has triggered a global suspension.
+ * Tracked separately from polling-state's `isGlobalSuspended()` so we
+ * only call `resumeAllSources()` if **we** were the ones who suspended
+ * — avoids interfering with other suspension triggers (e.g. a future
+ * manual pause button).
+ */
+let coordinatorSuspended = false;
+// ─── Internal handler ────────────────────────────────────────────────────────
+function handleDegradationChange(state) {
+    const autoRefreshDisabled = state.disabledFeatures.has("autoRefresh");
+    if (autoRefreshDisabled && !coordinatorSuspended) {
+        // Memory pressure activated — suspend all non-essential sources.
+        coordinatorSuspended = true;
+        suspendAllSources();
+    }
+    else if (!autoRefreshDisabled && coordinatorSuspended) {
+        // Memory pressure cleared — restart all sources at original intervals.
+        coordinatorSuspended = false;
+        resumeAllSources();
+    }
+}
+// ─── Public API ──────────────────────────────────────────────────────────────
+/**
+ * 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 function startPollingRestart() {
+    if (started)
+        stopPollingRestart();
+    started = true;
+    coordinatorSuspended = false;
+    // Subscribe to ongoing degradation changes.
+    unsubscribeDegradation = onDegradationChange(handleDegradationChange);
+    // Evaluate current state immediately (handles late-start scenarios).
+    if (isFeatureDisabled("autoRefresh")) {
+        coordinatorSuspended = true;
+        suspendAllSources();
+    }
+}
+/**
+ * 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 function stopPollingRestart() {
+    if (unsubscribeDegradation) {
+        unsubscribeDegradation();
+        unsubscribeDegradation = null;
+    }
+    // If we suspended sources, resume them so we don't leave
+    // polling frozen after the coordinator is stopped.
+    if (coordinatorSuspended) {
+        coordinatorSuspended = false;
+        resumeAllSources();
+    }
+    started = false;
+}
+//# sourceMappingURL=polling-restart.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"polling-restart.js","sourceRoot":"","sources":["../../../src/viewer/polling/polling-restart.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,EACL,iBAAiB,EACjB,gBAAgB,GAIjB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,mBAAmB,EACnB,iBAAiB,GAElB,MAAM,wCAAwC,CAAC;AAEhD,gFAAgF;AAEhF,IAAI,sBAAsB,GAAwB,IAAI,CAAC;AACvD,IAAI,OAAO,GAAG,KAAK,CAAC;AAEpB;;;;;;GAMG;AACH,IAAI,oBAAoB,GAAG,KAAK,CAAC;AAEjC,gFAAgF;AAEhF,SAAS,uBAAuB,CAAC,KAAuB;IACtD,MAAM,mBAAmB,GAAG,KAAK,CAAC,gBAAgB,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;IAEtE,IAAI,mBAAmB,IAAI,CAAC,oBAAoB,EAAE,CAAC;QACjD,iEAAiE;QACjE,oBAAoB,GAAG,IAAI,CAAC;QAC5B,iBAAiB,EAAE,CAAC;IACtB,CAAC;SAAM,IAAI,CAAC,mBAAmB,IAAI,oBAAoB,EAAE,CAAC;QACxD,uEAAuE;QACvE,oBAAoB,GAAG,KAAK,CAAC;QAC7B,gBAAgB,EAAE,CAAC;IACrB,CAAC;AACH,CAAC;AAED,gFAAgF;AAEhF;;;;;;;;GAQG;AACH,MAAM,UAAU,mBAAmB;IACjC,IAAI,OAAO;QAAE,kBAAkB,EAAE,CAAC;IAElC,OAAO,GAAG,IAAI,CAAC;IACf,oBAAoB,GAAG,KAAK,CAAC;IAE7B,4CAA4C;IAC5C,sBAAsB,GAAG,mBAAmB,CAAC,uBAAuB,CAAC,CAAC;IAEtE,qEAAqE;IACrE,IAAI,iBAAiB,CAAC,aAAa,CAAC,EAAE,CAAC;QACrC,oBAAoB,GAAG,IAAI,CAAC;QAC5B,iBAAiB,EAAE,CAAC;IACtB,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,kBAAkB;IAChC,IAAI,sBAAsB,EAAE,CAAC;QAC3B,sBAAsB,EAAE,CAAC;QACzB,sBAAsB,GAAG,IAAI,CAAC;IAChC,CAAC;IAED,yDAAyD;IACzD,mDAAmD;IACnD,IAAI,oBAAoB,EAAE,CAAC;QACzB,oBAAoB,GAAG,KAAK,CAAC;QAC7B,gBAAgB,EAAE,CAAC;IACrB,CAAC;IAED,OAAO,GAAG,KAAK,CAAC;AAClB,CAAC"}

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

@@ -0,0 +1,182 @@
+/**
+ * Centralized polling state manager.
+ *
+ * Provides a single registry for all interval-based polling sources in the
+ * application (polling-manager, memory-monitor, DOM performance monitor,
+ * tick timer, etc.). Enables coordinated suspension, resumption, and
+ * disposal of all polling sources from one location.
+ *
+ * Problems this solves:
+ *
+ *   1. **Orphaned intervals** — Without a central registry, independent
+ *      modules that manage their own `setInterval` can leak timers if
+ *      their stop functions are never called.
+ *
+ *   2. **No single "stop everything"** — Previously, shutting down all
+ *      polling required calling individual stop functions across 4+
+ *      modules. Now `disposeAllSources()` handles it.
+ *
+ *   3. **Component remount safety** — Module-level state persists across
+ *      Preact component teardown/remount cycles. Generation IDs prevent
+ *      stale callbacks from restarting disposed sources.
+ *
+ *   4. **Memory-pressure coordination** — Sources can be tagged as
+ *      `essential` (e.g. memory-monitor must keep running to detect
+ *      recovery) or non-essential (suspended during memory pressure).
+ *
+ * Generation tracking:
+ *
+ *   Each `suspendAllSources()` / `resumeAllSources()` cycle increments a
+ *   generation counter. Callers can snapshot the generation before an
+ *   async operation and compare afterward to detect whether a
+ *   suspend/resume cycle occurred while they were waiting — preventing
+ *   stale restarts from orphaned component lifecycles.
+ *
+ * Designed as a standalone module with zero framework dependencies.
+ */
+/** Status of an individual polling source. */
+export type PollingSourceStatus = "active" | "suspended" | "disposed" | "idle";
+/** Lifecycle callbacks for a registered polling source. */
+export interface PollingSourceCallbacks {
+    /** Suspend the source (stop its interval but keep state for resume). */
+    suspend: () => void;
+    /** Resume the source (restart its interval). */
+    resume: () => void;
+    /** Fully dispose the source (stop interval, clear state). */
+    dispose: () => void;
+    /** Return the source's current status. */
+    getStatus: () => PollingSourceStatus;
+}
+/** Configuration for a polling source registration. */
+export interface PollingSourceConfig {
+    /**
+     * Whether this source is essential and should NOT be suspended during
+     * memory pressure. The memory monitor itself is essential — it must
+     * keep running to detect when pressure subsides.
+     */
+    essential: boolean;
+}
+/** Read-only view of a registered polling source. */
+export interface PollingSourceInfo {
+    readonly key: string;
+    readonly status: PollingSourceStatus;
+    readonly essential: boolean;
+    readonly registeredAt: string;
+}
+/** Read-only snapshot of the global polling state. */
+export interface PollingStateSnapshot {
+    /** All registered polling sources. */
+    readonly sources: readonly PollingSourceInfo[];
+    /** Number of registered sources. */
+    readonly sourceCount: number;
+    /** Number of currently active (running) sources. */
+    readonly activeCount: number;
+    /** Number of currently suspended sources. */
+    readonly suspendedCount: number;
+    /** Whether global suspension is active. */
+    readonly globalSuspended: boolean;
+    /** Current generation counter (increments on suspend/resume cycles). */
+    readonly generation: number;
+}
+/** Callback invoked when the global polling state changes. */
+export type PollingStateChangeHandler = (snapshot: PollingStateSnapshot) => void;
+/**
+ * Register a polling source with the centralized state manager.
+ *
+ * If a source with the same key already exists, it is disposed and replaced.
+ * If global suspension is active and the source is not essential, it will
+ * be immediately suspended after registration.
+ *
+ * Returns an unregister function that removes the source from the registry
+ * WITHOUT calling dispose. This allows sources to voluntarily unregister
+ * (e.g. during their own stop/shutdown) without triggering re-entrant
+ * dispose calls. The `dispose` callback is only invoked by
+ * `disposeAllSources()` or when the source is replaced by a new
+ * registration with the same key.
+ *
+ * @param key - Unique identifier for this source.
+ * @param callbacks - Lifecycle callbacks (suspend, resume, dispose, getStatus).
+ * @param config - Source configuration (essential flag).
+ */
+export declare function registerPollingSource(key: string, callbacks: PollingSourceCallbacks, config?: Partial<PollingSourceConfig>): () => void;
+/**
+ * Remove a polling source from the registry WITHOUT calling dispose.
+ *
+ * Use this when the source is cleaning itself up voluntarily (e.g. a
+ * module's own stop function). The source is responsible for its own
+ * resource cleanup in this case. For forced cleanup, use
+ * `disposeAllSources()`.
+ */
+export declare function unregisterPollingSource(key: string): void;
+/**
+ * Suspend all non-essential polling sources.
+ *
+ * Essential sources (e.g. memory-monitor) continue running so they can
+ * detect when conditions improve. Increments the generation counter.
+ */
+export declare function suspendAllSources(): void;
+/**
+ * Resume all suspended polling sources.
+ *
+ * Restarts non-essential sources that were suspended. Essential sources
+ * that were already running are unaffected. Increments the generation counter.
+ */
+export declare function resumeAllSources(): void;
+/**
+ * Dispose all registered polling sources and clear the registry.
+ *
+ * After this call, all intervals are stopped and all sources are removed.
+ * The generation counter is incremented. New sources can still be registered.
+ */
+export declare function disposeAllSources(): void;
+/**
+ * Check if global suspension is active.
+ */
+export declare function isGlobalSuspended(): boolean;
+/**
+ * Get the current generation counter.
+ *
+ * The generation increments on every suspend/resume/dispose cycle.
+ * Callers can snapshot this value before an async operation and compare
+ * afterward to detect whether a lifecycle change occurred.
+ */
+export declare function getGeneration(): number;
+/**
+ * Check if a specific source is registered.
+ */
+export declare function isSourceRegistered(key: string): boolean;
+/**
+ * Get read-only information about a specific source, or null if not registered.
+ */
+export declare function getSourceInfo(key: string): PollingSourceInfo | null;
+/**
+ * Get a full snapshot of the global polling state.
+ */
+export declare function getPollingState(): PollingStateSnapshot;
+/**
+ * Subscribe to polling state changes. Returns an unsubscribe function.
+ */
+export declare function onPollingStateChange(listener: PollingStateChangeHandler): () => void;
+/**
+ * Get the number of registered polling sources.
+ */
+export declare function getSourceCount(): number;
+/**
+ * Validate that a generation value is still current.
+ *
+ * Returns `true` if the given generation matches the current generation,
+ * meaning no suspend/resume/dispose cycle has occurred since the value
+ * was captured. Useful for guarding against stale restarts in async code:
+ *
+ * ```ts
+ * const gen = getGeneration();
+ * await fetchData();
+ * if (!isGenerationCurrent(gen)) return; // stale — bail out
+ * ```
+ */
+export declare function isGenerationCurrent(gen: number): boolean;
+/**
+ * Reset all module state (for testing). Disposes all sources, clears
+ * listeners, and resets the generation counter.
+ */
+export declare function resetPollingState(): void;

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

@@ -0,0 +1,306 @@
+/**
+ * Centralized polling state manager.
+ *
+ * Provides a single registry for all interval-based polling sources in the
+ * application (polling-manager, memory-monitor, DOM performance monitor,
+ * tick timer, etc.). Enables coordinated suspension, resumption, and
+ * disposal of all polling sources from one location.
+ *
+ * Problems this solves:
+ *
+ *   1. **Orphaned intervals** — Without a central registry, independent
+ *      modules that manage their own `setInterval` can leak timers if
+ *      their stop functions are never called.
+ *
+ *   2. **No single "stop everything"** — Previously, shutting down all
+ *      polling required calling individual stop functions across 4+
+ *      modules. Now `disposeAllSources()` handles it.
+ *
+ *   3. **Component remount safety** — Module-level state persists across
+ *      Preact component teardown/remount cycles. Generation IDs prevent
+ *      stale callbacks from restarting disposed sources.
+ *
+ *   4. **Memory-pressure coordination** — Sources can be tagged as
+ *      `essential` (e.g. memory-monitor must keep running to detect
+ *      recovery) or non-essential (suspended during memory pressure).
+ *
+ * Generation tracking:
+ *
+ *   Each `suspendAllSources()` / `resumeAllSources()` cycle increments a
+ *   generation counter. Callers can snapshot the generation before an
+ *   async operation and compare afterward to detect whether a
+ *   suspend/resume cycle occurred while they were waiting — preventing
+ *   stale restarts from orphaned component lifecycles.
+ *
+ * Designed as a standalone module with zero framework dependencies.
+ */
+// ─── Module state ────────────────────────────────────────────────────────────
+const sources = new Map();
+let globalSuspended = false;
+let generation = 0;
+let listeners = [];
+// ─── Internal helpers ────────────────────────────────────────────────────────
+/** Build a snapshot from current module state. */
+function buildSnapshot() {
+    const infos = [];
+    let activeCount = 0;
+    let suspendedCount = 0;
+    for (const entry of sources.values()) {
+        const status = entry.callbacks.getStatus();
+        infos.push({
+            key: entry.key,
+            status,
+            essential: entry.config.essential,
+            registeredAt: entry.registeredAt,
+        });
+        if (status === "active")
+            activeCount++;
+        if (status === "suspended")
+            suspendedCount++;
+    }
+    return {
+        sources: infos,
+        sourceCount: sources.size,
+        activeCount,
+        suspendedCount,
+        globalSuspended,
+        generation,
+    };
+}
+function notifyListeners() {
+    const snapshot = buildSnapshot();
+    for (const listener of listeners) {
+        try {
+            listener(snapshot);
+        }
+        catch (err) {
+            console.warn("[polling-state] listener error:", err);
+        }
+    }
+}
+// ─── Public API ──────────────────────────────────────────────────────────────
+/**
+ * Register a polling source with the centralized state manager.
+ *
+ * If a source with the same key already exists, it is disposed and replaced.
+ * If global suspension is active and the source is not essential, it will
+ * be immediately suspended after registration.
+ *
+ * Returns an unregister function that removes the source from the registry
+ * WITHOUT calling dispose. This allows sources to voluntarily unregister
+ * (e.g. during their own stop/shutdown) without triggering re-entrant
+ * dispose calls. The `dispose` callback is only invoked by
+ * `disposeAllSources()` or when the source is replaced by a new
+ * registration with the same key.
+ *
+ * @param key - Unique identifier for this source.
+ * @param callbacks - Lifecycle callbacks (suspend, resume, dispose, getStatus).
+ * @param config - Source configuration (essential flag).
+ */
+export function registerPollingSource(key, callbacks, config = {}) {
+    // Dispose existing source with the same key (prevents orphaned intervals).
+    const existing = sources.get(key);
+    if (existing) {
+        try {
+            existing.callbacks.dispose();
+        }
+        catch (err) {
+            console.warn(`[polling-state] failed to dispose replaced source "${key}":`, err);
+        }
+    }
+    const entry = {
+        key,
+        callbacks,
+        config: {
+            essential: config.essential ?? false,
+        },
+        registeredAt: new Date().toISOString(),
+    };
+    sources.set(key, entry);
+    // If global suspension is active and this source is not essential,
+    // suspend it immediately to maintain consistent state.
+    if (globalSuspended && !entry.config.essential) {
+        try {
+            callbacks.suspend();
+        }
+        catch (err) {
+            console.warn(`[polling-state] failed to suspend new source "${key}":`, err);
+        }
+    }
+    notifyListeners();
+    return () => unregisterPollingSource(key);
+}
+/**
+ * Remove a polling source from the registry WITHOUT calling dispose.
+ *
+ * Use this when the source is cleaning itself up voluntarily (e.g. a
+ * module's own stop function). The source is responsible for its own
+ * resource cleanup in this case. For forced cleanup, use
+ * `disposeAllSources()`.
+ */
+export function unregisterPollingSource(key) {
+    if (!sources.has(key))
+        return;
+    sources.delete(key);
+    notifyListeners();
+}
+/**
+ * Suspend all non-essential polling sources.
+ *
+ * Essential sources (e.g. memory-monitor) continue running so they can
+ * detect when conditions improve. Increments the generation counter.
+ */
+export function suspendAllSources() {
+    if (globalSuspended)
+        return;
+    globalSuspended = true;
+    generation++;
+    for (const entry of sources.values()) {
+        if (entry.config.essential)
+            continue;
+        try {
+            entry.callbacks.suspend();
+        }
+        catch (err) {
+            console.warn(`[polling-state] failed to suspend source "${entry.key}":`, err);
+        }
+    }
+    notifyListeners();
+}
+/**
+ * Resume all suspended polling sources.
+ *
+ * Restarts non-essential sources that were suspended. Essential sources
+ * that were already running are unaffected. Increments the generation counter.
+ */
+export function resumeAllSources() {
+    if (!globalSuspended)
+        return;
+    globalSuspended = false;
+    generation++;
+    for (const entry of sources.values()) {
+        if (entry.config.essential)
+            continue;
+        try {
+            entry.callbacks.resume();
+        }
+        catch (err) {
+            console.warn(`[polling-state] failed to resume source "${entry.key}":`, err);
+        }
+    }
+    notifyListeners();
+}
+/**
+ * Dispose all registered polling sources and clear the registry.
+ *
+ * After this call, all intervals are stopped and all sources are removed.
+ * The generation counter is incremented. New sources can still be registered.
+ */
+export function disposeAllSources() {
+    generation++;
+    for (const entry of sources.values()) {
+        try {
+            entry.callbacks.dispose();
+        }
+        catch (err) {
+            console.warn(`[polling-state] failed to dispose source "${entry.key}":`, err);
+        }
+    }
+    sources.clear();
+    globalSuspended = false;
+    notifyListeners();
+}
+/**
+ * Check if global suspension is active.
+ */
+export function isGlobalSuspended() {
+    return globalSuspended;
+}
+/**
+ * Get the current generation counter.
+ *
+ * The generation increments on every suspend/resume/dispose cycle.
+ * Callers can snapshot this value before an async operation and compare
+ * afterward to detect whether a lifecycle change occurred.
+ */
+export function getGeneration() {
+    return generation;
+}
+/**
+ * Check if a specific source is registered.
+ */
+export function isSourceRegistered(key) {
+    return sources.has(key);
+}
+/**
+ * Get read-only information about a specific source, or null if not registered.
+ */
+export function getSourceInfo(key) {
+    const entry = sources.get(key);
+    if (!entry)
+        return null;
+    return {
+        key: entry.key,
+        status: entry.callbacks.getStatus(),
+        essential: entry.config.essential,
+        registeredAt: entry.registeredAt,
+    };
+}
+/**
+ * Get a full snapshot of the global polling state.
+ */
+export function getPollingState() {
+    return buildSnapshot();
+}
+/**
+ * Subscribe to polling state changes. Returns an unsubscribe function.
+ */
+export function onPollingStateChange(listener) {
+    listeners.push(listener);
+    return () => {
+        listeners = listeners.filter((l) => l !== listener);
+    };
+}
+/**
+ * Get the number of registered polling sources.
+ */
+export function getSourceCount() {
+    return sources.size;
+}
+/**
+ * Validate that a generation value is still current.
+ *
+ * Returns `true` if the given generation matches the current generation,
+ * meaning no suspend/resume/dispose cycle has occurred since the value
+ * was captured. Useful for guarding against stale restarts in async code:
+ *
+ * ```ts
+ * const gen = getGeneration();
+ * await fetchData();
+ * if (!isGenerationCurrent(gen)) return; // stale — bail out
+ * ```
+ */
+export function isGenerationCurrent(gen) {
+    return gen === generation;
+}
+/**
+ * Reset all module state (for testing). Disposes all sources, clears
+ * listeners, and resets the generation counter.
+ */
+export function resetPollingState() {
+    // Dispose all sources without incrementing generation
+    // (reset is a testing utility, not a lifecycle event).
+    for (const entry of sources.values()) {
+        try {
+            entry.callbacks.dispose();
+        }
+        catch (err) {
+            console.warn(`[polling-state] failed to dispose source "${entry.key}" during reset:`, err);
+        }
+    }
+    sources.clear();
+    globalSuspended = false;
+    generation = 0;
+    listeners = [];
+}
+//# sourceMappingURL=polling-state.js.map

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

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