@scalebun-release/web 2.2.2

package/dist/features/replay/lifecycle/deltaBatcher.d.ts

@@ -0,0 +1,31 @@
+/**
+ * DeltaBatcher — the single packaging point for DOM-shaped delta ops (mutations, CSSOM, iframe
+ * mutations). Producers keep their own capture cadence (MutationRecorder serializes per rAF so node
+ * state is read close to the change; CssomRecorder coalesces per microtask) but no longer decide
+ * frame boundaries: they APPEND ops here, and one frame ships per `windowMs` window.
+ *
+ * Why: a frame is the unit of meaningful replay state, not the unit of browser scheduling. Before
+ * this, every rAF with DOM activity produced its own frame — a 60fps DOM animation became 60
+ * frames/sec, and a CSSOM change in the same tick as a DOM change shipped as a second envelope.
+ * Batching here caps the DOM lane at ~1000/windowMs frames/sec while losing NO ops — only the
+ * packaging changes. Ordering is preserved (ops are appended in arrival order and applied in order
+ * by the player), which is also what lets DOM and CSSOM ops share one frame safely.
+ *
+ * `flush()` is synchronous for the moments that need a hard boundary: before a checkpoint snapshot
+ * (pending ops must ship as deltas against the OLD keyframe) and before an immediate interaction
+ * frame (a click on a just-added node must not precede the mutation that adds it).
+ */
+import type { Mutation } from '../engine/types.js';
+export declare class DeltaBatcher {
+    private readonly windowMs;
+    private readonly emit;
+    private pending;
+    private timer;
+    constructor(windowMs: number, emit: (mutations: Mutation[]) => void);
+    append(muts: Mutation[]): void;
+    /** Synchronously package everything pending into one frame (no-op when empty). */
+    flush(): void;
+    /** Flush the tail and stop — captured ops are never dropped on pause/teardown. */
+    dispose(): void;
+}
+//# sourceMappingURL=deltaBatcher.d.ts.map

package/dist/features/replay/lifecycle/deltaBatcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deltaBatcher.d.ts","sourceRoot":"","sources":["../../../../src/features/replay/lifecycle/deltaBatcher.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAEhD,qBAAa,YAAY;IAKrB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,IAAI;IALvB,OAAO,CAAC,OAAO,CAAkB;IACjC,OAAO,CAAC,KAAK,CAA8C;gBAGxC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,CAAC,SAAS,EAAE,QAAQ,EAAE,KAAK,IAAI;IAGxD,MAAM,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,IAAI;IAM9B,kFAAkF;IAClF,KAAK,IAAI,IAAI;IAWb,kFAAkF;IAClF,OAAO,IAAI,IAAI;CAGhB"}

package/dist/features/replay/lifecycle/deltaBatcher.js

@@ -0,0 +1,32 @@
+export class DeltaBatcher {
+    constructor(windowMs, emit) {
+        this.windowMs = windowMs;
+        this.emit = emit;
+        this.pending = [];
+        this.timer = null;
+    }
+    append(muts) {
+        if (!muts.length)
+            return;
+        this.pending.push(...muts);
+        if (this.timer == null)
+            this.timer = setTimeout(() => this.flush(), this.windowMs);
+    }
+    /** Synchronously package everything pending into one frame (no-op when empty). */
+    flush() {
+        if (this.timer != null) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        if (!this.pending.length)
+            return;
+        const batch = this.pending;
+        this.pending = [];
+        this.emit(batch);
+    }
+    /** Flush the tail and stop — captured ops are never dropped on pause/teardown. */
+    dispose() {
+        this.flush();
+    }
+}
+//# sourceMappingURL=deltaBatcher.js.map

package/dist/features/replay/lifecycle/deltaBatcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deltaBatcher.js","sourceRoot":"","sources":["../../../../src/features/replay/lifecycle/deltaBatcher.ts"],"names":[],"mappings":"AAmBA,MAAM,OAAO,YAAY;IAIvB,YACmB,QAAgB,EAChB,IAAqC;QADrC,aAAQ,GAAR,QAAQ,CAAQ;QAChB,SAAI,GAAJ,IAAI,CAAiC;QALhD,YAAO,GAAe,EAAE,CAAC;QACzB,UAAK,GAAyC,IAAI,CAAC;IAKxD,CAAC;IAEJ,MAAM,CAAC,IAAgB;QACrB,IAAI,CAAC,IAAI,CAAC,MAAM;YAAE,OAAO;QACzB,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;QAC3B,IAAI,IAAI,CAAC,KAAK,IAAI,IAAI;YAAE,IAAI,CAAC,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;IACrF,CAAC;IAED,kFAAkF;IAClF,KAAK;QACH,IAAI,IAAI,CAAC,KAAK,IAAI,IAAI,EAAE,CAAC;YACvB,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACzB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;QACpB,CAAC;QACD,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM;YAAE,OAAO;QACjC,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC;QAC3B,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;QAClB,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACnB,CAAC;IAED,kFAAkF;IAClF,OAAO;QACL,IAAI,CAAC,KAAK,EAAE,CAAC;IACf,CAAC;CACF"}

package/dist/features/replay/lifecycle/deviceSignals.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Cost/capability signals for replay egress decisions — all feature-detected + SSR-safe.
+ *
+ * Best-practice: respect the user's Save-Data preference (and slow / ultra-low-memory devices) by NOT
+ * streaming replay live over the network. Capture itself is NOT disabled — the session still records
+ * into the buffered pre-roll and flushes on signal (error/crash), so incident replay is preserved;
+ * only the continuous, bandwidth-heavy live upload is deferred.
+ *
+ * These are the ONLY device signals a browser exposes (battery/thermal are gone or never existed), so
+ * this is the web analog of the native SDK's SyncDecisionEngine.
+ */
+export interface NetworkHint {
+    /** The user turned on data-saver (Save-Data: on) — honor it. */
+    saveData: boolean;
+    /** effectiveType is 2g / slow-2g. */
+    slow: boolean;
+    effectiveType?: string;
+}
+export declare function networkHint(): NetworkHint;
+/**
+ * True when the user is signalling "do not track / do not sell-or-share" via **Global Privacy
+ * Control** (`navigator.globalPrivacyControl === true`) or legacy **Do-Not-Track**
+ * (`navigator.doNotTrack === '1'` / `'yes'`, or `window.doNotTrack === '1'`). Feature-detected +
+ * SSR-safe. Consulted only when the host opts in via `privacy.respectDnt`.
+ */
+export declare function userOptedOutOfTracking(): boolean;
+/** Approximate device RAM in GB (Chromium `navigator.deviceMemory`), or undefined when unsupported. */
+export declare function deviceMemoryGB(): number | undefined;
+/**
+ * True when continuous live replay streaming should be deferred to buffered-only capture: the user
+ * asked to save data, the link is 2g/slow-2g, or the device is ultra-low-memory (≤1 GB). Returns
+ * false when no signal is available (feature-detect miss) — never over-restricts by default.
+ */
+export declare function shouldDeferHeavyEgress(): boolean;
+//# sourceMappingURL=deviceSignals.d.ts.map

package/dist/features/replay/lifecycle/deviceSignals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deviceSignals.d.ts","sourceRoot":"","sources":["../../../../src/features/replay/lifecycle/deviceSignals.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAYH,MAAM,WAAW,WAAW;IAC1B,gEAAgE;IAChE,QAAQ,EAAE,OAAO,CAAC;IAClB,qCAAqC;IACrC,IAAI,EAAE,OAAO,CAAC;IACd,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,wBAAgB,WAAW,IAAI,WAAW,CAQzC;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,IAAI,OAAO,CAQhD;AAED,uGAAuG;AACvG,wBAAgB,cAAc,IAAI,MAAM,GAAG,SAAS,CAInD;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,IAAI,OAAO,CAKhD"}

package/dist/features/replay/lifecycle/deviceSignals.js

@@ -0,0 +1,61 @@
+/**
+ * Cost/capability signals for replay egress decisions — all feature-detected + SSR-safe.
+ *
+ * Best-practice: respect the user's Save-Data preference (and slow / ultra-low-memory devices) by NOT
+ * streaming replay live over the network. Capture itself is NOT disabled — the session still records
+ * into the buffered pre-roll and flushes on signal (error/crash), so incident replay is preserved;
+ * only the continuous, bandwidth-heavy live upload is deferred.
+ *
+ * These are the ONLY device signals a browser exposes (battery/thermal are gone or never existed), so
+ * this is the web analog of the native SDK's SyncDecisionEngine.
+ */
+function connection() {
+    if (typeof navigator === 'undefined')
+        return undefined;
+    return navigator.connection;
+}
+export function networkHint() {
+    const c = connection();
+    const effectiveType = typeof c?.effectiveType === 'string' ? c.effectiveType : undefined;
+    return {
+        saveData: c?.saveData === true,
+        slow: effectiveType === '2g' || effectiveType === 'slow-2g',
+        effectiveType,
+    };
+}
+/**
+ * True when the user is signalling "do not track / do not sell-or-share" via **Global Privacy
+ * Control** (`navigator.globalPrivacyControl === true`) or legacy **Do-Not-Track**
+ * (`navigator.doNotTrack === '1'` / `'yes'`, or `window.doNotTrack === '1'`). Feature-detected +
+ * SSR-safe. Consulted only when the host opts in via `privacy.respectDnt`.
+ */
+export function userOptedOutOfTracking() {
+    if (typeof navigator === 'undefined')
+        return false;
+    const nav = navigator;
+    if (nav.globalPrivacyControl === true)
+        return true;
+    const dnt = nav.doNotTrack ??
+        (typeof window !== 'undefined' ? window.doNotTrack : undefined);
+    return dnt === '1' || dnt === 'yes';
+}
+/** Approximate device RAM in GB (Chromium `navigator.deviceMemory`), or undefined when unsupported. */
+export function deviceMemoryGB() {
+    if (typeof navigator === 'undefined')
+        return undefined;
+    const dm = navigator.deviceMemory;
+    return typeof dm === 'number' ? dm : undefined;
+}
+/**
+ * True when continuous live replay streaming should be deferred to buffered-only capture: the user
+ * asked to save data, the link is 2g/slow-2g, or the device is ultra-low-memory (≤1 GB). Returns
+ * false when no signal is available (feature-detect miss) — never over-restricts by default.
+ */
+export function shouldDeferHeavyEgress() {
+    const n = networkHint();
+    if (n.saveData || n.slow)
+        return true;
+    const mem = deviceMemoryGB();
+    return typeof mem === 'number' && mem <= 1;
+}
+//# sourceMappingURL=deviceSignals.js.map

package/dist/features/replay/lifecycle/deviceSignals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deviceSignals.js","sourceRoot":"","sources":["../../../../src/features/replay/lifecycle/deviceSignals.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAOH,SAAS,UAAU;IACjB,IAAI,OAAO,SAAS,KAAK,WAAW;QAAE,OAAO,SAAS,CAAC;IACvD,OAAQ,SAAuD,CAAC,UAAU,CAAC;AAC7E,CAAC;AAUD,MAAM,UAAU,WAAW;IACzB,MAAM,CAAC,GAAG,UAAU,EAAE,CAAC;IACvB,MAAM,aAAa,GAAG,OAAO,CAAC,EAAE,aAAa,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,SAAS,CAAC;IACzF,OAAO;QACL,QAAQ,EAAE,CAAC,EAAE,QAAQ,KAAK,IAAI;QAC9B,IAAI,EAAE,aAAa,KAAK,IAAI,IAAI,aAAa,KAAK,SAAS;QAC3D,aAAa;KACd,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,sBAAsB;IACpC,IAAI,OAAO,SAAS,KAAK,WAAW;QAAE,OAAO,KAAK,CAAC;IACnD,MAAM,GAAG,GAAG,SAA+E,CAAC;IAC5F,IAAI,GAAG,CAAC,oBAAoB,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IACnD,MAAM,GAAG,GACP,GAAG,CAAC,UAAU;QACd,CAAC,OAAO,MAAM,KAAK,WAAW,CAAC,CAAC,CAAE,MAA6C,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;IAC1G,OAAO,GAAG,KAAK,GAAG,IAAI,GAAG,KAAK,KAAK,CAAC;AACtC,CAAC;AAED,uGAAuG;AACvG,MAAM,UAAU,cAAc;IAC5B,IAAI,OAAO,SAAS,KAAK,WAAW;QAAE,OAAO,SAAS,CAAC;IACvD,MAAM,EAAE,GAAI,SAAkD,CAAC,YAAY,CAAC;IAC5E,OAAO,OAAO,EAAE,KAAK,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;AACjD,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,sBAAsB;IACpC,MAAM,CAAC,GAAG,WAAW,EAAE,CAAC;IACxB,IAAI,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC,IAAI;QAAE,OAAO,IAAI,CAAC;IACtC,MAAM,GAAG,GAAG,cAAc,EAAE,CAAC;IAC7B,OAAO,OAAO,GAAG,KAAK,QAAQ,IAAI,GAAG,IAAI,CAAC,CAAC;AAC7C,CAAC"}

package/dist/features/replay/lifecycle/offloadDomFrames.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Upload a DOM frame's payload STRAIGHT to object storage, so it never travels through the API.
+ *
+ * WHY. Measured on production over 32 hours: 154,235 of 163,644 stored frames are web DOM payloads,
+ * and every one arrived inline in the batch envelope and was then PUT to object storage BY THE
+ * SERVER, on the request path, at 25–70ms per round trip. That relay is most of a slow ingest
+ * request — the database work inside the same request is about 4% of it. React Native has uploaded
+ * its screenshots directly for a long time; the web lane could not, because the presign endpoint
+ * only signed image keys and the ingest path only read a client-supplied key for images.
+ *
+ * WHAT IT IS NOT. This does not change what is stored: same object, same key, same row, same
+ * `events` copy in Postgres for the heatmap lane. It changes who performs the upload.
+ *
+ * EVERY FAILURE FALLS BACK TO INLINE. A presign that cannot be reached, a backend with storage
+ * switched off, a PUT that is rejected — each leaves the frame exactly as it was, and the server
+ * stores it the way it always has. That is the whole safety argument: the old path is not removed,
+ * it is simply not used when the fast one works.
+ */
+/** The fields the server assembles into the stored object. MUST match `domObj` in persistFrame. */
+interface DomFrame {
+    kind?: string;
+    renderer?: string;
+    frameId?: string;
+    snapshot?: unknown;
+    mutations?: unknown[];
+    events?: unknown;
+    adoptedStyles?: string[];
+    viewport?: unknown;
+    href?: string;
+    domStorageKey?: string;
+    sizeBytes?: number;
+}
+export interface OffloadDeps {
+    sessionId: string;
+    presign: (sessionId: string, frames: Array<{
+        frameId: string;
+        payloadKind?: string;
+    }>, cssIds?: string[]) => Promise<{
+        enabled: boolean;
+        frames?: Array<{
+            frameId: string;
+            uploadUrl: string;
+            storageKey: string;
+            contentType: string;
+        }>;
+    } | null>;
+    put: (url: string, body: BodyInit, contentType: string) => Promise<boolean>;
+}
+/**
+ * THE STORED OBJECT'S SHAPE, and the reason it is a named function rather than an inline literal.
+ *
+ * The server builds exactly this set — snapshot, mutations, events, adoptedStyles, viewport, href —
+ * and the reader parses what the server built. If the two ever disagree the upload still succeeds,
+ * the row still stores a key, and the replay renders wrong or blank with nothing logged at either
+ * end. Keeping it in one exported function is what lets a test pin the field set.
+ */
+export declare function domPayloadOf(f: DomFrame): Record<string, unknown>;
+/**
+ * Offload what can be offloaded, in place, and leave everything else untouched.
+ *
+ * Mutates the items rather than returning copies, deliberately: when a batch fails to send it is
+ * put back on the queue, and a frame whose bytes are ALREADY in storage should stay that way. A
+ * copy would upload the same payload again on every retry.
+ *
+ * Returns how many frames were offloaded, for the caller's diagnostics — never throws.
+ */
+export declare function offloadDomFrames(items: readonly unknown[], deps: OffloadDeps): Promise<number>;
+export {};
+//# sourceMappingURL=offloadDomFrames.d.ts.map

package/dist/features/replay/lifecycle/offloadDomFrames.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"offloadDomFrames.d.ts","sourceRoot":"","sources":["../../../../src/features/replay/lifecycle/offloadDomFrames.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,mGAAmG;AACnG,UAAU,QAAQ;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,SAAS,CAAC,EAAE,OAAO,EAAE,CAAC;IACtB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,CACP,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,KAAK,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,EACxD,MAAM,CAAC,EAAE,MAAM,EAAE,KACd,OAAO,CAAC;QACX,OAAO,EAAE,OAAO,CAAC;QACjB,MAAM,CAAC,EAAE,KAAK,CAAC;YAAE,OAAO,EAAE,MAAM,CAAC;YAAC,SAAS,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,WAAW,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;KACjG,GAAG,IAAI,CAAC,CAAC;IACV,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CAC7E;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CASjE;AAgBD;;;;;;;;GAQG;AACH,wBAAsB,gBAAgB,CACpC,KAAK,EAAE,SAAS,OAAO,EAAE,EACzB,IAAI,EAAE,WAAW,GAChB,OAAO,CAAC,MAAM,CAAC,CAqDjB"}

package/dist/features/replay/lifecycle/offloadDomFrames.js

@@ -0,0 +1,107 @@
+/**
+ * Upload a DOM frame's payload STRAIGHT to object storage, so it never travels through the API.
+ *
+ * WHY. Measured on production over 32 hours: 154,235 of 163,644 stored frames are web DOM payloads,
+ * and every one arrived inline in the batch envelope and was then PUT to object storage BY THE
+ * SERVER, on the request path, at 25–70ms per round trip. That relay is most of a slow ingest
+ * request — the database work inside the same request is about 4% of it. React Native has uploaded
+ * its screenshots directly for a long time; the web lane could not, because the presign endpoint
+ * only signed image keys and the ingest path only read a client-supplied key for images.
+ *
+ * WHAT IT IS NOT. This does not change what is stored: same object, same key, same row, same
+ * `events` copy in Postgres for the heatmap lane. It changes who performs the upload.
+ *
+ * EVERY FAILURE FALLS BACK TO INLINE. A presign that cannot be reached, a backend with storage
+ * switched off, a PUT that is rejected — each leaves the frame exactly as it was, and the server
+ * stores it the way it always has. That is the whole safety argument: the old path is not removed,
+ * it is simply not used when the fast one works.
+ */
+/**
+ * THE STORED OBJECT'S SHAPE, and the reason it is a named function rather than an inline literal.
+ *
+ * The server builds exactly this set — snapshot, mutations, events, adoptedStyles, viewport, href —
+ * and the reader parses what the server built. If the two ever disagree the upload still succeeds,
+ * the row still stores a key, and the replay renders wrong or blank with nothing logged at either
+ * end. Keeping it in one exported function is what lets a test pin the field set.
+ */
+export function domPayloadOf(f) {
+    return {
+        snapshot: f.snapshot ?? null,
+        mutations: f.mutations ?? null,
+        events: f.events ?? null,
+        adoptedStyles: f.adoptedStyles ?? null,
+        viewport: f.viewport ?? null,
+        href: f.href ?? null,
+    };
+}
+/** True for a DOM frame that still carries its payload and has not been offloaded yet. */
+function isOffloadable(it) {
+    const f = it;
+    return (!!f &&
+        f.kind === 'frame' &&
+        f.renderer === 'dom' &&
+        !f.domStorageKey &&
+        (f.snapshot != null || (f.mutations != null && f.mutations.length > 0)) &&
+        typeof f.frameId === 'string' &&
+        !!f.frameId);
+}
+/**
+ * Offload what can be offloaded, in place, and leave everything else untouched.
+ *
+ * Mutates the items rather than returning copies, deliberately: when a batch fails to send it is
+ * put back on the queue, and a frame whose bytes are ALREADY in storage should stay that way. A
+ * copy would upload the same payload again on every retry.
+ *
+ * Returns how many frames were offloaded, for the caller's diagnostics — never throws.
+ */
+export async function offloadDomFrames(items, deps) {
+    const targets = items.filter(isOffloadable);
+    if (targets.length === 0)
+        return 0;
+    let signed;
+    try {
+        signed = await deps.presign(deps.sessionId, targets.map((f) => ({ frameId: f.frameId, payloadKind: 'dom' })));
+    }
+    catch {
+        return 0; // inline, exactly as before
+    }
+    if (!signed || !signed.enabled || !signed.frames?.length)
+        return 0;
+    const byId = new Map(signed.frames.map((s) => [s.frameId, s]));
+    let done = 0;
+    await Promise.all(targets.map(async (f) => {
+        const slot = byId.get(f.frameId);
+        if (!slot)
+            return; // the server declined this one; it stays inline
+        let body;
+        try {
+            body = JSON.stringify(domPayloadOf(f));
+        }
+        catch {
+            return; // unserializable — the server's own path would have failed the same way
+        }
+        const ok = await deps.put(slot.uploadUrl, body, slot.contentType);
+        if (!ok)
+            return; // PUT refused → inline
+        /**
+         * ONLY NOW is the payload removed from the item. Doing it before the PUT resolved would turn
+         * a failed upload into a frame with neither bytes nor a key — the one outcome worse than
+         * sending it inline.
+         *
+         * `events` is deliberately KEPT: the server reads it off the item to fill `domEvents`, the
+         * slim Postgres copy the click-heatmap scans, and that must land whether or not the payload
+         * travelled through the server.
+         *
+         * `sizeBytes` is set because the server measures it from the inline payload it can no longer
+         * see. Sending it keeps "how big is this session" answerable for web.
+         */
+        f.domStorageKey = slot.storageKey;
+        f.sizeBytes = body.length;
+        delete f.snapshot;
+        delete f.mutations;
+        delete f.adoptedStyles;
+        done += 1;
+    }));
+    return done;
+}
+//# sourceMappingURL=offloadDomFrames.js.map

package/dist/features/replay/lifecycle/offloadDomFrames.js.map

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

package/dist/features/replay/lifecycle/pii.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Heuristic PII redaction for replay text — the 'strict' privacy tier. Mask-all-text (default) already
+ * removes PII at capture; this is the safety net for UNMASKED replay (internal/dev apps that opt out
+ * of masking but still must not ship emails / card numbers / SSNs). Runs in the recorder, in MY lane:
+ * it scrubs the serialized SNode snapshot + delta mutation values BEFORE they're buffered/encoded, so
+ * no PII reaches the wire — without touching the engine's capture path.
+ *
+ * Heuristic by nature (regex): in strict mode we err toward over-redaction (privacy-first).
+ */
+import type { FrameItem } from '@scalebun/protocol';
+export declare function redactText(s: string): string;
+/** Mutate a frame in place, scrubbing PII from its snapshot (keyframe) or mutations (delta). */
+export declare function redactFrame(frame: FrameItem): void;
+//# sourceMappingURL=pii.d.ts.map

package/dist/features/replay/lifecycle/pii.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pii.d.ts","sourceRoot":"","sources":["../../../../src/features/replay/lifecycle/pii.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAepD,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAI5C;AAED,gGAAgG;AAChG,wBAAgB,WAAW,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,CAKlD"}

package/dist/features/replay/lifecycle/pii.js

@@ -0,0 +1,52 @@
+const MASK = '[redacted]';
+// Order matters: alpha-prefixed (IBAN) and dashed (SSN) forms BEFORE the broad digit-runs so they
+// aren't half-eaten; phone (structured, shorter) after the card run so a card isn't caught as a phone.
+const PATTERNS = [
+    /\b[\w.+-]+@[\w-]+\.[\w.-]+\b/g, // email
+    /\b[A-Z]{2}\d{2}[A-Z0-9]{10,30}\b/g, // IBAN (country + check digits + BBAN)
+    /\b\d{3}-\d{2}-\d{4}\b/g, // US SSN
+    /\b(?:\d[ -]?){13,18}\d\b/g, // card-like 14–19 digit run (optionally spaced/dashed)
+    // Phone: an optional + country code / parenthesized area code, then ≥3 separated digit groups, so a
+    // real phone is caught but a plain two-token number ("42 items") is not.
+    /(?:\+\d{1,3}[\s.-]?)?\(?\d{2,4}\)?[\s.-]\d{2,4}[\s.-]\d{2,4}(?:[\s.-]\d{2,4})?/g,
+];
+export function redactText(s) {
+    let out = s;
+    for (const re of PATTERNS)
+        out = out.replace(re, MASK);
+    return out;
+}
+/** Mutate a frame in place, scrubbing PII from its snapshot (keyframe) or mutations (delta). */
+export function redactFrame(frame) {
+    const snap = frame.snapshot;
+    if (snap && typeof snap === 'object')
+        redactSNode(snap);
+    const muts = frame.mutations;
+    if (Array.isArray(muts))
+        for (const m of muts)
+            redactMutation(m);
+}
+function redactSNode(n) {
+    if (n.t === 'tx' || n.t === 'cm') {
+        if (typeof n.value === 'string')
+            n.value = redactText(n.value);
+        return;
+    }
+    if (n.attrs)
+        for (const k in n.attrs)
+            if (typeof n.attrs[k] === 'string')
+                n.attrs[k] = redactText(n.attrs[k]);
+    if (Array.isArray(n.children))
+        for (const c of n.children)
+            redactSNode(c);
+    if (n.shadow?.children)
+        for (const c of n.shadow.children)
+            redactSNode(c);
+}
+function redactMutation(m) {
+    if ((m.op === 'text' || m.op === 'attr') && typeof m.value === 'string')
+        m.value = redactText(m.value);
+    if (m.op === 'add' && m.node)
+        redactSNode(m.node);
+}
+//# sourceMappingURL=pii.js.map

package/dist/features/replay/lifecycle/pii.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pii.js","sourceRoot":"","sources":["../../../../src/features/replay/lifecycle/pii.ts"],"names":[],"mappings":"AAWA,MAAM,IAAI,GAAG,YAAY,CAAC;AAC1B,kGAAkG;AAClG,uGAAuG;AACvG,MAAM,QAAQ,GAAa;IACzB,+BAA+B,EAAE,QAAQ;IACzC,mCAAmC,EAAE,uCAAuC;IAC5E,wBAAwB,EAAE,SAAS;IACnC,2BAA2B,EAAE,uDAAuD;IACpF,oGAAoG;IACpG,yEAAyE;IACzE,iFAAiF;CAClF,CAAC;AAEF,MAAM,UAAU,UAAU,CAAC,CAAS;IAClC,IAAI,GAAG,GAAG,CAAC,CAAC;IACZ,KAAK,MAAM,EAAE,IAAI,QAAQ;QAAE,GAAG,GAAG,GAAG,CAAC,OAAO,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;IACvD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,gGAAgG;AAChG,MAAM,UAAU,WAAW,CAAC,KAAgB;IAC1C,MAAM,IAAI,GAAI,KAAgC,CAAC,QAAQ,CAAC;IACxD,IAAI,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ;QAAE,WAAW,CAAC,IAAgB,CAAC,CAAC;IACpE,MAAM,IAAI,GAAI,KAAuC,CAAC,SAAS,CAAC;IAChE,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC;QAAE,KAAK,MAAM,CAAC,IAAI,IAAI;YAAE,cAAc,CAAC,CAAC,CAAC,CAAC;AACnE,CAAC;AAgBD,SAAS,WAAW,CAAC,CAAW;IAC9B,IAAI,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC;QACjC,IAAI,OAAO,CAAC,CAAC,KAAK,KAAK,QAAQ;YAAE,CAAC,CAAC,KAAK,GAAG,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;QAC/D,OAAO;IACT,CAAC;IACD,IAAI,CAAC,CAAC,KAAK;QAAE,KAAK,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK;YAAE,IAAI,OAAO,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,QAAQ;gBAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IAC9G,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,QAAQ,CAAC;QAAE,KAAK,MAAM,CAAC,IAAI,CAAC,CAAC,QAAQ;YAAE,WAAW,CAAC,CAAC,CAAC,CAAC;IAC1E,IAAI,CAAC,CAAC,MAAM,EAAE,QAAQ;QAAE,KAAK,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,QAAQ;YAAE,WAAW,CAAC,CAAC,CAAC,CAAC;AAC5E,CAAC;AAED,SAAS,cAAc,CAAC,CAAc;IACpC,IAAI,CAAC,CAAC,CAAC,EAAE,KAAK,MAAM,IAAI,CAAC,CAAC,EAAE,KAAK,MAAM,CAAC,IAAI,OAAO,CAAC,CAAC,KAAK,KAAK,QAAQ;QAAE,CAAC,CAAC,KAAK,GAAG,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;IACvG,IAAI,CAAC,CAAC,EAAE,KAAK,KAAK,IAAI,CAAC,CAAC,IAAI;QAAE,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;AACpD,CAAC"}

package/dist/features/replay/lifecycle/recorder.d.ts

@@ -0,0 +1,178 @@
+/**
+ * RecorderController — the entire DOM-replay recording lifecycle, lazy-loaded by the thin
+ * `ReplayFeature` shell only for a SAMPLED session. Keeping this out of the eager feature class
+ * means none of the orchestration (segments, checkpoints, cadence, wiring) weighs down the core
+ * bundle — the shell in core is ~a dozen lines.
+ *
+ * Owns: keyframe snapshot (worker-compressed) → mutation/CSSOM/interaction/iframe/canvas deltas →
+ * the SegmentBuffer pre-roll → capture-on-signal flush → re-keyframe checkpoints (segment-full /
+ * time / visibility / URL). In 'sampled'/'always' mode it streams from the first frame instead.
+ */
+import type { FeatureContext } from '@scalebun/sdk-contracts';
+import type { SampleDecision } from './sampling.js';
+/** Diagnostics surfaced via ScaleBun.replay.stats() + the Dev Panel. */
+export interface ReplayStats {
+    recording: boolean;
+    paused: boolean;
+    streaming: boolean;
+    sampleReason: string;
+    sampleBucket: number;
+    qualityLevel: number;
+    segments: number;
+    /**
+     * Frames currently held in the SEGMENT BUFFER — not a cumulative total.
+     *
+     * Named here because it reads like one and is not: while streaming, frames leave the buffer as they
+     * ship, so a perfectly healthy session reports 0. The P1b first-frame watchdog originally tested
+     * this and fired on every healthy streaming session, which would have poisoned the exact metric it
+     * exists to feed. Use `captured` to ask "did this session ever produce a frame".
+     */
+    frames: number;
+    /**
+     * Has a keyframe EVER been produced in this session? Cumulative and monotonic.
+     *
+     * Derived from `keyframeId`, which is assigned when the first snapshot is taken and thereafter only
+     * reassigned (every delta references it as `baseFrameId`), so it is never cleared back to null while
+     * recording. That makes it the honest answer to "did capture actually happen", independent of what
+     * the buffer holds right now or whether the session streams or buffers.
+     */
+    captured: boolean;
+    bufferBytes: number;
+    droppedSegments: number;
+    shedFrames: number;
+    /**
+     * Cumulative per-producer frame/byte counters for THIS session (what actually shipped or was
+     * buffered — adaptive-shed frames are excluded; they're in `shedFrames`). Bytes are approxBytes
+     * at push time, i.e. pre-gzip for keyframes. The point is attribution, not accounting: "62% of
+     * frames were cursor moves" is the measurement the flush-policy tuning is judged against.
+     * Producers: keyframe | mutation (DOM+CSSOM lane) | canvas | interaction (click/deadclick/input)
+     * | scroll (scroll/viewport) | move.
+     */
+    producers: Record<string, {
+        frames: number;
+        bytes: number;
+    }>;
+}
+export declare function createRecorder(ctx: FeatureContext, decision: SampleDecision): Promise<RecorderController>;
+export declare class RecorderController {
+    private readonly ctx;
+    private readonly decision;
+    /**
+     * Take the next sequence number and persist the advance (survives reload / shared tabs).
+     *
+     * CALLED FROM push(), AFTER every decision that can discard the frame — never from the builders.
+     *
+     * It used to be called while constructing the frame object, which push() could then drop outright:
+     * adaptive quality shedding a cursor-move frame, or SegmentBuffer refusing a delta that has no open
+     * segment. The number was never reused, so a deliberate shed and a frame genuinely lost in transit
+     * left the SAME hole in the stored sequence. That made our own reliability figure unprovable —
+     * production measures 1.16% of numbered frames missing, and nobody could say how much of it was
+     * intentional. Assigning at emission makes a gap mean exactly one thing: a frame that left the
+     * recorder and did not arrive.
+     */
+    private nextSeq;
+    private active;
+    private streaming;
+    /**
+     * Replay frame sequence, PER SESSION rather than per document.
+     *
+     * A session now survives a refresh (features/session/sessionStore), and the backend both orders
+     * frames by this number and resolves a keyframe's deltas as the frames in [seq, nextSeq). A
+     * counter that restarted at 0 on each page load would therefore emit a second frame 0, 1, 2…
+     * that sorts BEFORE the first load's later frames and scrambles the replay. Seed from the store
+     * so a resumed session keeps counting.
+     */
+    private seq;
+    private keyframeId;
+    private checkpointing;
+    private dirtySinceKeyframe;
+    private lastKeyframeAt;
+    private streamChainBytes;
+    private streamChainFrames;
+    /** Last `egressDropped` reading — a RISE means the pipeline shed a chain (see push()). */
+    private lastShed;
+    private segBuf?;
+    private reg?;
+    private snapOpts?;
+    private takeSnapshotFn?;
+    private mutationRec?;
+    private cssomRec?;
+    private encoder?;
+    private readonly pendingEncodes;
+    private adaptive?;
+    private shed;
+    private deltaBatcher?;
+    private readonly producerCounts;
+    private readonly persistBuffer;
+    private replayStore?;
+    private onPageHide?;
+    private onVisHidden?;
+    private redactPII;
+    private paused;
+    private maskText;
+    private disconnectRecorder?;
+    private disconnectInteractions?;
+    private disconnectCssom?;
+    private disconnectCanvas?;
+    private disconnectIframes?;
+    private disposeEncoder?;
+    private unsubSignal?;
+    private disconnectCadence?;
+    private childSatelliteStop?;
+    constructor(ctx: FeatureContext, decision: SampleDecision);
+    get isActive(): boolean;
+    /** Live diagnostics. */
+    stats(): ReplayStats;
+    /** Force a re-keyframe (e.g. ScaleBun.replay.checkpoint() before a risky flow). */
+    forceCheckpoint(reason: string): void;
+    /** One-time bring-up: segment buffer + crash-survival mirror + encoder (survive pause/resume), then
+     *  ARM the capture pipeline (observers + first keyframe). The re-armable part lives in `arm()`. */
+    init(): Promise<void>;
+    /**
+     * ARM the capture pipeline: fresh NodeRegistry + a keyframe of the CURRENT DOM, then wire + observe
+     * the mutation/interaction/CSSOM/iframe/canvas recorders, adaptive quality, and checkpoint cadence.
+     * Idempotent-safe to call after `disarm()` — this is exactly what resume()/setPrivacy() do, and why a
+     * resume takes a fresh keyframe (the DOM changed while paused, so old deltas can't rebase).
+     */
+    private arm;
+    /** DISARM the capture pipeline: stop every observer + adaptive + cadence and drop the capture-scoped
+     *  state, WITHOUT touching the segment buffer / crash-mirror / encoder / session (those survive a
+     *  pause). The inverse of `arm()`; shared by pause() and teardown(). Idempotent. */
+    private disarm;
+    /** Pause capture (stop observers) while keeping the session + buffered pre-roll intact. No-op when
+     *  not recording or already paused. */
+    pause(): void;
+    /** Resume capture after pause(): re-arm with a FRESH keyframe of the current DOM (the DOM changed
+     *  while paused, so a new base is required). No-op when not recording or not paused. */
+    resume(): void;
+    /** Change replay masking at runtime (e.g. entering a sensitive screen). Re-arms with a fresh keyframe
+     *  so the new masking takes effect from here on; the already-captured pre-roll keeps its old masking. */
+    setPrivacy(policy: {
+        maskAllText?: boolean;
+    }): void;
+    /** Build a delta frame against the current keyframe. `seq` is assigned in push(), not here — see
+     *  the note on nextSeq(). */
+    private delta;
+    private push;
+    /** Re-keyframe: drain queued records onto the OLD keyframe, snapshot the live DOM, open a new
+     *  segment with the keyframe (raw → gzip in-place). Subsequent deltas auto-rebase via `keyframeId`. */
+    private checkpoint;
+    private recoverPriorPreRoll;
+    /** Mirror the current pre-roll to IDB (byte-capped). A crash retains it; a clean close clears it.
+     *  Every item here IS a frame, so `isHeavy` is constant — the predicates exist to tell capBytes
+     *  which of them is a base, so a trimmed pre-roll starts at a keyframe instead of at deltas that
+     *  reconstruct against a snapshot no longer present. */
+    private persistPreRoll;
+    private installPersistGuards;
+    /**
+     * Upgrade a keyframe's already-emitted RAW snapshot to gzip in-place as the worker finishes. The
+     * frame object is shared with the SegmentBuffer / pipeline queue, so filling `.snapshot` swaps the
+     * payload before egress IF the encode wins the race; otherwise the valid raw payload ships. No
+     * await, no ordering hazard — correctness over a few uncompressed bytes on a lost race.
+     */
+    private compressInPlace;
+    /** Capture-on-signal: drain pending records, flush the pre-roll segments, then stream live. */
+    flush(): void;
+    teardown(): void;
+}
+//# sourceMappingURL=recorder.d.ts.map

package/dist/features/replay/lifecycle/recorder.d.ts.map

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