@sailfish-ai/recorder 1.12.5 → 1.12.7

package/dist/canvas/videoCapture.js

@@ -0,0 +1,252 @@
+/**
+ * WebCodecs video capture, attach side — port of the bench webcodecs strategy
+ * (test-applications/canvas-recorder-bench/src/capture/webcodecs.ts).
+ * Frames are grabbed IN-TASK with the render (the manager's microtask pump
+ * provides the afterRender hook) — the only way to read
+ * preserveDrawingBuffer:false WebGL and task-scoped WebGPU textures without
+ * buffer-forcing hacks. Adaptive fps + interaction-forced keyframes; the
+ * encoder runs in an inline-blob worker; frames travel as transferred
+ * VideoFrames; encoded chunks stream back live for SFCV video-chunk frames.
+ *
+ * `intervalPaced` mode covers worker-rendered placeholder canvases that have
+ * no draw hooks: the placeholder's COMMITTED frame persists like an image
+ * (no task-scoped readback hazard), so a timer-paced grab is safe there.
+ */
+import { VideoEncoderClient } from "./encodeWorker";
+const BASE_FPS = 20;
+const BOOST_FPS = 30;
+/** boost window after an interaction */
+const BOOST_MS = 1_500;
+const KEYFRAME_EVERY_MS = 2_000;
+// Encoder bitrate is per-second (size barely depends on fps) — higher fps
+// cuts replay staleness for moving scenes at near-zero size cost.
+const BITRATE = 1_800_000;
+export class VideoCapture {
+    canvas;
+    now;
+    out;
+    opts;
+    client = null;
+    configured = false;
+    failed = false;
+    stopped = false;
+    lastFrame = -Infinity;
+    lastKey = -Infinity;
+    boostUntil = -Infinity;
+    configuredW = 0;
+    configuredH = 0;
+    intervalId = null;
+    /** A11: dedupe the "throttled" note to once per saturation episode */
+    throttledNoted = false;
+    /** A24: an encoder restart at the new canvas size is in flight */
+    restarting = false;
+    /** A24: force the next captured frame to a keyframe (after a restart) */
+    forceKeyNext = false;
+    static supported() {
+        return typeof VideoEncoder === "function" && typeof VideoFrame === "function";
+    }
+    constructor(canvas, now, out, opts) {
+        this.canvas = canvas;
+        this.now = now;
+        this.out = out;
+        this.opts = opts;
+    }
+    /** Resolves true when the encoder configured; false -> keyframes-only fallback. */
+    async start() {
+        if (!VideoCapture.supported()) {
+            this.failed = true;
+            this.out.note("no WebCodecs — video capture unavailable");
+            return false;
+        }
+        const w = this.canvas.width;
+        const h = this.canvas.height;
+        if (!w || !h) {
+            this.failed = true;
+            this.out.note("zero-size canvas — video capture unavailable");
+            return false;
+        }
+        this.client = new VideoEncoderClient({
+            onDecoderConfig: (codec, description) => this.out.onInit(codec, description),
+            onChunk: (data, timestampUs, key) => this.out.onChunk(key, timestampUs, data),
+            onError: (m) => this.out.note(m),
+        });
+        const ok = await this.client.configure({
+            width: w,
+            height: h,
+            bitrate: BITRATE,
+            codecs: ["avc1.42001f", "vp8", "vp09.00.10.08"],
+        });
+        if (!ok) {
+            this.failed = true;
+            this.out.note("no supported video codec");
+            this.client.terminate();
+            this.client = null;
+            return false;
+        }
+        this.configured = true;
+        this.configuredW = w;
+        this.configuredH = h;
+        if (this.opts?.intervalPaced) {
+            this.intervalId = setInterval(() => this.afterRender(this.now()), 1000 / BASE_FPS);
+        }
+        return true;
+    }
+    onInteraction(tMs) {
+        this.boostUntil = tMs + BOOST_MS;
+        this.lastKey = -Infinity; // force keyframe on next captured frame
+    }
+    /** Same-task capture: invoked by the manager's microtask pump right after
+     * the scene rendered. Dirty-by-construction — only called when a frame was
+     * drawn (or on the interval for placeholder canvases). */
+    afterRender(t) {
+        if (!this.configured || this.failed || this.stopped || !this.client)
+            return;
+        // A11 backpressure: the encoder can outpace a slow-but-open socket, growing
+        // WebSocket.bufferedAmount without bound. While the transport is saturated,
+        // SKIP producing a new VideoFrame entirely (no encode, no send). lastFrame/
+        // lastKey are left untouched so that as soon as the buffer drains, the next
+        // render produces a frame and the keyframe spacing logic re-keys naturally.
+        // Never blocks: this is a single cached-number check.
+        if (this.out.isTransportSaturated?.()) {
+            if (!this.throttledNoted) {
+                this.throttledNoted = true;
+                this.out.note("transport saturated — video frames throttled");
+            }
+            return;
+        }
+        this.throttledNoted = false;
+        if (this.canvas.width !== this.configuredW || this.canvas.height !== this.configuredH) {
+            // A24: the canvas was resized mid-stream. The encoder is locked to its
+            // configured dimensions, so instead of silently dropping every later
+            // frame (the old behavior — replay froze at the resize), restart the
+            // encoder at the new size. The restart is async; skip frames until it
+            // completes, then the next frame is forced to a keyframe.
+            this.requestRestart();
+            return;
+        }
+        const fps = t < this.boostUntil ? BOOST_FPS : BASE_FPS;
+        if (t - this.lastFrame < 1000 / fps)
+            return;
+        this.lastFrame = t;
+        // First frame after a successful restart forces a keyframe so the new-size
+        // stream is independently decodable from its start.
+        const forceKey = this.forceKeyNext;
+        this.forceKeyNext = false;
+        const key = forceKey || t - this.lastKey >= KEYFRAME_EVERY_MS;
+        if (key)
+            this.lastKey = t;
+        try {
+            // t is epoch ms; chunk timestamps therefore land in epoch µs
+            // (contract §1's clock, µs units for WebCodecs).
+            const frame = new VideoFrame(this.canvas, { timestamp: Math.round(t * 1000) });
+            this.client.encodeFrame(frame, key);
+        }
+        catch (e) {
+            this.out.note(String(e));
+        }
+    }
+    /**
+     * A24: restart the encoder at the canvas's current dimensions after a
+     * mid-stream resize. The old encoder is torn down (its locked-size frames are
+     * no longer valid) and a fresh one is configured for the new size; the new
+     * encoder's first chunk re-emits the decoder config (onInit) so the player
+     * re-initializes, and the next captured frame is forced to a keyframe. Skips
+     * if already restarting, stopped, or the new size is zero.
+     */
+    requestRestart() {
+        if (this.restarting || this.stopped)
+            return;
+        const w = this.canvas.width;
+        const h = this.canvas.height;
+        if (!w || !h)
+            return; // transient zero-size during resize — wait
+        this.restarting = true;
+        const oldClient = this.client;
+        this.client = null; // pause frame production until reconfigured
+        this.configured = false;
+        this.out.note(`canvas resized to ${w}x${h} during video capture — restarting encoder`);
+        void (async () => {
+            try {
+                if (oldClient) {
+                    try {
+                        oldClient.terminate();
+                    }
+                    catch { /* already gone */ }
+                }
+                if (this.stopped)
+                    return;
+                const client = new VideoEncoderClient({
+                    onDecoderConfig: (codec, description) => this.out.onInit(codec, description),
+                    onChunk: (data, timestampUs, key) => this.out.onChunk(key, timestampUs, data),
+                    onError: (m) => this.out.note(m),
+                });
+                const ok = await client.configure({
+                    width: w,
+                    height: h,
+                    bitrate: BITRATE,
+                    codecs: ["avc1.42001f", "vp8", "vp09.00.10.08"],
+                });
+                if (this.stopped || !ok) {
+                    client.terminate();
+                    if (!ok)
+                        this.out.note("encoder restart failed after resize — frames dropped until next resize");
+                    return;
+                }
+                this.client = client;
+                this.configuredW = w;
+                this.configuredH = h;
+                this.configured = true;
+                this.forceKeyNext = true;
+                // reset pacing so the very next render produces the keyframe
+                this.lastFrame = -Infinity;
+                this.lastKey = -Infinity;
+            }
+            finally {
+                this.restarting = false;
+            }
+        })();
+    }
+    /** Non-terminal drain (visibilitychange:hidden on mobile, where the OS may
+     * kill the tab without a reliable pagehide): push the encoder's queued frames
+     * out as chunks WITHOUT tearing down, so capture resumes if the tab returns.
+     * No-op once stopped. */
+    async flush() {
+        if (this.stopped || !this.client)
+            return;
+        await this.client.flush();
+    }
+    /**
+     * A22 / A6 / A10: immediate teardown WITHOUT flushing — used when the canvas
+     * was removed from the DOM, masked mid-session, or its GPU context was lost.
+     * Flushing would emit chunks for content that is gone/garbage, so we just
+     * terminate the encoder worker and stop. Idempotent.
+     */
+    abort() {
+        if (this.stopped)
+            return;
+        this.stopped = true;
+        if (this.intervalId != null) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+        }
+        if (this.client) {
+            this.client.terminate();
+            this.client = null;
+        }
+    }
+    /** Flush the encoder (remaining chunks stream through onChunk) and tear down. */
+    async stop() {
+        if (this.stopped)
+            return;
+        this.stopped = true;
+        if (this.intervalId != null) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+        }
+        if (this.client) {
+            await this.client.stop();
+            this.client.terminate();
+            this.client = null;
+        }
+    }
+}

package/dist/canvas/workerRelay.js

@@ -0,0 +1,99 @@
+/**
+ * Main-thread registry for canvases whose control was transferred to a
+ * worker, plus the AUTO-ASSOCIATION patches the bench left to the build
+ * plugin (contract §5):
+ *
+ *  - HTMLCanvasElement.prototype.transferControlToOffscreen is patched to
+ *    remember which OffscreenCanvas came from which canvas element.
+ *  - Worker.prototype.postMessage is patched to map canvas -> worker when an
+ *    OffscreenCanvas from a tracked canvas appears in the transfer list.
+ *
+ * Worker-side recording additionally requires the customer to import
+ * `@sailfish-ai/recorder/canvas-worker` in the worker (the shim). The
+ * manager pings the worker (sf-record-ping/pong) to detect the shim; absent
+ * a pong, the canvas falls back to video capture of the placeholder.
+ *
+ * SSR rule: nothing here touches window/document at module scope — patches
+ * install inside installWorkerRelay().
+ */
+const offscreenToCanvas = new WeakMap();
+const registry = new Map();
+let installed = false;
+let onAssociation = null;
+/** Manager subscription: fires when a canvas->worker link is discovered. */
+export function setWorkerAssociationNotifier(fn) {
+    onAssociation = fn;
+}
+export function installWorkerRelay() {
+    if (installed)
+        return;
+    installed = true;
+    if (typeof HTMLCanvasElement !== "undefined" &&
+        typeof HTMLCanvasElement.prototype.transferControlToOffscreen === "function") {
+        const orig = HTMLCanvasElement.prototype.transferControlToOffscreen;
+        HTMLCanvasElement.prototype.transferControlToOffscreen = function () {
+            const off = orig.call(this);
+            offscreenToCanvas.set(off, this);
+            return off;
+        };
+    }
+    if (typeof Worker !== "undefined") {
+        const origPost = Worker.prototype.postMessage;
+        Worker.prototype.postMessage = function (message, transferOrOptions) {
+            const transfer = Array.isArray(transferOrOptions)
+                ? transferOrOptions
+                : transferOrOptions?.transfer;
+            if (transfer) {
+                for (const t of transfer) {
+                    const canvas = t && typeof t === "object"
+                        ? offscreenToCanvas.get(t)
+                        : undefined;
+                    if (canvas && !registry.has(canvas)) {
+                        registry.set(canvas, this);
+                        onAssociation?.(canvas, this);
+                    }
+                }
+            }
+            return origPost.apply(this, [message, transferOrOptions]);
+        };
+    }
+}
+export function registerWorkerCanvas(canvas, worker) {
+    registry.set(canvas, worker);
+    onAssociation?.(canvas, worker);
+}
+export function getWorkerForCanvas(canvas) {
+    return registry.get(canvas);
+}
+export function unregisterWorkerCanvas(canvas) {
+    registry.delete(canvas);
+}
+/**
+ * Detect the worker-side shim: resolves true iff the worker answers
+ * sf-record-ping with sf-record-pong within `timeoutMs`.
+ */
+export function pingWorkerShim(worker, timeoutMs = 500) {
+    return new Promise((resolve) => {
+        let settled = false;
+        const finish = (ok) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(tid);
+            worker.removeEventListener("message", onMsg);
+            resolve(ok);
+        };
+        const onMsg = (e) => {
+            if (e.data?.type === "sf-record-pong")
+                finish(true);
+        };
+        const tid = setTimeout(() => finish(false), timeoutMs);
+        worker.addEventListener("message", onMsg);
+        try {
+            worker.postMessage({ type: "sf-record-ping" });
+        }
+        catch {
+            finish(false);
+        }
+    });
+}

package/dist/canvas/workerShim.js

@@ -0,0 +1,227 @@
+/**
+ * Worker-side 2D command recorder — port of the bench tier-2 worker module
+ * (test-applications/canvas-recorder-bench/src/capture/workerRecorder.ts).
+ * Customers import this as `@sailfish-ai/recorder/canvas-worker` inside any
+ * worker that renders to a transferred OffscreenCanvas (a later build plugin
+ * will inject it automatically). It patches
+ * OffscreenCanvasRenderingContext2D, records the command stream with the
+ * shared binary codec, and relays batches/assets/sizes to the main thread on
+ * demand.
+ *
+ * Message protocol (main -> worker):
+ *   {type:'sf-record-ping'}  -> {type:'sf-record-pong'}   (shim detection)
+ *   {type:'sf-record-start'} / {type:'sf-record-stop'}
+ * Worker -> main:
+ *   {type:'sf-record-done', batches, chunks, cpuMs, notes, assets}
+ *
+ * SDK adaptations: the recorder clock defaults to epoch ms (contract §1 —
+ * setWorkerNow remains available for custom clocks); the OffscreenCanvas
+ * getContext is patched so the rendered context registers itself (the bench
+ * required an explicit registerWorkerCanvasContext call); the module
+ * auto-installs when imported inside a worker scope. Only ONE OffscreenCanvas
+ * per worker is recorded in this increment (bench behavior).
+ */
+import { attachRecorderToContext, patch2DProto, } from "./patch2d";
+import { CommandEncoder, deflate } from "./codec";
+import { redactSensitiveContent } from "./piiDetect";
+let patched = false;
+let installedListener = false;
+let registeredCtx = null;
+/** recorder clock — epoch ms by default (contract §1, rrweb-aligned) */
+let workerNow = () => Date.now();
+// A13: content-detection flags pushed in by the main thread at sf-record-start.
+// A worker/OffscreenCanvas serializes its own commands with no DOM, so the main
+// thread can only forward the data-sensitivity flags; selector-based suppression
+// (block/maskText) is decided main-thread BEFORE the worker is started, so
+// any worker that reaches here is "normal" mode and only needs CC/SSN/DOB
+// content redaction on its drawn-text args.
+let contentFlags = null;
+/** True when at least one record* flag is explicitly false (redaction needed). */
+function flagsRequireRedaction(f) {
+    return (!!f &&
+        (f.recordCreditCardInfo === false ||
+            f.recordSsn === false ||
+            f.recordDob === false));
+}
+let recorder = null;
+let encoder = null;
+let rawBatches = [];
+let chunks = [];
+let notes = [];
+let encodeCpu = 0;
+let batchStart = 0;
+let pending = [];
+/** Optional: explicitly register the OffscreenCanvas 2D context to record
+ * (the getContext patch normally does this automatically). */
+export function registerWorkerCanvasContext(ctx) {
+    registeredCtx = ctx;
+}
+/** Optional: keep the recorder clock in sync with a custom render time. */
+export function setWorkerNow(now) {
+    workerNow = now;
+}
+async function encodeBitmapLocal(bitmap) {
+    const off = new OffscreenCanvas(bitmap.width, bitmap.height);
+    off.getContext("2d").drawImage(bitmap, 0, 0);
+    bitmap.close();
+    const blob = await off.convertToBlob({ type: "image/webp", quality: 0.85 });
+    return { size: blob.size };
+}
+function flushBatch(t) {
+    if (!encoder || encoder.ops === 0)
+        return;
+    const raw = encoder.takeBatch();
+    // STREAM batches live (Phase 0.5 E2E fix): the bench protocol accumulated
+    // until sf-record-stop, which meant a live session produced ZERO frames
+    // until teardown — and none at all if the page never cleanly stopped.
+    // Each ~1s batch is deflated and posted immediately; sf-record-done now
+    // carries only assets/notes/cpu (batches: [] kept for shape compat).
+    pending.push(deflate(raw).then((z) => {
+        chunks.push({ tMs: t, bytes: z.length });
+        const buf = z.buffer.slice(z.byteOffset, z.byteOffset + z.byteLength);
+        self.postMessage({ type: "sf-record-batch", deflated: buf, tMs: t }, [buf]);
+    }));
+}
+function ensurePatched() {
+    if (patched)
+        return;
+    patched = true;
+    const proto = globalThis
+        .OffscreenCanvasRenderingContext2D?.prototype;
+    if (proto)
+        patch2DProto(proto);
+    // Auto-register: the first OffscreenCanvas 2D context created in this
+    // worker becomes the recorded context (bench required an explicit call).
+    const OffscreenCtor = globalThis.OffscreenCanvas;
+    if (OffscreenCtor) {
+        const origGetContext = OffscreenCtor.prototype.getContext;
+        OffscreenCtor.prototype.getContext = function (type, attrs) {
+            const result = origGetContext.call(this, type, attrs);
+            if (type === "2d" && result && !registeredCtx) {
+                registeredCtx = result;
+            }
+            return result;
+        };
+    }
+}
+function start(flags) {
+    ensurePatched();
+    contentFlags = flags ?? null;
+    encoder = new CommandEncoder();
+    rawBatches = [];
+    chunks = [];
+    notes = [];
+    encodeCpu = 0;
+    batchStart = 0;
+    pending = [];
+    if (registeredCtx) {
+        attachNow();
+    }
+    else {
+        // No 2D OffscreenCanvas context in this worker (e.g. it renders WebGL —
+        // the shim records 2D only). Tell the main thread so it can fall back to
+        // video capture of the placeholder instead of waiting on command batches
+        // that will never come. Recording stays armed: if a 2D context appears
+        // later the getContext patch registers it and stop() captures the tail.
+        notes.push("sf-record-start: no OffscreenCanvas 2D context registered yet");
+        self.postMessage({ type: "sf-record-noctx" });
+    }
+}
+function attachNow() {
+    if (!registeredCtx || !encoder)
+        return;
+    recorder = attachRecorderToContext(registeredCtx, {
+        onOp(op) {
+            const t0 = performance.now();
+            encoder.encode(op);
+            encodeCpu += performance.now() - t0;
+            if (op.t - batchStart >= 1000) {
+                flushBatch(op.t);
+                batchStart = op.t;
+            }
+        },
+        onAssetBytes(_id, bytes, t) {
+            chunks.push({ tMs: t, bytes });
+        },
+        note(m) { if (!notes.includes(m))
+            notes.push(m); },
+    }, () => workerNow(), "cas", encodeBitmapLocal, { retainAssets: true });
+    // A13: normal-mode worker canvases still get content-detection redaction of
+    // drawn-text args (CC/SSN/DOB) when the account opts those types out. Selector
+    // suppression (block/maskText) was already decided main-thread, so the
+    // worker only needs the content layer. Skip installing the redactor entirely
+    // when no flag requires it (keeps the hot path allocation-free).
+    if (recorder && flagsRequireRedaction(contentFlags)) {
+        const flags = contentFlags;
+        recorder.textRedactor = (t) => redactSensitiveContent(t, flags);
+    }
+}
+async function stop() {
+    // Late registration (context created after start): attach so at least the
+    // tail is captured; common case is attach-at-start.
+    if (!recorder && registeredCtx && encoder)
+        attachNow();
+    flushBatch(workerNow());
+    await recorder?.settle();
+    await Promise.all(pending);
+    const assets = [];
+    const transfers = [];
+    for (const [, a] of recorder?.assets ?? new Map()) {
+        const wire = { id: a.id, kind: a.kind, t: a.t, bytes: a.bytes, w: a.w, h: a.h };
+        if (a.bitmap) {
+            wire.bitmap = a.bitmap;
+            transfers.push(a.bitmap);
+        }
+        if (a.imageData)
+            wire.imageData = a.imageData;
+        assets.push(wire);
+    }
+    self.postMessage({
+        type: "sf-record-done",
+        batches: [],
+        chunks,
+        cpuMs: (recorder?.cpuMs ?? 0) + encodeCpu,
+        notes,
+        assets,
+    }, transfers);
+    recorder = null;
+}
+/** Install the relay message listener (call once at worker startup —
+ * importing this module inside a worker does it automatically). */
+export function installWorkerRecorder() {
+    if (installedListener)
+        return;
+    installedListener = true;
+    // BUGFIX (Phase 0.5 E2E, found on /worker-2d): patch getContext AT INSTALL,
+    // not lazily at sf-record-start. The worker handles the app's init message
+    // (creating its OffscreenCanvas 2D context) BEFORE the main thread's
+    // shim-ping/record-start round trip arrives — a lazily-installed patch
+    // missed the registration, the recorder never attached, and the canvas
+    // recorded zero ops. installWorkerRecorder only runs inside worker scopes
+    // (auto-install below is guarded), so this stays SSR/main-thread safe.
+    ensurePatched();
+    self.addEventListener("message", (e) => {
+        const msg = e.data;
+        if (msg?.type === "sf-record-ping") {
+            self.postMessage({ type: "sf-record-pong" });
+        }
+        else if (msg?.type === "sf-record-start") {
+            start(msg.contentFlags);
+        }
+        else if (msg?.type === "sf-record-stop")
+            void stop();
+    });
+}
+// Auto-install when imported inside a (dedicated) worker scope. The guards
+// keep this module side-effect-free on the main thread and under SSR.
+if (typeof self !== "undefined" &&
+    typeof window === "undefined" &&
+    typeof document === "undefined" &&
+    typeof self.postMessage === "function") {
+    try {
+        installWorkerRecorder();
+    }
+    catch {
+        /* never break the host worker */
+    }
+}

package/dist/canvas-worker.cjs

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const e = require("./chunks/patch2d-9voowhJ_.js");
+let t = false, s = false, n = null, workerNow = () => Date.now(), o = null;
+let r = null, a = null, c = [], i = [], f = 0, d = 0, l = [];
+async function encodeBitmapLocal(e2) {
+  const t2 = new OffscreenCanvas(e2.width, e2.height);
+  t2.getContext("2d").drawImage(e2, 0, 0), e2.close();
+  return { size: (await t2.convertToBlob({ type: "image/webp", quality: 0.85 })).size };
+}
+function flushBatch(t2) {
+  if (!a || 0 === a.ops) return;
+  const s2 = a.takeBatch();
+  l.push(e.deflate(s2).then((e2) => {
+    c.push({ tMs: t2, bytes: e2.length });
+    const s3 = e2.buffer.slice(e2.byteOffset, e2.byteOffset + e2.byteLength);
+    self.postMessage({ type: "sf-record-batch", deflated: s3, tMs: t2 }, [s3]);
+  }));
+}
+function ensurePatched() {
+  var _a;
+  if (t) return;
+  t = true;
+  const s2 = (_a = globalThis.OffscreenCanvasRenderingContext2D) == null ? void 0 : _a.prototype;
+  s2 && e.patch2DProto(s2);
+  const o2 = globalThis.OffscreenCanvas;
+  if (o2) {
+    const e2 = o2.prototype.getContext;
+    o2.prototype.getContext = function(t2, s3) {
+      const o3 = e2.call(this, t2, s3);
+      return "2d" === t2 && o3 && !n && (n = o3), o3;
+    };
+  }
+}
+function attachNow() {
+  if (n && a && (r = e.attachRecorderToContext(n, { onOp(e2) {
+    const t2 = performance.now();
+    a.encode(e2), f += performance.now() - t2, e2.t - d >= 1e3 && (flushBatch(e2.t), d = e2.t);
+  }, onAssetBytes(e2, t2, s2) {
+    c.push({ tMs: s2, bytes: t2 });
+  }, note(e2) {
+    i.includes(e2) || i.push(e2);
+  } }, () => workerNow(), "cas", encodeBitmapLocal, { retainAssets: true }), r && (function flagsRequireRedaction(e2) {
+    return !!e2 && (false === e2.recordCreditCardInfo || false === e2.recordSsn || false === e2.recordDob);
+  })(o))) {
+    const t2 = o;
+    r.textRedactor = (s2) => e.redactSensitiveContent(s2, t2);
+  }
+}
+function installWorkerRecorder() {
+  s || (s = true, ensurePatched(), self.addEventListener("message", (t2) => {
+    const s2 = t2.data;
+    "sf-record-ping" === (s2 == null ? void 0 : s2.type) ? self.postMessage({ type: "sf-record-pong" }) : "sf-record-start" === (s2 == null ? void 0 : s2.type) ? (function start(t3) {
+      ensurePatched(), o = t3 ?? null, a = new e.CommandEncoder(), c = [], i = [], f = 0, d = 0, l = [], n ? attachNow() : (i.push("sf-record-start: no OffscreenCanvas 2D context registered yet"), self.postMessage({ type: "sf-record-noctx" }));
+    })(s2.contentFlags) : "sf-record-stop" === (s2 == null ? void 0 : s2.type) && (async function stop() {
+      !r && n && a && attachNow(), flushBatch(workerNow()), await (r == null ? void 0 : r.settle()), await Promise.all(l);
+      const e2 = [], t3 = [];
+      for (const [, s3] of (r == null ? void 0 : r.assets) ?? /* @__PURE__ */ new Map()) {
+        const n2 = { id: s3.id, kind: s3.kind, t: s3.t, bytes: s3.bytes, w: s3.w, h: s3.h };
+        s3.bitmap && (n2.bitmap = s3.bitmap, t3.push(s3.bitmap)), s3.imageData && (n2.imageData = s3.imageData), e2.push(n2);
+      }
+      self.postMessage({ type: "sf-record-done", batches: [], chunks: c, cpuMs: ((r == null ? void 0 : r.cpuMs) ?? 0) + f, notes: i, assets: e2 }, t3), r = null;
+    })();
+  }));
+}
+if ("undefined" != typeof self && "undefined" == typeof window && "undefined" == typeof document && "function" == typeof self.postMessage) try {
+  installWorkerRecorder();
+} catch {
+}
+exports.installWorkerRecorder = installWorkerRecorder, exports.registerWorkerCanvasContext = function registerWorkerCanvasContext(e2) {
+  n = e2;
+}, exports.setWorkerNow = function setWorkerNow(e2) {
+  workerNow = e2;
+};