@scalebun-release/web 2.2.2

package/dist/features/watchdog/collectors.js

@@ -0,0 +1,107 @@
+/**
+ * W5.2 — Resource-Watchdog collectors (LAZY chunk; browser APIs only, zero third-party).
+ *
+ * Tier 0 (universal): event-loop-lag heartbeat — visibility-gated so background-tab timer throttling
+ * never masquerades as jank (research caveat). Tier 1 (Chromium): Compute Pressure + performance.memory.
+ * FPS + LoAF are NOT collected here — the watchdog taps PerformanceFeature's existing observer
+ * (jankTap) rather than opening a second one. Every collector is feature-detected and fail-soft.
+ */
+import { now } from '../../core/index.js';
+function isVisible() {
+    try {
+        return typeof document === 'undefined' || document.visibilityState !== 'hidden';
+    }
+    catch {
+        return true;
+    }
+}
+export function startCollectors(sinks, opts) {
+    const cleanups = [];
+    // ── Tier 0: event-loop-lag heartbeat (visibility-gated) ───────────────────────
+    let last = now();
+    let hbTimer;
+    const tick = () => {
+        const t = now();
+        const drift = t - last - opts.heartbeatMs; // extra time beyond the scheduled interval = lag
+        last = t;
+        if (drift >= 0)
+            sinks.onHeartbeat(drift);
+        hbTimer = setTimeout(tick, opts.heartbeatMs);
+    };
+    const startHb = () => {
+        last = now(); // fresh baseline — never measure across a paused/hidden span
+        hbTimer = setTimeout(tick, opts.heartbeatMs);
+    };
+    const stopHb = () => {
+        if (hbTimer)
+            clearTimeout(hbTimer);
+        hbTimer = undefined;
+    };
+    const onVis = () => {
+        if (!isVisible())
+            stopHb();
+        else if (!hbTimer)
+            startHb();
+    };
+    if (typeof document !== 'undefined') {
+        document.addEventListener('visibilitychange', onVis);
+        cleanups.push(() => document.removeEventListener('visibilitychange', onVis));
+    }
+    if (isVisible())
+        startHb();
+    cleanups.push(stopHb);
+    // ── Tier 1: Compute Pressure (Chromium) ───────────────────────────────────────
+    let pressureAvailable = false;
+    try {
+        const PO = globalThis.PressureObserver;
+        if (typeof PO === 'function') {
+            pressureAvailable = true;
+            const po = new PO((records) => {
+                const rec = records[records.length - 1];
+                if (rec?.state)
+                    sinks.onPressure(rec.state);
+            });
+            // observe() may reject under a restrictive permissions policy — then pressure simply never
+            // arrives (cpu_spike stays quiet this session); the lag-proxy is not retrofitted mid-flight.
+            po.observe('cpu', { sampleInterval: 2000 }).catch(() => { });
+            cleanups.push(() => {
+                try {
+                    po.disconnect();
+                }
+                catch {
+                    /* ignore */
+                }
+            });
+        }
+    }
+    catch {
+        pressureAvailable = false;
+    }
+    // ── Tier 1: heap trend (Chromium performance.memory) ──────────────────────────
+    const memoryAvailable = typeof performance !== 'undefined' && typeof performance.memory?.usedJSHeapSize === 'number';
+    if (memoryAvailable) {
+        const sampleMem = () => {
+            const m = performance.memory;
+            if (m && typeof m.usedJSHeapSize === 'number')
+                sinks.onMemory(m.usedJSHeapSize, m.jsHeapSizeLimit ?? 0);
+        };
+        sampleMem(); // seed immediately so slope/leak windows start filling
+        const memTimer = setInterval(sampleMem, opts.memorySampleMs);
+        cleanups.push(() => clearInterval(memTimer));
+    }
+    return {
+        stop: () => {
+            for (const c of cleanups) {
+                try {
+                    c();
+                }
+                catch {
+                    /* ignore */
+                }
+            }
+        },
+        pressureAvailable,
+        memoryAvailable,
+    };
+}
+//# sourceMappingURL=collectors.js.map

package/dist/features/watchdog/collectors.js.map

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

package/dist/features/watchdog/config.d.ts

@@ -0,0 +1,51 @@
+/**
+ * W5.2 — Resource Watchdog thresholds + options.
+ *
+ * These are WEB defaults, NOT mobile's: mobile's ProfilerIncidentThresholds were calibrated against a
+ * ~2 s native RSS sample cadence; web samples heap every 20–30 s through quantized `performance.memory`
+ * and reads CPU load as coarse Compute-Pressure states. Every value here is a starting point to be
+ * calibrated during dogfood — the `thresholds` init option exists so this needs no SDK release to tune.
+ */
+export interface WatchdogThresholds {
+    /** cpu_spike (Chromium): dwell time in `critical` compute-pressure before it's an incident. */
+    pressureSustainMs: number;
+    /** cpu_spike (universal fallback): event-loop-lag p95 over the trailing ring that counts as a spike. */
+    lagP95Ms: number;
+    /** main_thread_stall: a single heartbeat gap at/above this is a stall. */
+    mainThreadStallMs: number;
+    /** jank_burst: N LoAF/longtask readings within `jankWindowMs`. */
+    jankBurstCount: number;
+    jankWindowMs: number;
+    /** frozen_frame: a LoAF/task whose frame duration is at/above this. */
+    frozenFrameMs: number;
+    /** memory_surge: heap growth rate (bytes/sec) sustained for 2 consecutive trend intervals. */
+    memSurgeBytesPerSec: number;
+    /** memory_leak_suspicion: monotonic growth across this many trend samples AND ≥ leakMinBytes total. */
+    leakSamples: number;
+    leakMinBytes: number;
+    /** low_memory_pressure: usedJSHeapSize / jsHeapSizeLimit at/above this. */
+    heapUsedRatio: number;
+    /** Per-incident-type cooldown (fixes mobile's single global cooldown shadowing all types). */
+    cooldownMs: number;
+}
+export declare const DEFAULT_THRESHOLDS: WatchdogThresholds;
+export interface WatchdogOptions {
+    /** Per-session deterministic keep rate (fnv1a32 over sessionId). Default 1 (all sessions). */
+    sampleRate?: number;
+    /** Event-loop-lag heartbeat cadence. Default 1000 ms, floored at 250. */
+    heartbeatMs?: number;
+    /** Health-rollup window — one `resource_health` item per window. Default 30 000 ms. */
+    rollupMs?: number;
+    /** performance.memory / measureUserAgentSpecificMemory sample cadence. Default 20 000 ms. */
+    memorySampleMs?: number;
+    /** Threshold overrides (merged over DEFAULT_THRESHOLDS). */
+    thresholds?: Partial<WatchdogThresholds>;
+    /** 5.3 — capture a JS Self-Profiling window when an incident fires (no-op until the header is set
+     *  and phase 5.3 lands). Accepted now so config is forward-compatible. Default true. */
+    captureProfileOnIncident?: boolean;
+}
+/** Global incident rate cap (a session-wide backstop above the per-type cooldowns). */
+export declare const RATE_WINDOW_MS: number;
+export declare const RATE_MAX = 10;
+export declare function resolveThresholds(o?: Partial<WatchdogThresholds>): WatchdogThresholds;
+//# sourceMappingURL=config.d.ts.map

package/dist/features/watchdog/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/features/watchdog/config.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,WAAW,kBAAkB;IACjC,+FAA+F;IAC/F,iBAAiB,EAAE,MAAM,CAAC;IAC1B,wGAAwG;IACxG,QAAQ,EAAE,MAAM,CAAC;IACjB,0EAA0E;IAC1E,iBAAiB,EAAE,MAAM,CAAC;IAC1B,kEAAkE;IAClE,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;IACrB,uEAAuE;IACvE,aAAa,EAAE,MAAM,CAAC;IACtB,8FAA8F;IAC9F,mBAAmB,EAAE,MAAM,CAAC;IAC5B,uGAAuG;IACvG,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,2EAA2E;IAC3E,aAAa,EAAE,MAAM,CAAC;IACtB,8FAA8F;IAC9F,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,eAAO,MAAM,kBAAkB,EAAE,kBAYhC,CAAC;AAEF,MAAM,WAAW,eAAe;IAC9B,8FAA8F;IAC9F,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,yEAAyE;IACzE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,uFAAuF;IACvF,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,6FAA6F;IAC7F,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,4DAA4D;IAC5D,UAAU,CAAC,EAAE,OAAO,CAAC,kBAAkB,CAAC,CAAC;IACzC;4FACwF;IACxF,wBAAwB,CAAC,EAAE,OAAO,CAAC;CACpC;AAED,uFAAuF;AACvF,eAAO,MAAM,cAAc,QAAc,CAAC;AAC1C,eAAO,MAAM,QAAQ,KAAK,CAAC;AAE3B,wBAAgB,iBAAiB,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,kBAAkB,CAAC,GAAG,kBAAkB,CAErF"}

package/dist/features/watchdog/config.js

@@ -0,0 +1,28 @@
+/**
+ * W5.2 — Resource Watchdog thresholds + options.
+ *
+ * These are WEB defaults, NOT mobile's: mobile's ProfilerIncidentThresholds were calibrated against a
+ * ~2 s native RSS sample cadence; web samples heap every 20–30 s through quantized `performance.memory`
+ * and reads CPU load as coarse Compute-Pressure states. Every value here is a starting point to be
+ * calibrated during dogfood — the `thresholds` init option exists so this needs no SDK release to tune.
+ */
+export const DEFAULT_THRESHOLDS = {
+    pressureSustainMs: 6000,
+    lagP95Ms: 500,
+    mainThreadStallMs: 500,
+    jankBurstCount: 5,
+    jankWindowMs: 10000,
+    frozenFrameMs: 700,
+    memSurgeBytesPerSec: 6 * 1024 * 1024, // 6 MiB/s — web starting point (dogfood-calibrated)
+    leakSamples: 10, // ≈ 5 min at a 30 s memory cadence
+    leakMinBytes: 50 * 1024 * 1024, // 50 MiB cumulative growth
+    heapUsedRatio: 0.9,
+    cooldownMs: 60000,
+};
+/** Global incident rate cap (a session-wide backstop above the per-type cooldowns). */
+export const RATE_WINDOW_MS = 10 * 60000; // 10 min
+export const RATE_MAX = 10;
+export function resolveThresholds(o) {
+    return o ? { ...DEFAULT_THRESHOLDS, ...o } : DEFAULT_THRESHOLDS;
+}
+//# sourceMappingURL=config.js.map

package/dist/features/watchdog/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../../../src/features/watchdog/config.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAyBH,MAAM,CAAC,MAAM,kBAAkB,GAAuB;IACpD,iBAAiB,EAAE,IAAK;IACxB,QAAQ,EAAE,GAAG;IACb,iBAAiB,EAAE,GAAG;IACtB,cAAc,EAAE,CAAC;IACjB,YAAY,EAAE,KAAM;IACpB,aAAa,EAAE,GAAG;IAClB,mBAAmB,EAAE,CAAC,GAAG,IAAI,GAAG,IAAI,EAAE,oDAAoD;IAC1F,WAAW,EAAE,EAAE,EAAE,mCAAmC;IACpD,YAAY,EAAE,EAAE,GAAG,IAAI,GAAG,IAAI,EAAE,2BAA2B;IAC3D,aAAa,EAAE,GAAG;IAClB,UAAU,EAAE,KAAM;CACnB,CAAC;AAkBF,uFAAuF;AACvF,MAAM,CAAC,MAAM,cAAc,GAAG,EAAE,GAAG,KAAM,CAAC,CAAC,SAAS;AACpD,MAAM,CAAC,MAAM,QAAQ,GAAG,EAAE,CAAC;AAE3B,MAAM,UAAU,iBAAiB,CAAC,CAA+B;IAC/D,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,kBAAkB,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,kBAAkB,CAAC;AAClE,CAAC"}

package/dist/features/watchdog/engine.d.ts

@@ -0,0 +1,22 @@
+/**
+ * W5.2 — Resource-Watchdog orchestrator (LAZY chunk). Owns everything but the feature-detect+import:
+ * the per-session sampling gate, the browser collectors + shared jank tap wired into the pure
+ * IncidentEngine and the HealthRollup, the perf-item emit, and the `resource_pressure` signal. Kept out
+ * of the eager shell so the core bundle gate holds and nothing here loads for non-watchdog tenants.
+ */
+import type { FeatureContext } from '@scalebun/sdk-contracts';
+export interface WatchdogStats {
+    incidents: number;
+    droppedIncidents: number;
+    rollups: number;
+    tiers: {
+        pressure: boolean;
+        memory: boolean;
+    };
+}
+export interface WatchdogHandle {
+    stop: () => void;
+    stats: () => WatchdogStats;
+}
+export declare function startWatchdog(ctx: FeatureContext): WatchdogHandle;
+//# sourceMappingURL=engine.d.ts.map

package/dist/features/watchdog/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../../src/features/watchdog/engine.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAU9D,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,MAAM,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE;QAAE,QAAQ,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,OAAO,CAAA;KAAE,CAAC;CAC/C;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,IAAI,CAAC;IACjB,KAAK,EAAE,MAAM,aAAa,CAAC;CAC5B;AA4BD,wBAAgB,aAAa,CAAC,GAAG,EAAE,cAAc,GAAG,cAAc,CAgGjE"}

package/dist/features/watchdog/engine.js

@@ -0,0 +1,123 @@
+import { uuid, now, getReplayCoord } from '../../core/index.js';
+import { fnv1a32 } from '../config/bucketing.js';
+import { onJank } from '../performance/jankTap.js';
+import { flameAvailable, captureFlameWindow } from '../profiler/capture.js';
+import { IncidentEngine } from './incidents.js';
+import { HealthRollup } from './rollup.js';
+import { startCollectors } from './collectors.js';
+import { resolveThresholds } from './config.js';
+const NOOP = {
+    stop: () => { },
+    stats: () => ({ incidents: 0, droppedIncidents: 0, rollups: 0, tiers: { pressure: false, memory: false } }),
+};
+/** Deterministic per-session keep (server-reconcilable), matching the perf tail-sampler's fnv1a32 style. */
+function keepSession(sessionId, rate) {
+    const r = rate ?? 1;
+    if (r >= 1)
+        return true;
+    if (r <= 0)
+        return false;
+    return fnv1a32(`${sessionId ?? ''}:wzb-watchdog-v1`) % 100 < r * 100;
+}
+function currentScreen() {
+    try {
+        return typeof location !== 'undefined' ? location.pathname : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+// W5.3 — a flame window per incident is expensive; cap it to at most one per minute even under an
+// incident burst (the per-type cooldowns + rate cap already bound incidents, this bounds profiling).
+const FLAME_WINDOW_MS = 10000;
+const FLAME_COOLDOWN_MS = 60000;
+export function startWatchdog(ctx) {
+    const opts = (ctx.watchdogOptions ?? {});
+    if (!keepSession(ctx.sessionId, opts.sampleRate))
+        return NOOP; // not a sampled session
+    const emit = (metric, value, metadata, clientId) => {
+        const replay = getReplayCoord();
+        ctx.emit({
+            kind: 'performance',
+            metric,
+            value,
+            screenName: currentScreen(),
+            metadata: replay ? { ...metadata, replay } : metadata, // frame-accurate incident→replay deep-link
+            clientId: clientId ?? `wd_${uuid()}`,
+            timestamp: now(),
+        });
+    };
+    // W5.3 — Tier-2 escalation: when an incident fires and the page opted into the js-profiling header,
+    // capture a short flame window and ship it as `js_profile` back-linked to the incident. No-op without
+    // the header — so flame capture happens automatically only where it's available AND at the moment it matters.
+    const captureProfile = opts.captureProfileOnIncident !== false;
+    let capturing = false;
+    let lastFlameAt = 0;
+    const maybeCaptureFlame = (incidentClientId) => {
+        if (!captureProfile || capturing || !flameAvailable())
+            return;
+        const t = now();
+        if (t - lastFlameAt < FLAME_COOLDOWN_MS)
+            return;
+        lastFlameAt = t;
+        capturing = true;
+        void captureFlameWindow(FLAME_WINDOW_MS)
+            .then((res) => {
+            if (res)
+                emit('js_profile', res.samples, { profile: res.profile, format: 'w3c-js-self-profiling', incidentClientId });
+        })
+            .finally(() => {
+            capturing = false;
+        });
+    };
+    const th = resolveThresholds(opts.thresholds);
+    const rollup = new HealthRollup();
+    let incidentCount = 0;
+    let rollups = 0;
+    const pressureAvailable = typeof globalThis.PressureObserver === 'function';
+    const engine = new IncidentEngine({
+        thresholds: th,
+        now,
+        pressureAvailable,
+        onIncident: (inc) => {
+            incidentCount++;
+            rollup.noteIncident();
+            const incidentClientId = `wd_${uuid()}`;
+            emit('resource_incident', inc.value ?? 1, inc, incidentClientId);
+            // Arm replay capture-on-signal + let engage react (e.g. a "having trouble?" survey).
+            ctx.signal('resource_pressure');
+            // Tier-2: grab a flame trace of the live jank, linked back to this incident (header-gated).
+            maybeCaptureFlame(incidentClientId);
+        },
+    });
+    const offJank = onJank((r) => engine.onJank(r)); // JankTapReading is structurally engine.onJank's input
+    const handle = startCollectors({
+        onHeartbeat: (lag) => {
+            engine.onHeartbeat(lag);
+            rollup.onHeartbeat(lag);
+        },
+        onPressure: (s) => {
+            engine.onPressure(s);
+            rollup.onPressure(s);
+        },
+        onMemory: (used, limit) => {
+            engine.onMemory(used, limit);
+            rollup.onMemory(used);
+        },
+    }, { heartbeatMs: Math.max(250, opts.heartbeatMs ?? 1000), memorySampleMs: opts.memorySampleMs ?? 20000 });
+    const tiers = () => ({ pressure: pressureAvailable, memory: handle.memoryAvailable });
+    const rollupTimer = setInterval(() => {
+        rollups++;
+        const snap = rollup.drain(tiers(), engine.dropped);
+        emit('resource_health', snap.lagP95, snap);
+    }, opts.rollupMs ?? 30000);
+    return {
+        stop: () => {
+            clearInterval(rollupTimer);
+            offJank();
+            handle.stop();
+        },
+        stats: () => ({ incidents: incidentCount, droppedIncidents: engine.dropped, rollups, tiers: tiers() }),
+    };
+}
+//# sourceMappingURL=engine.js.map

package/dist/features/watchdog/engine.js.map

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

package/dist/features/watchdog/incidents.d.ts

@@ -0,0 +1,79 @@
+/**
+ * W5.2 — Resource-Watchdog incident engine. PURE: no browser APIs, no timers — it consumes discrete
+ * readings pushed by the collectors and a `now()` clock, and calls `onIncident`. That makes the whole
+ * detection matrix exhaustively unit-testable with a synthetic clock (mobile's native detector, which
+ * can't run in CI, is the cautionary tale this design fixes).
+ *
+ * It ports mobile's incident heuristics with mobile's four reference bugs FIXED — windowed jank
+ * (not a cumulative counter), per-type cooldowns (not one global cooldown that shadows other types),
+ * a real dwell model for compute-pressure (which is edge-triggered, not sampled), — and implements
+ * `main_thread_stall` + `memory_leak_suspicion`, which mobile declares but never built.
+ */
+import type { WatchdogThresholds } from './config.js';
+export type Severity = 'info' | 'warning' | 'critical';
+export type Confidence = 'low' | 'medium' | 'high';
+export type IncidentType = 'cpu_spike' | 'main_thread_stall' | 'jank_burst' | 'frozen_frame' | 'memory_surge' | 'memory_leak_suspicion' | 'low_memory_pressure';
+export type PressureState = 'nominal' | 'fair' | 'serious' | 'critical';
+export interface JankReading {
+    metric: 'loaf' | 'longtask';
+    blockingMs: number;
+    frameDurationMs: number;
+    script?: {
+        url?: string;
+        invoker?: string;
+        fn?: string;
+    };
+}
+export interface Incident {
+    type: IncidentType;
+    severity: Severity;
+    confidence: Confidence;
+    startTs: number;
+    likelyCause: string;
+    description: string;
+    /** Provenance of the signal — the dashboard grades cross-browser claims honestly with this. */
+    tier: 'pressure' | 'lag-proxy' | 'loaf' | 'longtask' | 'memory';
+    value?: number;
+    script?: {
+        url?: string;
+        invoker?: string;
+        fn?: string;
+    };
+}
+export interface IncidentEngineDeps {
+    thresholds: WatchdogThresholds;
+    now: () => number;
+    /** Whether Compute Pressure is available — decides the cpu_spike model (dwell vs lag-proxy). */
+    pressureAvailable: boolean;
+    onIncident: (i: Incident) => void;
+}
+export declare class IncidentEngine {
+    private readonly th;
+    private readonly deps;
+    private lag;
+    private static readonly LAG_RING;
+    private pressure;
+    private pressureSince;
+    private jankAt;
+    private prevMem?;
+    private highSlopeStreak;
+    private memTrend;
+    private lastEmit;
+    private emitTimes;
+    private droppedCount;
+    constructor(deps: IncidentEngineDeps);
+    /** Dropped-by-rate-cap counter (surfaced on the health rollup — "no silent caps"). */
+    get dropped(): number;
+    /** One event-loop-lag heartbeat (ms of drift). Also serves as the periodic evaluate tick for the
+     *  time-based conditions (pressure dwell) so the engine needs no timer of its own. */
+    onHeartbeat(lagMs: number): void;
+    /** Compute-pressure state change (edge-triggered — fires only on transitions). */
+    onPressure(state: PressureState): void;
+    /** A LoAF / long-task reading (from the shared jank tap). */
+    onJank(r: JankReading): void;
+    /** A heap sample: used bytes + the heap limit (both from `performance.memory`, quantized). */
+    onMemory(usedBytes: number, limitBytes: number): void;
+    private evaluateCpu;
+    private emit;
+}
+//# sourceMappingURL=incidents.d.ts.map

package/dist/features/watchdog/incidents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"incidents.d.ts","sourceRoot":"","sources":["../../../src/features/watchdog/incidents.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAGnD,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,SAAS,GAAG,UAAU,CAAC;AACvD,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;AACnD,MAAM,MAAM,YAAY,GACpB,WAAW,GACX,mBAAmB,GACnB,YAAY,GACZ,cAAc,GACd,cAAc,GACd,uBAAuB,GACvB,qBAAqB,CAAC;AAE1B,MAAM,MAAM,aAAa,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,GAAG,UAAU,CAAC;AAExE,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,GAAG,UAAU,CAAC;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,EAAE,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC1D;AAED,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,YAAY,CAAC;IACnB,QAAQ,EAAE,QAAQ,CAAC;IACnB,UAAU,EAAE,UAAU,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,+FAA+F;IAC/F,IAAI,EAAE,UAAU,GAAG,WAAW,GAAG,MAAM,GAAG,UAAU,GAAG,QAAQ,CAAC;IAChE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,EAAE,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC1D;AAED,MAAM,WAAW,kBAAkB;IACjC,UAAU,EAAE,kBAAkB,CAAC;IAC/B,GAAG,EAAE,MAAM,MAAM,CAAC;IAClB,gGAAgG;IAChG,iBAAiB,EAAE,OAAO,CAAC;IAC3B,UAAU,EAAE,CAAC,CAAC,EAAE,QAAQ,KAAK,IAAI,CAAC;CACnC;AAQD,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAqB;IACxC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAqB;IAG1C,OAAO,CAAC,GAAG,CAAgB;IAC3B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAM;IAGtC,OAAO,CAAC,QAAQ,CAA4B;IAC5C,OAAO,CAAC,aAAa,CAAK;IAG1B,OAAO,CAAC,MAAM,CAAgB;IAG9B,OAAO,CAAC,OAAO,CAAC,CAA+B;IAC/C,OAAO,CAAC,eAAe,CAAK;IAC5B,OAAO,CAAC,QAAQ,CAAgB;IAGhC,OAAO,CAAC,QAAQ,CAAmC;IACnD,OAAO,CAAC,SAAS,CAAgB;IACjC,OAAO,CAAC,YAAY,CAAK;gBAEb,IAAI,EAAE,kBAAkB;IAKpC,sFAAsF;IACtF,IAAI,OAAO,IAAI,MAAM,CAEpB;IAGD;0FACsF;IACtF,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAmBhC,kFAAkF;IAClF,UAAU,CAAC,KAAK,EAAE,aAAa,GAAG,IAAI;IAOtC,6DAA6D;IAC7D,MAAM,CAAC,CAAC,EAAE,WAAW,GAAG,IAAI;IAmC5B,8FAA8F;IAC9F,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI;IAkErD,OAAO,CAAC,WAAW;IA+BnB,OAAO,CAAC,IAAI;CAYb"}

package/dist/features/watchdog/incidents.js

@@ -0,0 +1,204 @@
+import { RATE_MAX, RATE_WINDOW_MS } from './config.js';
+function p95(sorted) {
+    if (!sorted.length)
+        return 0;
+    const idx = Math.min(sorted.length - 1, Math.floor(sorted.length * 0.95));
+    return sorted[idx];
+}
+export class IncidentEngine {
+    constructor(deps) {
+        // main-thread lag ring (for cpu_spike lag-proxy p95); bounded.
+        this.lag = [];
+        // compute-pressure dwell
+        this.pressure = 'nominal';
+        this.pressureSince = 0;
+        // jank sliding window (timestamps of readings)
+        this.jankAt = [];
+        this.highSlopeStreak = 0;
+        this.memTrend = []; // used-heap samples (for leak monotonicity)
+        // emit gating
+        this.lastEmit = new Map();
+        this.emitTimes = [];
+        this.droppedCount = 0;
+        this.deps = deps;
+        this.th = deps.thresholds;
+    }
+    /** Dropped-by-rate-cap counter (surfaced on the health rollup — "no silent caps"). */
+    get dropped() {
+        return this.droppedCount;
+    }
+    // ── inputs ────────────────────────────────────────────────────────────────────
+    /** One event-loop-lag heartbeat (ms of drift). Also serves as the periodic evaluate tick for the
+     *  time-based conditions (pressure dwell) so the engine needs no timer of its own. */
+    onHeartbeat(lagMs) {
+        this.lag.push(lagMs);
+        if (this.lag.length > IncidentEngine.LAG_RING)
+            this.lag.shift();
+        // main_thread_stall — a single bad tick.
+        if (lagMs >= this.th.mainThreadStallMs) {
+            this.emit({
+                type: 'main_thread_stall',
+                severity: lagMs >= 2000 ? 'critical' : 'warning',
+                confidence: 'high',
+                tier: 'lag-proxy',
+                value: Math.round(lagMs),
+                likelyCause: 'main thread blocked',
+                description: `The main thread was blocked for ${Math.round(lagMs)} ms.`,
+            });
+        }
+        this.evaluateCpu();
+    }
+    /** Compute-pressure state change (edge-triggered — fires only on transitions). */
+    onPressure(state) {
+        if (state === this.pressure)
+            return;
+        this.pressure = state;
+        this.pressureSince = this.deps.now();
+        this.evaluateCpu();
+    }
+    /** A LoAF / long-task reading (from the shared jank tap). */
+    onJank(r) {
+        const t = this.deps.now();
+        // frozen_frame — one very long frame.
+        if (r.frameDurationMs >= this.th.frozenFrameMs) {
+            this.emit({
+                type: 'frozen_frame',
+                severity: r.frameDurationMs >= 2000 ? 'critical' : 'warning',
+                confidence: 'high',
+                tier: r.metric,
+                value: Math.round(r.frameDurationMs),
+                script: r.script,
+                likelyCause: r.script?.url ? `long frame in ${r.script.url}` : 'long animation frame',
+                description: `A single frame took ${Math.round(r.frameDurationMs)} ms.`,
+            });
+        }
+        // jank_burst — N readings within a sliding window (fixes mobile's cumulative counter).
+        this.jankAt.push(t);
+        const cutoff = t - this.th.jankWindowMs;
+        while (this.jankAt.length && this.jankAt[0] < cutoff)
+            this.jankAt.shift();
+        if (this.jankAt.length >= this.th.jankBurstCount) {
+            this.emit({
+                type: 'jank_burst',
+                severity: 'warning',
+                confidence: 'medium',
+                tier: r.metric,
+                value: this.jankAt.length,
+                script: r.script,
+                likelyCause: r.script?.url ? `repeated jank in ${r.script.url}` : 'repeated main-thread jank',
+                description: `${this.jankAt.length} janky frames within ${Math.round(this.th.jankWindowMs / 1000)} s.`,
+            });
+        }
+    }
+    /** A heap sample: used bytes + the heap limit (both from `performance.memory`, quantized). */
+    onMemory(usedBytes, limitBytes) {
+        const t = this.deps.now();
+        // low_memory_pressure — near the ceiling.
+        if (limitBytes > 0 && usedBytes / limitBytes >= this.th.heapUsedRatio) {
+            this.emit({
+                type: 'low_memory_pressure',
+                severity: 'critical',
+                confidence: 'high',
+                tier: 'memory',
+                value: Math.round((usedBytes / limitBytes) * 100),
+                likelyCause: 'JS heap near its limit',
+                description: `Used heap is ${Math.round((usedBytes / limitBytes) * 100)}% of the limit.`,
+            });
+        }
+        // memory_surge — high growth rate sustained across 2 consecutive intervals (debounces quantization).
+        if (this.prevMem) {
+            const dt = (t - this.prevMem.at) / 1000;
+            const slope = dt > 0 ? (usedBytes - this.prevMem.used) / dt : 0;
+            if (slope > this.th.memSurgeBytesPerSec) {
+                this.highSlopeStreak++;
+                if (this.highSlopeStreak >= 2) {
+                    this.emit({
+                        type: 'memory_surge',
+                        severity: slope > 2 * this.th.memSurgeBytesPerSec ? 'critical' : 'warning',
+                        confidence: 'medium',
+                        tier: 'memory',
+                        value: Math.round(slope),
+                        likelyCause: 'rapid heap allocation',
+                        description: `Heap grew ~${Math.round(slope / (1024 * 1024))} MiB/s.`,
+                    });
+                }
+            }
+            else {
+                this.highSlopeStreak = 0;
+            }
+        }
+        this.prevMem = { used: usedBytes, at: t };
+        // memory_leak_suspicion — monotonic growth across N samples with a meaningful total.
+        this.memTrend.push(usedBytes);
+        if (this.memTrend.length > this.th.leakSamples)
+            this.memTrend.shift();
+        if (this.memTrend.length === this.th.leakSamples) {
+            let monotonic = true;
+            for (let i = 1; i < this.memTrend.length; i++) {
+                if (this.memTrend[i] < this.memTrend[i - 1]) {
+                    monotonic = false;
+                    break;
+                }
+            }
+            const growth = this.memTrend[this.memTrend.length - 1] - this.memTrend[0];
+            if (monotonic && growth >= this.th.leakMinBytes) {
+                this.emit({
+                    type: 'memory_leak_suspicion',
+                    severity: 'warning',
+                    confidence: 'low', // honest — heap growth can be legitimate; "suspicion" not "leak"
+                    tier: 'memory',
+                    value: Math.round(growth),
+                    likelyCause: 'monotonic heap growth',
+                    description: `Heap grew ~${Math.round(growth / (1024 * 1024))} MiB over ${this.memTrend.length} samples without release.`,
+                });
+            }
+        }
+    }
+    // ── cpu_spike (dwell on Chromium, lag-proxy elsewhere) ──────────────────────────
+    evaluateCpu() {
+        if (this.deps.pressureAvailable) {
+            if (this.pressure === 'critical' && this.deps.now() - this.pressureSince >= this.th.pressureSustainMs) {
+                this.emit({
+                    type: 'cpu_spike',
+                    severity: 'critical',
+                    confidence: 'high',
+                    tier: 'pressure',
+                    likelyCause: 'sustained CPU pressure',
+                    description: `CPU stayed under critical pressure for ${Math.round(this.th.pressureSustainMs / 1000)}s+.`,
+                });
+            }
+            return;
+        }
+        // Universal fallback: lag p95 over the trailing ring (need a few samples to be meaningful).
+        if (this.lag.length < 6)
+            return;
+        const val = p95([...this.lag].sort((a, b) => a - b));
+        if (val > this.th.lagP95Ms) {
+            this.emit({
+                type: 'cpu_spike',
+                severity: val > 2 * this.th.lagP95Ms ? 'critical' : 'warning',
+                confidence: 'medium',
+                tier: 'lag-proxy',
+                value: Math.round(val),
+                likelyCause: 'sustained event-loop lag',
+                description: `Event-loop lag p95 was ${Math.round(val)} ms.`,
+            });
+        }
+    }
+    // ── emit gating (per-type cooldown + global rate cap) ───────────────────────────
+    emit(base) {
+        const t = this.deps.now();
+        if (t - (this.lastEmit.get(base.type) ?? -Infinity) < this.th.cooldownMs)
+            return; // per-type cooldown
+        this.emitTimes = this.emitTimes.filter((x) => t - x < RATE_WINDOW_MS);
+        if (this.emitTimes.length >= RATE_MAX) {
+            this.droppedCount++; // global backstop — surfaced on the rollup, never silent
+            return;
+        }
+        this.lastEmit.set(base.type, t);
+        this.emitTimes.push(t);
+        this.deps.onIncident({ ...base, startTs: t });
+    }
+}
+IncidentEngine.LAG_RING = 32;
+//# sourceMappingURL=incidents.js.map