@scalebun/web 1.0.0

package/dist/features/session/sessionStore.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Persisted web session identity.
+ *
+ * THE BUG THIS FIXES
+ * `SessionManager` minted `sess_${uuid()}` in its constructor and stored it nowhere, so EVERY
+ * document load started a new session. A refresh, a hard navigation, or opening the same app in a
+ * second tab each produced a separate "visit" — session replay showed a user's single journey as a
+ * pile of disconnected 10-second sessions, and every session-scoped metric (duration, events per
+ * session, rage-click grouping) was measured against the wrong denominator.
+ *
+ * WHAT A SESSION IS NOW
+ * One session continues across refreshes and navigations within a browsing context, and ends when
+ * that context goes away (the tab or browser is closed), after a period of inactivity (default 30
+ * minutes), or once it hits an absolute cap (default 24 hours, so a tab left open for days cannot
+ * produce an infinite session).
+ *
+ * WHY sessionStorage AND NOT localStorage
+ * This first shipped on localStorage, following the GA/analytics definition of a session: storage
+ * that outlives the browsing context, expired purely by a 30-minute idle timer. That is correct for
+ * analytics and WRONG here — it meant closing the site and returning a minute later resumed the old
+ * session, because "closed the browser" is not an end signal in that model. For session REPLAY a
+ * visit ends when the visit ends.
+ *
+ * sessionStorage is scoped to the browsing context: it survives refreshes and same-tab navigations
+ * (the actual bug this file exists to fix) and is dropped when the tab closes. The idle timeout is
+ * kept on top of it so a tab left open overnight still rolls over.
+ *
+ * The tradeoff, stated plainly: sessionStorage is per-TAB, so opening a link in a new tab starts a
+ * new session. For replay that is arguably the better shape anyway — frames are per-document, and
+ * two tabs sharing one session means two writers interleaving into a single `seq` space (see below).
+ * Caveat: browsers that restore tabs after a crash also restore sessionStorage, so crash → "restore
+ * tabs" can resume; crash → reopening manually starts fresh.
+ *
+ * THE SEQUENCE COUNTER LIVES HERE TOO, DELIBERATELY
+ * Replay frames carry a per-session `seq`, and the backend both orders frames by it
+ * (`orderBy: { sequenceNumber: 'asc' }`) and resolves a keyframe's deltas as the frames in
+ * `[seq, nextSeq)`. The recorder's counter is per-INSTANCE and restarts at 0 on every page load, so
+ * resuming a session without also resuming the counter would emit a second frame 0, 1, 2… that
+ * sorts *before* the first load's later frames and scrambles the replay. Persisting the id without
+ * the counter would have traded a visible bug for a subtler one.
+ */
+/** Inactivity that ends a session. 30 min is the de-facto standard (GA, and most RUM tools). */
+export declare const DEFAULT_SESSION_TIMEOUT_MS: number;
+/**
+ * Hard cap so a tab left open for days does not report one endless session.
+ *
+ * 4 HOURS, lowered from 24. A 24-hour cap describes a DEVICE, not a visit: measured on live Joint
+ * Clinic data, clinic workstations left open across a shift produced single sessions of 100, 98 and 79
+ * minutes, and the cap was the only thing bounding them. Four hours is longer than any genuine sitting
+ * while still splitting a shift into a handful of sessions instead of one.
+ *
+ * ⚠️ This moves SESSION COUNTS, and therefore every per-session metric (sessions/day, per-session
+ * averages, conversion-per-session). It is a deliberate product change, not a refactor — hosts who
+ * want the old behaviour set `sessionMaxDurationMs: 86_400_000`.
+ */
+export declare const DEFAULT_SESSION_MAX_MS: number;
+export interface SessionRecord {
+    id: string;
+    /** When this session began — drives the absolute cap. */
+    startedAt: number;
+    /** Last activity we observed — drives the inactivity timeout. */
+    lastSeenAt: number;
+    /** Next replay frame sequence number for this session. */
+    seq: number;
+}
+/**
+ * Resume the stored session when it is still live, otherwise start a fresh one.
+ *
+ * Clock note: `lastSeenAt` is wall-clock, so a large system-clock change can expire a session early
+ * or hold one open. Expiring early is the safe direction, and a negative delta (clock moved
+ * backwards) is treated as "no time passed" rather than as a huge idle gap.
+ */
+export declare function resolveSession(timeoutMs?: number, maxMs?: number): SessionRecord;
+/** Test seam — drop the in-memory copy so a case can simulate a fresh document. */
+export declare function __resetLiveSessionForTests(): void;
+/**
+ * Mark activity so the inactivity window slides forward.
+ *
+ * Called on the per-envelope path, so it is THROTTLED: without this a busy page would do a
+ * JSON parse + sessionStorage write per event, and sessionStorage is synchronous — that is main-thread
+ * work on the hot path. Once a minute is far finer than the 30-minute window it feeds.
+ */
+export declare function touchSession(): void;
+/**
+ * Reserve `count` sequence numbers and return the first.
+ *
+ * Read-modify-write against storage rather than a purely in-memory counter, so the counter SURVIVES
+ * a refresh: a resumed session must keep numbering upward instead of restarting at 0 and sorting its
+ * new frames before the old ones.
+ *
+ * Since the move to sessionStorage the store is per-tab, so the cross-tab contention this used to
+ * guard against cannot arise — two tabs now hold two different sessions, each with its own counter.
+ */
+export declare function reserveSeq(count?: number): number;
+/**
+ * Raise the next-sequence floor, returning it.
+ *
+ * Crash recovery replays a pre-roll buffer whose frames ALREADY consumed sequence numbers, but those
+ * frames were written by a previous document and the store knows nothing about them. Without this the
+ * counter would hand the same numbers out again and the recovered frames would collide with the new
+ * session's — the exact ordering corruption the persisted counter exists to prevent.
+ */
+export declare function ensureSeqAtLeast(next: number): number;
+/** Ends the current session; the next resolve() mints a new id. Used by `reset()` / logout. */
+export declare function clearSession(): void;
+//# sourceMappingURL=sessionStore.d.ts.map

package/dist/features/session/sessionStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessionStore.d.ts","sourceRoot":"","sources":["../../../src/features/session/sessionStore.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAMH,gGAAgG;AAChG,eAAO,MAAM,0BAA0B,QAAiB,CAAC;AACzD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,sBAAsB,QAAqB,CAAC;AAEzD,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,yDAAyD;IACzD,SAAS,EAAE,MAAM,CAAC;IAClB,iEAAiE;IACjE,UAAU,EAAE,MAAM,CAAC;IACnB,0DAA0D;IAC1D,GAAG,EAAE,MAAM,CAAC;CACb;AAwDD;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,SAAS,GAAE,MAAmC,EAC9C,KAAK,GAAE,MAA+B,GACrC,aAAa,CAgBf;AAoBD,mFAAmF;AACnF,wBAAgB,0BAA0B,IAAI,IAAI,CAEjD;AAMD;;;;;;GAMG;AACH,wBAAgB,YAAY,IAAI,IAAI,CAgDnC;AAED;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,KAAK,SAAI,GAAG,MAAM,CAe5C;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAWrD;AAED,+FAA+F;AAC/F,wBAAgB,YAAY,IAAI,IAAI,CAMnC"}

package/dist/features/session/sessionStore.js

@@ -0,0 +1,265 @@
+/**
+ * Persisted web session identity.
+ *
+ * THE BUG THIS FIXES
+ * `SessionManager` minted `sess_${uuid()}` in its constructor and stored it nowhere, so EVERY
+ * document load started a new session. A refresh, a hard navigation, or opening the same app in a
+ * second tab each produced a separate "visit" — session replay showed a user's single journey as a
+ * pile of disconnected 10-second sessions, and every session-scoped metric (duration, events per
+ * session, rage-click grouping) was measured against the wrong denominator.
+ *
+ * WHAT A SESSION IS NOW
+ * One session continues across refreshes and navigations within a browsing context, and ends when
+ * that context goes away (the tab or browser is closed), after a period of inactivity (default 30
+ * minutes), or once it hits an absolute cap (default 24 hours, so a tab left open for days cannot
+ * produce an infinite session).
+ *
+ * WHY sessionStorage AND NOT localStorage
+ * This first shipped on localStorage, following the GA/analytics definition of a session: storage
+ * that outlives the browsing context, expired purely by a 30-minute idle timer. That is correct for
+ * analytics and WRONG here — it meant closing the site and returning a minute later resumed the old
+ * session, because "closed the browser" is not an end signal in that model. For session REPLAY a
+ * visit ends when the visit ends.
+ *
+ * sessionStorage is scoped to the browsing context: it survives refreshes and same-tab navigations
+ * (the actual bug this file exists to fix) and is dropped when the tab closes. The idle timeout is
+ * kept on top of it so a tab left open overnight still rolls over.
+ *
+ * The tradeoff, stated plainly: sessionStorage is per-TAB, so opening a link in a new tab starts a
+ * new session. For replay that is arguably the better shape anyway — frames are per-document, and
+ * two tabs sharing one session means two writers interleaving into a single `seq` space (see below).
+ * Caveat: browsers that restore tabs after a crash also restore sessionStorage, so crash → "restore
+ * tabs" can resume; crash → reopening manually starts fresh.
+ *
+ * THE SEQUENCE COUNTER LIVES HERE TOO, DELIBERATELY
+ * Replay frames carry a per-session `seq`, and the backend both orders frames by it
+ * (`orderBy: { sequenceNumber: 'asc' }`) and resolves a keyframe's deltas as the frames in
+ * `[seq, nextSeq)`. The recorder's counter is per-INSTANCE and restarts at 0 on every page load, so
+ * resuming a session without also resuming the counter would emit a second frame 0, 1, 2… that
+ * sorts *before* the first load's later frames and scrambles the replay. Persisting the id without
+ * the counter would have traded a visible bug for a subtler one.
+ */
+import { uuid, now } from '../../core';
+const SESSION_KEY = 'scalebun_session';
+/** Inactivity that ends a session. 30 min is the de-facto standard (GA, and most RUM tools). */
+export const DEFAULT_SESSION_TIMEOUT_MS = 30 * 60 * 1000;
+/**
+ * Hard cap so a tab left open for days does not report one endless session.
+ *
+ * 4 HOURS, lowered from 24. A 24-hour cap describes a DEVICE, not a visit: measured on live Joint
+ * Clinic data, clinic workstations left open across a shift produced single sessions of 100, 98 and 79
+ * minutes, and the cap was the only thing bounding them. Four hours is longer than any genuine sitting
+ * while still splitting a shift into a handful of sessions instead of one.
+ *
+ * ⚠️ This moves SESSION COUNTS, and therefore every per-session metric (sessions/day, per-session
+ * averages, conversion-per-session). It is a deliberate product change, not a refactor — hosts who
+ * want the old behaviour set `sessionMaxDurationMs: 86_400_000`.
+ */
+export const DEFAULT_SESSION_MAX_MS = 4 * 60 * 60 * 1000;
+function read() {
+    try {
+        const raw = typeof sessionStorage !== 'undefined' && sessionStorage.getItem(SESSION_KEY);
+        if (!raw)
+            return null;
+        const a = JSON.parse(raw);
+        // A truncated or hand-edited record must not resurrect a broken session.
+        if (!Array.isArray(a) || typeof a[0] !== 'string' || !a[0] || typeof a[2] !== 'number')
+            return null;
+        /**
+         * `startedAt` gets the SAME scrutiny as `lastSeenAt`, and falls back to `lastSeenAt` — never 0.
+         *
+         * It used to be `+a[1] || 0`, which was validated by nothing. A record whose startedAt did not
+         * parse therefore resolved to epoch 0, and `resolveSession`'s absolute-cap check
+         * (`t - startedAt <= maxMs`) then measured ~56 YEARS and killed the session on the very next load
+         * — silently, and forever, because each replacement was written by the same code path. The visible
+         * symptom is a brand-new session id seconds after a perfectly good one, which is indistinguishable
+         * from "the SDK does not persist sessions at all".
+         *
+         * Falling back to `lastSeenAt` keeps the session alive and merely under-measures its age, which is
+         * the safe direction: the worst case is one session that runs to the idle timeout instead of the
+         * cap, rather than a user's whole visit shattered into fragments.
+         */
+        const started = typeof a[1] === 'number' && isFinite(a[1]) && a[1] > 0 ? a[1] : a[2];
+        return { id: a[0], startedAt: started, lastSeenAt: a[2], seq: a[3] > 0 ? a[3] : 0 };
+    }
+    catch {
+        return null; // storage blocked (private mode / partitioned) or unparsable
+    }
+}
+function write(r) {
+    // Every persist keeps the in-memory copy current, so a restore can never write back a STALER record
+    // than the one in use. Doing this anywhere but here drifts: `reserveSeq` advances the frame counter
+    // far more often than the throttled `touchSession` runs, so a restore that had only seen the load-time
+    // record would reset `seq` to 0 — and frames numbered from 0 sort BEFORE the earlier ones, which is
+    // the exact replay scramble this file's header warns about.
+    live = r;
+    try {
+        if (typeof sessionStorage !== 'undefined') {
+            sessionStorage.setItem(SESSION_KEY, JSON.stringify([r.id, r.startedAt, r.lastSeenAt, r.seq]));
+        }
+    }
+    catch {
+        /* quota or blocked storage → session stays in-memory for this document */
+    }
+}
+/**
+ * Resume the stored session when it is still live, otherwise start a fresh one.
+ *
+ * Clock note: `lastSeenAt` is wall-clock, so a large system-clock change can expire a session early
+ * or hold one open. Expiring early is the safe direction, and a negative delta (clock moved
+ * backwards) is treated as "no time passed" rather than as a huge idle gap.
+ */
+export function resolveSession(timeoutMs = DEFAULT_SESSION_TIMEOUT_MS, maxMs = DEFAULT_SESSION_MAX_MS) {
+    const t = now();
+    const prev = read();
+    // Math.max(0, …) so a backwards clock jump reads as "no time passed" rather than a huge idle gap.
+    if (prev && Math.max(0, t - prev.lastSeenAt) <= timeoutMs && Math.max(0, t - prev.startedAt) <= maxMs) {
+        prev.lastSeenAt = t;
+        write(prev);
+        live = prev;
+        return prev;
+    }
+    const fresh = { id: `sess_${uuid()}`, startedAt: t, lastSeenAt: t, seq: 0 };
+    write(fresh);
+    live = fresh;
+    return fresh;
+}
+/**
+ * The session this document is running, held in memory as well as in storage.
+ *
+ * WHY A SECOND COPY. `sessionStorage` belongs to the page, not to us, and hosts wipe it. Clearing
+ * storage on sign-out is the single most common auth pattern there is — `sessionStorage.clear()` in a
+ * logout handler is meant to drop the app's own auth state and takes `scalebun_session` with it as
+ * collateral. From the SDK's side the session then simply vanishes mid-visit, and the next resolve
+ * mints a new id: one continuous visit is reported as two sessions, which is exactly the "I logged out
+ * in the same tab and got a new session" report. The same thing happens on sign-IN for apps that clear
+ * storage before establishing the new identity.
+ *
+ * This copy lets `touchSession` notice the record has disappeared and put it back, so a host clearing
+ * storage no longer silently splits the visit. It is deliberately NOT a second source of truth: a real
+ * boundary (idle timeout, absolute cap, tab close) still ends the session, because those are decided in
+ * `resolveSession` at load time and this only ever restores the id the document is already using.
+ */
+let live = null;
+/** Test seam — drop the in-memory copy so a case can simulate a fresh document. */
+export function __resetLiveSessionForTests() {
+    live = null;
+}
+let lastTouch = 0;
+/** Sequence counter used when no record can be persisted (see reserveSeq). */
+let memSeq = 0;
+/**
+ * Mark activity so the inactivity window slides forward.
+ *
+ * Called on the per-envelope path, so it is THROTTLED: without this a busy page would do a
+ * JSON parse + sessionStorage write per event, and sessionStorage is synchronous — that is main-thread
+ * work on the hot path. Once a minute is far finer than the 30-minute window it feeds.
+ */
+export function touchSession() {
+    /**
+     * D5 — a HIDDEN document does not slide the inactivity window.
+     *
+     * This runs on the per-envelope path, which means TELEMETRY kept the session alive, not the visitor:
+     * a parked background tab still flushes a queue and refreshes config, so `lastSeenAt` advanced every
+     * minute and the 30-minute timeout was never reached. That is why the only thing bounding a
+     * shift-long tab was the hard cap. Freezing `lastSeenAt` while hidden lets the timeout actually fire,
+     * so returning after 30+ minutes away resolves to a NEW session on the next load.
+     *
+     * A hidden tab playing media is the honest edge case here — it is genuinely doing something, and
+     * this will let its session expire. Treating "hidden" as "not present" is the right default for a
+     * clinic workstation, which is the case that prompted this; a host that needs otherwise can raise
+     * `sessionTimeoutMs`.
+     */
+    if (typeof document !== 'undefined' && document.visibilityState === 'hidden')
+        return;
+    const t = now();
+    /**
+     * Self-heal, checked on EVERY call rather than behind the throttle.
+     *
+     * The throttle exists so a busy page does not do a parse + write per envelope — but the window it
+     * creates is the whole problem here: a host that clears storage in its logout handler usually
+     * navigates or reloads immediately afterwards, well inside 60 seconds, so a throttled restore would
+     * run only after the session had already been lost. This guard is a bare `getItem` with no parse —
+     * the cheapest read available — and it only does work in the case that is actually broken.
+     */
+    if (live) {
+        try {
+            if (typeof sessionStorage !== 'undefined' && sessionStorage.getItem(SESSION_KEY) === null) {
+                live.lastSeenAt = t;
+                write(live);
+                lastTouch = t;
+                return;
+            }
+        }
+        catch {
+            /* storage blocked — nothing to restore into */
+        }
+    }
+    if (t - lastTouch < 60000)
+        return;
+    lastTouch = t;
+    const rec = read();
+    if (!rec)
+        return;
+    rec.lastSeenAt = t;
+    write(rec);
+    live = rec;
+}
+/**
+ * Reserve `count` sequence numbers and return the first.
+ *
+ * Read-modify-write against storage rather than a purely in-memory counter, so the counter SURVIVES
+ * a refresh: a resumed session must keep numbering upward instead of restarting at 0 and sorting its
+ * new frames before the old ones.
+ *
+ * Since the move to sessionStorage the store is per-tab, so the cross-tab contention this used to
+ * guard against cannot arise — two tabs now hold two different sessions, each with its own counter.
+ */
+export function reserveSeq(count = 1) {
+    const rec = read();
+    // No usable record (storage blocked, private mode, or a session that could not be written): fall
+    // back to an in-memory counter. Returning a constant 0 here would stamp EVERY frame as seq 0 and
+    // destroy replay ordering outright — far worse than the per-document counter this replaced.
+    if (!rec) {
+        const s = memSeq;
+        memSeq += count;
+        return s;
+    }
+    const start = rec.seq;
+    rec.seq = start + count;
+    rec.lastSeenAt = now();
+    write(rec);
+    return start;
+}
+/**
+ * Raise the next-sequence floor, returning it.
+ *
+ * Crash recovery replays a pre-roll buffer whose frames ALREADY consumed sequence numbers, but those
+ * frames were written by a previous document and the store knows nothing about them. Without this the
+ * counter would hand the same numbers out again and the recovered frames would collide with the new
+ * session's — the exact ordering corruption the persisted counter exists to prevent.
+ */
+export function ensureSeqAtLeast(next) {
+    const rec = read();
+    if (!rec) {
+        if (memSeq < next)
+            memSeq = next;
+        return memSeq;
+    }
+    if (rec.seq < next) {
+        rec.seq = next;
+        write(rec);
+    }
+    return rec.seq;
+}
+/** Ends the current session; the next resolve() mints a new id. Used by `reset()` / logout. */
+export function clearSession() {
+    try {
+        if (typeof sessionStorage !== 'undefined')
+            sessionStorage.removeItem(SESSION_KEY);
+    }
+    catch {
+        /* nothing we can do */
+    }
+}
+//# sourceMappingURL=sessionStore.js.map

package/dist/features/session/sessionStore.js.map

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

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

@@ -0,0 +1,23 @@
+/**
+ * F-WDOG (W5.2) — Resource Watchdog. Ultra-thin eager shell: feature-detect, then lazy-load the engine
+ * (sampling gate + collectors + incident detector + rollup + emit). A production watchdog — continuous
+ * low-cost resource sampling → local incident detection → only rollups + incidents egress, replay-
+ * correlated on the existing `kind:'performance'` lane (ZERO backend migration). Off by default.
+ *
+ * Distinct from `profiler` (JS Self-Profiling flame capture): mobile's profiler is desktop-only and
+ * never reaches the backend — this watchdog persists incidents. Everything but the detect+import lives
+ * in the lazy chunk to keep the core bundle gate.
+ */
+import type { IFeature, FeatureContext } from '@scalebun/sdk-contracts';
+import type { WatchdogStats } from './engine';
+export declare class WatchdogFeature implements IFeature {
+    readonly name = "watchdog";
+    private active;
+    private handle?;
+    get isActive(): boolean;
+    setup(ctx: FeatureContext): Promise<void>;
+    /** Self-observability (`scalebun.watchdog.stats()`), matching errorStats/perfStats. */
+    stats(): WatchdogStats;
+    teardown(): void;
+}
+//# sourceMappingURL=WatchdogFeature.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"WatchdogFeature.d.ts","sourceRoot":"","sources":["../../../src/features/watchdog/WatchdogFeature.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACxE,OAAO,KAAK,EAAkB,aAAa,EAAE,MAAM,UAAU,CAAC;AAI9D,qBAAa,eAAgB,YAAW,QAAQ;IAC9C,QAAQ,CAAC,IAAI,cAAc;IAC3B,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,MAAM,CAAC,CAAiB;IAEhC,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAEK,KAAK,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAQ/C,uFAAuF;IACvF,KAAK,IAAI,aAAa;IAItB,QAAQ,IAAI,IAAI;CAKjB"}

package/dist/features/watchdog/WatchdogFeature.js

@@ -0,0 +1,29 @@
+const EMPTY_STATS = { incidents: 0, droppedIncidents: 0, rollups: 0, tiers: { pressure: false, memory: false } };
+export class WatchdogFeature {
+    constructor() {
+        this.name = 'watchdog';
+        this.active = false;
+    }
+    get isActive() {
+        return this.active;
+    }
+    async setup(ctx) {
+        if (typeof window === 'undefined' || typeof performance === 'undefined')
+            return;
+        this.active = true;
+        const { startWatchdog } = await import('./engine');
+        if (!this.active)
+            return; // torn down while the chunk loaded
+        this.handle = startWatchdog(ctx);
+    }
+    /** Self-observability (`scalebun.watchdog.stats()`), matching errorStats/perfStats. */
+    stats() {
+        return this.handle?.stats() ?? EMPTY_STATS;
+    }
+    teardown() {
+        this.active = false;
+        this.handle?.stop();
+        this.handle = undefined;
+    }
+}
+//# sourceMappingURL=WatchdogFeature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"WatchdogFeature.js","sourceRoot":"","sources":["../../../src/features/watchdog/WatchdogFeature.ts"],"names":[],"mappings":"AAaA,MAAM,WAAW,GAAkB,EAAE,SAAS,EAAE,CAAC,EAAE,gBAAgB,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;AAEhI,MAAM,OAAO,eAAe;IAA5B;QACW,SAAI,GAAG,UAAU,CAAC;QACnB,WAAM,GAAG,KAAK,CAAC;IAyBzB,CAAC;IAtBC,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAED,KAAK,CAAC,KAAK,CAAC,GAAmB;QAC7B,IAAI,OAAO,MAAM,KAAK,WAAW,IAAI,OAAO,WAAW,KAAK,WAAW;YAAE,OAAO;QAChF,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;QACnB,MAAM,EAAE,aAAa,EAAE,GAAG,MAAM,MAAM,CAAC,UAAU,CAAC,CAAC;QACnD,IAAI,CAAC,IAAI,CAAC,MAAM;YAAE,OAAO,CAAC,mCAAmC;QAC7D,IAAI,CAAC,MAAM,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC;IACnC,CAAC;IAED,uFAAuF;IACvF,KAAK;QACH,OAAO,IAAI,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,WAAW,CAAC;IAC7C,CAAC;IAED,QAAQ;QACN,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;QACpB,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,CAAC;QACpB,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC;IAC1B,CAAC;CACF"}

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

@@ -0,0 +1,18 @@
+import type { PressureState } from './incidents';
+export interface CollectorSinks {
+    onHeartbeat: (lagMs: number) => void;
+    onPressure: (state: PressureState) => void;
+    onMemory: (usedBytes: number, limitBytes: number) => void;
+}
+export interface CollectorHandle {
+    stop: () => void;
+    /** Whether Compute Pressure is present (decides the incident engine's cpu_spike model). */
+    pressureAvailable: boolean;
+    /** Whether performance.memory is present (Chromium) — drives the rollup's honest tier map. */
+    memoryAvailable: boolean;
+}
+export declare function startCollectors(sinks: CollectorSinks, opts: {
+    heartbeatMs: number;
+    memorySampleMs: number;
+}): CollectorHandle;
+//# sourceMappingURL=collectors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"collectors.d.ts","sourceRoot":"","sources":["../../../src/features/watchdog/collectors.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjD,MAAM,WAAW,cAAc;IAC7B,WAAW,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACrC,UAAU,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAC;IAC3C,QAAQ,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,KAAK,IAAI,CAAC;CAC3D;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,IAAI,CAAC;IACjB,2FAA2F;IAC3F,iBAAiB,EAAE,OAAO,CAAC;IAC3B,8FAA8F;IAC9F,eAAe,EAAE,OAAO,CAAC;CAC1B;AAwBD,wBAAgB,eAAe,CAAC,KAAK,EAAE,cAAc,EAAE,IAAI,EAAE;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE,GAAG,eAAe,CAmF7H"}

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';
+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"}