@scalebun-release/web 2.2.2

package/dist/features/push/softAsk.js

@@ -0,0 +1,142 @@
+const STORE_KEY = 'scalebun.push.softAsk.snoozedUntil';
+const DAY_MS = 86400000;
+const DEFAULTS = {
+    title: 'Stay in the loop',
+    body: 'Get notified about important updates. You can turn this off any time.',
+    allowText: 'Allow notifications',
+    denyText: 'Not now',
+    remindAfterDays: 7,
+    accent: '#5B4FE0',
+};
+/** A dismissal is a real answer and is honoured across sessions. Storage failures never block. */
+function snoozed() {
+    try {
+        const until = Number(localStorage.getItem(STORE_KEY) || 0);
+        return Number.isFinite(until) && until > Date.now();
+    }
+    catch {
+        return false;
+    }
+}
+function snooze(days) {
+    try {
+        localStorage.setItem(STORE_KEY, String(Date.now() + days * DAY_MS));
+    }
+    catch {
+        /* private mode — the worst case is asking again next session */
+    }
+}
+/**
+ * Render the dialog and resolve with what the visitor chose.
+ *
+ * Shadow DOM so the host's CSS cannot break it and ours cannot leak into the host — the same
+ * containment rule the in-app surfaces follow.
+ */
+function ask(o) {
+    return new Promise((resolve) => {
+        const host = document.createElement('div');
+        host.setAttribute('data-scalebun-softask', '');
+        host.setAttribute('data-scalebun', '');
+        // Above ordinary page chrome, below the browser's own prompt (which the OS draws anyway).
+        host.style.cssText = 'position:fixed;z-index:2147483000;inset:auto 16px 16px auto';
+        const root = host.attachShadow({ mode: 'open' });
+        root.innerHTML = `
+      <style>
+        :host{all:initial}
+        .c{width:min(340px,calc(100vw - 32px));box-sizing:border-box;padding:16px 18px;border-radius:14px;
+           background:#fff;color:#172033;box-shadow:0 18px 48px rgba(3,7,18,.28);
+           font:14px/1.45 -apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,sans-serif;
+           animation:in .22s ease-out both}
+        @keyframes in{from{opacity:0;transform:translateY(10px)}to{opacity:1;transform:none}}
+        .t{font-size:15px;font-weight:700;margin:0 0 4px}
+        .b{margin:0 0 14px;color:#5b6472}
+        .r{display:flex;gap:8px;justify-content:flex-end}
+        button{font:inherit;font-weight:600;border-radius:9px;padding:8px 14px;cursor:pointer;border:0}
+        .no{background:transparent;color:#5b6472}
+        .yes{background:var(--a);color:#fff}
+        @media (prefers-color-scheme:dark){
+          .c{background:#1a1e27;color:#f2f4f8}.b{color:#aab2c0}.no{color:#aab2c0}
+        }
+        @media (prefers-reduced-motion:reduce){.c{animation-duration:1ms}}
+      </style>
+      <div class="c" role="dialog" aria-modal="false" style="--a:${o.accent}">
+        <p class="t"></p>
+        <p class="b"></p>
+        <div class="r">
+          <button class="no" type="button"></button>
+          <button class="yes" type="button"></button>
+        </div>
+      </div>`;
+        // textContent, never innerHTML: these strings come from tenant config and must not be able to
+        // inject markup into a host page.
+        root.querySelector('.t').textContent = o.title;
+        root.querySelector('.b').textContent = o.body;
+        const no = root.querySelector('.no');
+        const yes = root.querySelector('.yes');
+        no.textContent = o.denyText;
+        yes.textContent = o.allowText;
+        const close = (accepted) => {
+            host.remove();
+            resolve(accepted);
+        };
+        no.addEventListener('click', () => close(false));
+        // ⚠️ This click IS the user activation the browser requires. `enable()` must be called from
+        // inside this handler's task — deferring it (setTimeout, await before the call) drops the
+        // activation and the real prompt silently never appears.
+        yes.addEventListener('click', () => close(true));
+        document.body.appendChild(host);
+    });
+}
+/**
+ * Arm the soft-ask. Resolves once a decision is made (or immediately when it should not run).
+ *
+ * Every early return is a case where asking would be wrong, not merely unnecessary:
+ *   • already `granted` — they are subscribed; a dialog would be noise
+ *   • already `denied`  — the browser prompt is unavailable, so "Allow" could not work. Offering a
+ *     button that cannot succeed is worse than offering nothing.
+ *   • snoozed           — they said not now, and meant it
+ */
+export async function armSoftAsk(opts, deps) {
+    if (typeof document === 'undefined' || typeof Notification === 'undefined')
+        return;
+    const perm = deps.permission();
+    if (perm !== 'default')
+        return;
+    if (snoozed())
+        return;
+    const o = { ...DEFAULTS, ...opts };
+    const run = async () => {
+        if (deps.permission() !== 'default' || snoozed())
+            return;
+        const accepted = await ask(o);
+        if (!accepted) {
+            snooze(o.remindAfterDays);
+            deps.log?.('soft-ask declined — snoozed');
+            return;
+        }
+        const r = await deps.enable();
+        deps.log?.(`soft-ask accepted → enable() = ${r}`);
+        // A browser-level block is permanent, so there is nothing to snooze and nothing to retry.
+        if (r === 'denied')
+            deps.log?.('browser permission denied — the SDK cannot re-ask');
+    };
+    const t = opts.trigger ?? 'immediate';
+    if (t === 'immediate')
+        return void run();
+    if (typeof t === 'object' && 'afterMs' in t) {
+        setTimeout(() => void run(), Math.max(0, t.afterMs));
+        return;
+    }
+    if (typeof t === 'object' && 'onSelector' in t) {
+        // Delegated, so it still works for elements added after init (SPA routes, late hydration).
+        const onClick = (e) => {
+            const el = e.target;
+            if (el && el.closest && el.closest(t.onSelector)) {
+                document.removeEventListener('click', onClick, true);
+                void run();
+            }
+        };
+        document.addEventListener('click', onClick, true);
+    }
+}
+//# sourceMappingURL=softAsk.js.map

package/dist/features/push/softAsk.js.map

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

package/dist/features/replay/ReplayFeature.d.ts

@@ -0,0 +1,52 @@
+/**
+ * F-RPL — the thin eager shell. Registered in the manifest so the SDK knows replay exists, but it
+ * carries almost no code: it makes the deterministic SAMPLING decision (lazy `sampling.ts`) and, only
+ * for a sampled session, lazy-loads the full `RecorderController` (`lifecycle/recorder.ts`). All the
+ * recording lifecycle — snapshot, segments, checkpoints, cadence, engine wiring — lives in that lazy
+ * chunk, so it never weighs down the core bundle. A non-sampled session loads only `sampling.ts`.
+ */
+import type { IFeature, FeatureContext } from '@scalebun/sdk-contracts';
+import type { ReplayStats } from './lifecycle/recorder.js';
+export declare class ReplayFeature implements IFeature {
+    readonly name = "replay";
+    private controller?;
+    private uninstallWebGL?;
+    private watchdog?;
+    get isActive(): boolean;
+    setup(ctx: FeatureContext): Promise<void>;
+    /**
+     * Resolves when arming has finished — succeeded OR reported its failure. Never rejects (`arm` owns
+     * its own error handling), so awaiting it is always safe.
+     *
+     * Deliberately not on `IFeature`: nothing in the SDK awaits it, and adding it to the interface would
+     * imply every feature has an async tail. It exists because `setup()` returning early made "the
+     * recorder is now live" unobservable, which the replay suites legitimately need to assert — the
+     * alternative was weakening eleven behavioural tests into timing guesses, which would trade a real
+     * contract for a green tick.
+     */
+    armed?: Promise<void>;
+    /**
+     * Load the recorder and start capturing. Runs detached from `setup()` — see the note above.
+     *
+     * Every failure here is terminal for replay and silent everywhere else, so this method owns its own
+     * reporting: nothing upstream is awaiting it to notice a rejection.
+     */
+    private arm;
+    private load;
+    /** Capture-on-signal flush (promote pre-roll → live). No-op until a recorder is active. */
+    flush(): void;
+    /** Live diagnostics (null when not recording — off, or a non-sampled session). */
+    stats(): ReplayStats | null;
+    /** Force a re-keyframe (e.g. before a risky flow), so the player gets a clean seek point. */
+    checkpoint(reason?: string): void;
+    /** Pause capture (keep the session + buffered pre-roll). No-op until a recorder is active. */
+    pause(): void;
+    /** Resume capture after pause() with a fresh keyframe. No-op unless paused. */
+    resume(): void;
+    /** Change replay text-masking at runtime (re-keyframes so it applies from here on). */
+    setPrivacy(policy: {
+        maskAllText?: boolean;
+    }): void;
+    teardown(): void;
+}
+//# sourceMappingURL=ReplayFeature.d.ts.map

package/dist/features/replay/ReplayFeature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReplayFeature.d.ts","sourceRoot":"","sources":["../../../src/features/replay/ReplayFeature.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACxE,OAAO,KAAK,EAAsB,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAsD5E,qBAAa,aAAc,YAAW,QAAQ;IAC5C,QAAQ,CAAC,IAAI,YAAY;IACzB,OAAO,CAAC,UAAU,CAAC,CAAqB;IACxC,OAAO,CAAC,cAAc,CAAC,CAAa;IACpC,OAAO,CAAC,QAAQ,CAAC,CAAgC;IAEjD,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAEK,KAAK,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAgF/C;;;;;;;;;OASG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAEtB;;;;;OAKG;YACW,GAAG;YAgBH,IAAI;IA+FlB,2FAA2F;IAC3F,KAAK,IAAI,IAAI;IAIb,kFAAkF;IAClF,KAAK,IAAI,WAAW,GAAG,IAAI;IAI3B,6FAA6F;IAC7F,UAAU,CAAC,MAAM,SAAW,GAAG,IAAI;IAInC,8FAA8F;IAC9F,KAAK,IAAI,IAAI;IAIb,+EAA+E;IAC/E,MAAM,IAAI,IAAI;IAId,uFAAuF;IACvF,UAAU,CAAC,MAAM,EAAE;QAAE,WAAW,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI;IAInD,QAAQ,IAAI,IAAI;CAUjB"}

package/dist/features/replay/ReplayFeature.js

@@ -0,0 +1,282 @@
+/**
+ * P5 — `decideSampling` is imported STATICALLY, not fetched.
+ *
+ * It used to be `await import('./lifecycle/sampling.js')`, which put a whole round trip in front of the
+ * recorder import: init → fetch sampling → decide → fetch recorder → create. Measured, that waterfall
+ * is what sets the capture floor, and the floor is set by LATENCY rather than by session duration —
+ * with instant chunks a 100 ms visit captures, at 300 ms per chunk the floor rises to 500 ms and at
+ * 600 ms it rises to 2 s. Time-to-first-keyframe scales at roughly 8× per-chunk latency because the
+ * graph is deep, so removing a hop from it is worth more than shaving bytes anywhere else.
+ *
+ * This costs the EAGER core nothing. Since P5a moved `ReplayFeature` itself into a lazy chunk, its
+ * static imports are bundled into that chunk — which is already being fetched by the time this runs.
+ * The module is ~40 lines and its only runtime dependency, `bucketOf`, is in eager core already for
+ * flags and experiments.
+ *
+ * The guarantee the dynamic import was protecting is preserved and in fact strengthened: a
+ * non-sampled session still installs nothing beyond the decision, and now fetches nothing extra to
+ * make it.
+ */
+import { decideSampling } from './lifecycle/sampling.js';
+// Already in the eager core (FeatureRegistry), so reusing it here costs the identifier and nothing
+// more — and keeps ONE definition of "was this a chunk that never arrived" across both reporters.
+import { isModuleLoadFailure } from '../../bootstrap/FeatureRegistry.js';
+/** Gap before the single recorder-import retry (A3). Long enough to outlast a blip, short enough that a
+ *  bouncing visitor is not what decides the outcome. */
+const RECORDER_RETRY_MS = 400;
+/**
+ * P1b — the capture-failure report. SAME NAME as the React Native SDK, with platform-specific
+ * `reason` values, so one dashboard breakdown reads both without a concept-map alias.
+ *
+ * Hoisted to a const because it appears three times: repeating the literal costs more gzipped bytes
+ * than the identifier, and the eager budget it comes out of is 468 B.
+ */
+const FAIL = 'sdk_replay_capture_failed';
+/**
+ * How long a session may be ARMED with zero frames before that is a defect rather than latency.
+ *
+ * Measured, not chosen. Of sessions that produced a keyframe, the capture offset is p50 0 ms, p95
+ * 2,453 ms, p99 6,821 ms. 5 s sits above p95 and below p99: late enough that a merely slow session is
+ * not accused, early enough to still fire inside the 5–10 s bucket — which is where readiness collapses
+ * to 31.4% against 77% at 10–30 s, i.e. the one bucket this watchdog exists to explain.
+ *
+ * A page that unloads before this fires reports nothing, and that is correct: the session ended, it did
+ * not fail. Those are `bounced`, and they are counted from duration, not from here.
+ */
+const FIRST_FRAME_WATCHDOG_MS = 5000;
+/** Extracted so the retry awaits the SAME specifier — two spellings would defeat the module cache. */
+const loadRecorder = () => import('./lifecycle/recorder.js');
+export class ReplayFeature {
+    constructor() {
+        this.name = 'replay';
+    }
+    get isActive() {
+        return this.controller?.isActive ?? false;
+    }
+    async setup(ctx) {
+        /**
+         * P1b — the three exits below used to be SILENT, and that silence is the whole diagnostic gap.
+         *
+         * Measured on 275 live web sessions: 64 lasted a second or more and stored zero frames, and 57 of
+         * those 64 uploaded events, web vitals and `first_open` in the same session — so the SDK
+         * demonstrably ran, authenticated and delivered. Yet `sdk_feature_setup_failed` appears zero times
+         * across 2,736 analytics events and 2,317 replay events. The reason is now known: that event only
+         * fires when `setup()` THROWS, and these paths `return`. A failure that returns normally is
+         * indistinguishable from a healthy session that simply had nothing to say.
+         *
+         * Sampling is deliberately NOT reported. It is a legitimate decision rather than a failure, and it
+         * is already recoverable server-side — the bucket is `fnv1a32(sessionId + ':wzb-replay-v1') % 100`,
+         * byte-identical in the backend, so "should this session have recorded" is re-derivable without
+         * spending a single eager byte or trusting the client. Verified against this dataset: `missing`
+         * sessions are spread evenly across all 100 buckets (33 below 50, 31 above), which is what ruled
+         * sampling out as the cause. Calling a sampled-out session a capture failure would also poison the
+         * one metric this event exists to feed.
+         */
+        if (typeof document === 'undefined' || typeof MutationObserver === 'undefined') {
+            ctx.trackEvent(FAIL, { stage: 'init', reason: 'ENV_UNSUPPORTED' });
+            return;
+        }
+        // Deterministic sampling gate (server-reconcilable fnv1a) — decide BEFORE loading the recorder,
+        // so a non-sampled session installs nothing beyond this tiny decision. Statically imported: see
+        // the note on the import.
+        const decision = decideSampling(ctx.replaySampling, ctx.sessionId ?? '');
+        ctx.log('[replay] sampling:', decision.reason, '(bucket', decision.bucket + ')');
+        if (!decision.record)
+            return;
+        // D3 — honor GPC / Do-Not-Track (opt-in via privacy.respectDnt). If the user signalled opt-out,
+        // don't record replay at all. Lazy-imported so it costs nothing unless the host opted in.
+        if (ctx.respectDnt) {
+            const { userOptedOutOfTracking } = await import('./lifecycle/deviceSignals.js');
+            if (userOptedOutOfTracking()) {
+                ctx.log('[replay] dnt: skip');
+                // Not a defect — a respected opt-out. Reported anyway so it lands in the ATTRIBUTED column
+                // instead of the residual; an unexplained gap is what this phase exists to remove.
+                ctx.trackEvent(FAIL, { stage: 'init', reason: 'DNT_OPTED_OUT' });
+                return;
+            }
+        }
+        // P3/D1 cost-aware egress (Save-Data/slow/low-mem → buffer instead of stream) is applied inside the
+        // lazy recorder so it costs zero eager-core bytes.
+        // WebGL replay: force preserveDrawingBuffer as EARLY as possible (must precede the app creating its
+        // WebGL context) so the canvas recorder can snapshot 3D/WebGL canvases instead of capturing blank.
+        // Gated on canvas capture — we only pay the GPU cost for sampled sessions that record canvases.
+        if (ctx.replayCanvas) {
+            const { installWebGLPreserve } = await import('./engine/webglPatch.js');
+            this.uninstallWebGL = installWebGLPreserve();
+        }
+        /**
+         * P3 — ARM WITHOUT BLOCKING THE BOOTSTRAP. Everything below this line is deliberately NOT awaited.
+         *
+         * `SDKBootstrapper.activate()` runs `await registry.setupAll(ctx)` and only then
+         * `await pipeline.start()` — and `setupAll` is a sequential for-loop. So every millisecond replay
+         * spends fetching its recorder chunk is a millisecond before the SESSION IS OPENED. A slow chunk
+         * therefore does not merely lose replay: it loses the whole visit, including analytics, errors and
+         * performance, because nothing has a session to attach to yet.
+         *
+         * MEASURED, Phase 2 browser matrix: with the recorder chunk stalled 6 s, visits of 3 s and 5 s
+         * produced NO SESSION ROW AT ALL — not a session missing replay, no session. At 8 s and 15 s (long
+         * enough to outlast the stall) the same scenario reached PLAYBACK_READY, which is what identifies
+         * the stall as the cause rather than anything about capture itself.
+         *
+         * The `setupAll` ordering it relies on cannot simply be reversed: F-VIT documents a dependency on
+         * setup running before `pipeline.start`. Making replay's own tail non-blocking fixes the defect
+         * without touching that contract or any other feature.
+         *
+         * The cost of not awaiting is that a rejection no longer reaches `FeatureRegistry.setupAll`, which
+         * is what produced `sdk_feature_setup_failed` for replay. `arm()` therefore reports its own failure
+         * with a MORE specific reason than the registry could, so attribution improves rather than
+         * regresses.
+         */
+        this.armed = this.arm(ctx, decision);
+    }
+    /**
+     * Load the recorder and start capturing. Runs detached from `setup()` — see the note above.
+     *
+     * Every failure here is terminal for replay and silent everywhere else, so this method owns its own
+     * reporting: nothing upstream is awaiting it to notice a rejection.
+     */
+    async arm(ctx, decision) {
+        try {
+            await this.load(ctx, decision);
+        }
+        catch (err) {
+            const message = String(err?.message ?? err).slice(0, 300);
+            ctx.trackEvent(FAIL, {
+                stage: 'init',
+                // Separates "the chunk never arrived" (CSP, 404 after a deploy, chunk-hash skew, dropped
+                // request) from "the recorder itself threw" — completely different fixes, and the message is
+                // the only signal the three engines agree on.
+                reason: isModuleLoadFailure(message) ? 'ENGINE_CHUNK_LOAD_FAILED' : 'RECORDER_INIT_FAILED',
+                message,
+            });
+        }
+    }
+    async load(ctx, decision) {
+        /**
+         * R3 — WARM the engine chunks concurrently instead of letting them waterfall.
+         *
+         * Time-to-first-keyframe was five SEQUENTIAL await points: sampling → recorder →
+         * worker+segmentBuffer → the engine modules → iframe → only then `takeSnapshot`. Each is a module
+         * fetch, so on a cold cache the first keyframe waits on a chain of round trips — which is why
+         * sessions under 1s reach only 12% replay coverage while sessions over 30s reach 88%. Nothing is
+         * broken; the recorder simply is not loaded yet when a bouncing visitor leaves.
+         *
+         * These are fire-and-forget: the module registry dedupes, so when `arm()` later awaits the same
+         * specifiers they are already resolved and the waterfall collapses to roughly one round trip.
+         * Deliberately placed AFTER the sampling gate, so a non-sampled session still fetches nothing —
+         * that guarantee is the reason the gate is first, and warming ahead of it would break it.
+         *
+         * `catch` per import: a warm that fails must stay silent. `arm()` awaits these same specifiers and
+         * will surface a genuine failure there; an unhandled rejection here would be noise on a page that
+         * is about to record perfectly well from a retried fetch.
+         */
+        const warm = (p) => { void p.catch(() => { }); };
+        warm(import('../replay/engine/nodeRegistry.js'));
+        warm(import('../replay/engine/snapshot.js'));
+        warm(import('../replay/engine/mutations.js'));
+        warm(import('../replay/engine/interactions.js'));
+        warm(import('../replay/engine/cssom.js'));
+        warm(import('../replay/engine/iframe.js'));
+        warm(import('../replay/engine/replayWorker.js'));
+        warm(import('./lifecycle/segmentBuffer.js'));
+        /**
+         * A3 — retry the recorder import before giving up.
+         *
+         * This one import decides whether the session records at all: everything above it is warming, and
+         * `createRecorder` is what installs the observers. A single transient failure here loses the WHOLE
+         * session's replay while every other lane (events, perf, network — all eager core) keeps working
+         * normally, which is exactly the signature of the 43-of-47 unexplained sessions measured live
+         * (`npm run replay:diagnose`): SDK demonstrably ran, zero frames stored.
+         *
+         * Two attempts, ~400ms apart. Deliberately modest: a chunk that 404s (deploy skew, bad CDN path) will
+         * fail identically on retry, so this only buys back the transient cases — a dropped request, a
+         * network blip, a cold cache under contention. It costs nothing when the first attempt succeeds,
+         * which is the overwhelmingly common path.
+         *
+         * When the retry SUCCEEDS it says so. Without that event a retry is an unfalsifiable fix: coverage
+         * might improve and nobody could tell whether this was why. `sdk_replay_recovered` makes it
+         * measurable, and pairs with the `sdk_replay_capture_failed` its caller emits when the second
+         * attempt fails too, so both outcomes are visible instead of neither.
+         */
+        let createRecorder;
+        try {
+            ({ createRecorder } = await loadRecorder());
+        }
+        catch (first) {
+            await new Promise((r) => setTimeout(r, RECORDER_RETRY_MS));
+            ({ createRecorder } = await loadRecorder()); // a second failure propagates → reported by the registry
+            ctx.trackEvent('sdk_replay_recovered', {
+                stage: 'recorder-import',
+                message: String(first?.message ?? first).slice(0, 300),
+            });
+        }
+        this.controller = await createRecorder(ctx, decision);
+        /**
+         * P1b — the ARMED-BUT-SILENT watchdog. This is the case nothing else can see.
+         *
+         * Every gate above reports by returning or throwing. Once `createRecorder` resolves the feature is
+         * live and, as far as any existing signal is concerned, healthy — so a recorder that attaches and
+         * then never produces a frame (root never resolved, snapshot threw inside an observer callback,
+         * serialization died on a hostile DOM) is invisible on the client AND on the server, because
+         * nothing is ever sent. That is the exact residue this phase has to attribute.
+         *
+         * Tests `captured`, NOT `frames`. `frames` is the segment-buffer occupancy: while streaming, frames
+         * leave the buffer as they ship, so a healthy session reports 0 and an earlier revision of this
+         * watchdog accused every one of them — measured in the Phase 2 browser matrix, `normal` at 5 s, 8 s
+         * and 15 s all reached PLAYBACK_READY while reporting NO_FRAME_AFTER_ARM. A false positive here is
+         * worse than no watchdog: it would fill the attribution table this phase exists to build with
+         * sessions that captured perfectly.
+         *
+         * `recording` is still required: a paused or torn-down recorder has a legitimate reason to hold no
+         * keyframe and must not be accused either.
+         */
+        this.watchdog = setTimeout(() => {
+            const s = this.controller?.stats();
+            if (s?.recording && !s.captured) {
+                ctx.trackEvent(FAIL, {
+                    stage: 'first-frame',
+                    reason: 'NO_FRAME_AFTER_ARM',
+                    // Carried so the server can separate "armed and streaming" from "armed and buffering the
+                    // pre-roll", which is a legitimate zero-frame state under onError mode.
+                    streaming: s.streaming,
+                    bucket: s.sampleBucket,
+                });
+            }
+        }, FIRST_FRAME_WATCHDOG_MS);
+    }
+    /** Capture-on-signal flush (promote pre-roll → live). No-op until a recorder is active. */
+    flush() {
+        this.controller?.flush();
+    }
+    /** Live diagnostics (null when not recording — off, or a non-sampled session). */
+    stats() {
+        return this.controller?.stats() ?? null;
+    }
+    /** Force a re-keyframe (e.g. before a risky flow), so the player gets a clean seek point. */
+    checkpoint(reason = 'manual') {
+        this.controller?.forceCheckpoint(reason);
+    }
+    /** Pause capture (keep the session + buffered pre-roll). No-op until a recorder is active. */
+    pause() {
+        this.controller?.pause();
+    }
+    /** Resume capture after pause() with a fresh keyframe. No-op unless paused. */
+    resume() {
+        this.controller?.resume();
+    }
+    /** Change replay text-masking at runtime (re-keyframes so it applies from here on). */
+    setPrivacy(policy) {
+        this.controller?.setPrivacy(policy);
+    }
+    teardown() {
+        // Before the controller goes: a fired-after-teardown watchdog would read `stats()` as undefined and
+        // report nothing, but the timer would still hold this instance alive until it elapsed.
+        clearTimeout(this.watchdog);
+        this.watchdog = undefined;
+        this.controller?.teardown();
+        this.controller = undefined;
+        this.uninstallWebGL?.();
+        this.uninstallWebGL = undefined;
+    }
+}
+//# sourceMappingURL=ReplayFeature.js.map

package/dist/features/replay/ReplayFeature.js.map

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

package/dist/features/replay/engine/canvas.d.ts

@@ -0,0 +1,45 @@
+/**
+ * CanvasRecorder — opt-in <canvas> pixel capture. The DOM serializer captures a <canvas> element but
+ * not its pixels (they live in a 2D/WebGL context), so canvases replay blank. This throttled loop
+ * snapshots each canvas to a compact image and emits an `op:'canvas'` delta keyed by the node id; the
+ * player draws it back. Off by default (pixels can't be masked) + a per-canvas blocklist.
+ *
+ * Handles BOTH 2D and WebGL/3D canvases: a WebGL canvas would normally read back blank from this async
+ * loop (`preserveDrawingBuffer:false` clears the buffer after compositing), so `webglPatch.ts` forces
+ * `preserveDrawingBuffer:true` at context creation — the same `drawImage`/`toDataURL` path then captures
+ * WebGL pixels unchanged. A tainted (cross-origin texture) canvas still throws → skipped.
+ *
+ * v1 encodes on the main thread (`toDataURL`), bounded by the fps throttle + downscale. Moving the
+ * encode into the RPL-WORKER (OffscreenCanvas.convertToBlob) is a follow-up.
+ */
+import type { Mutation } from './types.js';
+import { NodeRegistry } from './nodeRegistry.js';
+export interface CanvasOptions {
+    fps?: number;
+    maxDim?: number;
+    quality?: number;
+    /** Documents to scan for canvases. Defaults to the top document; the ReplayFeature also passes the
+     *  observed same-origin iframe sub-documents so in-iframe canvases are captured too (A7). */
+    getDocs?: () => Document[];
+}
+export declare class CanvasRecorder {
+    private readonly reg;
+    private readonly onMutations;
+    private readonly log;
+    private timer;
+    private readonly last;
+    private readonly tainted;
+    private readonly intervalMs;
+    private readonly maxDim;
+    private readonly quality;
+    private readonly getDocs?;
+    private scratch;
+    constructor(reg: NodeRegistry, onMutations: (m: Mutation[]) => void, log?: (...a: unknown[]) => void, opts?: CanvasOptions);
+    start(): void;
+    disconnect(): void;
+    private capture;
+    /** Encode to a (possibly downscaled) webp data URL. `w/h` stay the ORIGINAL dims so the player
+     *  redraws at full size. Throws (SecurityError) on a tainted canvas → caller skips. */
+    private encode;
+}
+//# sourceMappingURL=canvas.d.ts.map

package/dist/features/replay/engine/canvas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canvas.d.ts","sourceRoot":"","sources":["../../../../src/features/replay/engine/canvas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C,MAAM,WAAW,aAAa;IAC5B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;iGAC6F;IAC7F,OAAO,CAAC,EAAE,MAAM,QAAQ,EAAE,CAAC;CAC5B;AAID,qBAAa,cAAc;IAWvB,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,GAAG;IAZtB,OAAO,CAAC,KAAK,CAA+C;IAC5D,OAAO,CAAC,QAAQ,CAAC,IAAI,CAA6B;IAClD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqB;IAC7C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAmB;IAC5C,OAAO,CAAC,OAAO,CAAkC;gBAG9B,GAAG,EAAE,YAAY,EACjB,WAAW,EAAE,CAAC,CAAC,EAAE,QAAQ,EAAE,KAAK,IAAI,EACpC,GAAG,GAAE,CAAC,GAAG,CAAC,EAAE,OAAO,EAAE,KAAK,IAAe,EAC1D,IAAI,GAAE,aAAkB;IAQ1B,KAAK,IAAI,IAAI;IAMb,UAAU,IAAI,IAAI;IAQlB,OAAO,CAAC,OAAO;IAkDf;2FACuF;IACvF,OAAO,CAAC,MAAM;CAcf"}