@sailfish-ai/recorder 1.12.4 → 1.12.6

package/dist/canvas-worker.js

@@ -0,0 +1,78 @@
+import { p as e, a as t, r as s, d as n, C as o } from "./chunks/patch2d-PQxcaE6r.js";
+let a = false, r = false, c = null, workerNow = () => Date.now(), f = null;
+let i = null, p = null, d = [], l = [], u = 0, h = 0, y = [];
+function registerWorkerCanvasContext(e2) {
+  c = e2;
+}
+function setWorkerNow(e2) {
+  workerNow = e2;
+}
+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(e2) {
+  if (!p || 0 === p.ops) return;
+  const t2 = p.takeBatch();
+  y.push(n(t2).then((t3) => {
+    d.push({ tMs: e2, bytes: t3.length });
+    const s2 = t3.buffer.slice(t3.byteOffset, t3.byteOffset + t3.byteLength);
+    self.postMessage({ type: "sf-record-batch", deflated: s2, tMs: e2 }, [s2]);
+  }));
+}
+function ensurePatched() {
+  var _a;
+  if (a) return;
+  a = true;
+  const t2 = (_a = globalThis.OffscreenCanvasRenderingContext2D) == null ? void 0 : _a.prototype;
+  t2 && e(t2);
+  const s2 = globalThis.OffscreenCanvas;
+  if (s2) {
+    const e2 = s2.prototype.getContext;
+    s2.prototype.getContext = function(t3, s3) {
+      const n2 = e2.call(this, t3, s3);
+      return "2d" === t3 && n2 && !c && (c = n2), n2;
+    };
+  }
+}
+function attachNow() {
+  if (c && p && (i = t(c, { onOp(e2) {
+    const t2 = performance.now();
+    p.encode(e2), u += performance.now() - t2, e2.t - h >= 1e3 && (flushBatch(e2.t), h = e2.t);
+  }, onAssetBytes(e2, t2, s2) {
+    d.push({ tMs: s2, bytes: t2 });
+  }, note(e2) {
+    l.includes(e2) || l.push(e2);
+  } }, () => workerNow(), "cas", encodeBitmapLocal, { retainAssets: true }), i && (function flagsRequireRedaction(e2) {
+    return !!e2 && (false === e2.recordCreditCardInfo || false === e2.recordSsn || false === e2.recordDob);
+  })(f))) {
+    const e2 = f;
+    i.textRedactor = (t2) => s(t2, e2);
+  }
+}
+function installWorkerRecorder() {
+  r || (r = true, ensurePatched(), self.addEventListener("message", (e2) => {
+    const t2 = e2.data;
+    "sf-record-ping" === (t2 == null ? void 0 : t2.type) ? self.postMessage({ type: "sf-record-pong" }) : "sf-record-start" === (t2 == null ? void 0 : t2.type) ? (function start(e3) {
+      ensurePatched(), f = e3 ?? null, p = new o(), d = [], l = [], u = 0, h = 0, y = [], c ? attachNow() : (l.push("sf-record-start: no OffscreenCanvas 2D context registered yet"), self.postMessage({ type: "sf-record-noctx" }));
+    })(t2.contentFlags) : "sf-record-stop" === (t2 == null ? void 0 : t2.type) && (async function stop() {
+      !i && c && p && attachNow(), flushBatch(workerNow()), await (i == null ? void 0 : i.settle()), await Promise.all(y);
+      const e3 = [], t3 = [];
+      for (const [, s2] of (i == null ? void 0 : i.assets) ?? /* @__PURE__ */ new Map()) {
+        const n2 = { id: s2.id, kind: s2.kind, t: s2.t, bytes: s2.bytes, w: s2.w, h: s2.h };
+        s2.bitmap && (n2.bitmap = s2.bitmap, t3.push(s2.bitmap)), s2.imageData && (n2.imageData = s2.imageData), e3.push(n2);
+      }
+      self.postMessage({ type: "sf-record-done", batches: [], chunks: d, cpuMs: ((i == null ? void 0 : i.cpuMs) ?? 0) + u, notes: l, assets: e3 }, t3), i = null;
+    })();
+  }));
+}
+if ("undefined" != typeof self && "undefined" == typeof window && "undefined" == typeof document && "function" == typeof self.postMessage) try {
+  installWorkerRecorder();
+} catch {
+}
+export {
+  installWorkerRecorder,
+  registerWorkerCanvasContext,
+  setWorkerNow
+};

package/dist/canvasFrameStore.js

@@ -0,0 +1,198 @@
+// canvasFrameStore.ts
+// SSR/Edge-safe IndexedDB persistence for binary canvas SFCV frames.
+//
+// Why this exists: while the recording WebSocket is down, canvas binary frames
+// buffer in a main-thread memory ring (see websocket.tsx) capped at 8 MiB,
+// oldest-dropped — so a long/large offline window silently loses frames, and a
+// page reload drops the whole ring. This module is the durable backstop: every
+// offline frame is also written to IDB (larger at-rest budget, survives reload)
+// and drained in order on reconnect. When IDB is unavailable (SSR, private
+// mode, exotic runtimes) every function is a safe no-op and the caller falls
+// back to the memory ring — i.e. today's behavior, never worse.
+//
+// Mirrors the defensive contract of eventStore.ts: zero top-level `indexedDB`
+// access, fail-closed (treat any error as "unavailable"), 24h at-rest TTL.
+// Uses its OWN database (not leapsEventDB) so the two stores' schema versions
+// can evolve independently without VersionError cross-talk.
+const DB_NAME = "leapsCanvasFrameDB";
+const STORE_NAME = "canvasFrames";
+const DB_VERSION = 1;
+// HIPAA MVP: bound at-rest exposure of buffered canvas pixels. 24h matches
+// eventStore.ts — long offline windows tolerated, not indefinite retention.
+const FRAME_TTL_MS = 24 * 60 * 60 * 1000;
+// At-rest budget. Larger than the 8 MiB in-memory ring (that cap exists to
+// bound *heap*; IDB is disk-backed so it can hold a fuller offline session)
+// but still bounded so a pathological offline window can't fill the origin's
+// quota. Oldest frames are pruned first, matching the ring's semantics.
+const FRAME_STORE_MAX_BYTES = 64 * 1024 * 1024;
+// Cached open promise; never created on SSR.
+let _dbPromise = null;
+function hasIndexedDB() {
+    return typeof globalThis !== "undefined" && !!globalThis.indexedDB;
+}
+function openDb() {
+    if (!hasIndexedDB())
+        return Promise.resolve(null);
+    if (_dbPromise)
+        return _dbPromise;
+    _dbPromise = new Promise((resolve) => {
+        try {
+            const req = globalThis.indexedDB.open(DB_NAME, DB_VERSION);
+            req.onupgradeneeded = () => {
+                const db = req.result;
+                if (!db.objectStoreNames.contains(STORE_NAME)) {
+                    db.createObjectStore(STORE_NAME, { keyPath: "id", autoIncrement: true });
+                }
+            };
+            req.onsuccess = () => resolve(req.result);
+            req.onerror = () => resolve(null); // fail closed → unavailable
+            req.onblocked = () => resolve(null);
+        }
+        catch {
+            resolve(null);
+        }
+    });
+    return _dbPromise;
+}
+function withStore(mode, fn) {
+    return openDb().then((db) => {
+        if (!db)
+            return null;
+        return new Promise((resolve) => {
+            try {
+                const tx = db.transaction(STORE_NAME, mode);
+                const store = tx.objectStore(STORE_NAME);
+                Promise.resolve(fn(store))
+                    .then((result) => {
+                    tx.oncomplete = () => resolve(result);
+                    tx.onerror = () => resolve(null);
+                })
+                    .catch(() => resolve(null));
+            }
+            catch {
+                resolve(null);
+            }
+        });
+    });
+}
+// ── Public API (SSR-safe) ──────────────────────────────────────────────────
+/**
+ * Persist one binary canvas frame. Returns true if the frame was durably
+ * written, false if IDB is unavailable (caller should keep the memory-ring
+ * fallback). After a successful add, prunes oldest frames so the store stays
+ * under FRAME_STORE_MAX_BYTES.
+ */
+export async function persistCanvasFrame(buf) {
+    const ok = await withStore("readwrite", (store) => {
+        store.add({ timestamp: Date.now(), bytes: buf.byteLength, buf });
+        return true;
+    });
+    if (ok)
+        void pruneToBudget().catch(() => { });
+    return ok === true;
+}
+/**
+ * Read all persisted frames in insertion order (ascending id), dropping any
+ * past the TTL and scheduling their background deletion. The returned `buf`s
+ * are ready to hand straight to the WS binary send path.
+ */
+export async function readAllCanvasFrames() {
+    const result = await withStore("readonly", (store) => {
+        return new Promise((resolve) => {
+            const req = store.getAll();
+            req.onsuccess = () => resolve(req.result);
+            req.onerror = () => resolve([]);
+        });
+    });
+    const all = result ?? [];
+    const now = Date.now();
+    const fresh = [];
+    const staleIds = [];
+    for (const f of all) {
+        if (typeof f?.timestamp === "number" && now - f.timestamp >= FRAME_TTL_MS) {
+            if (typeof f.id === "number")
+                staleIds.push(f.id);
+        }
+        else {
+            fresh.push(f);
+        }
+    }
+    if (staleIds.length > 0)
+        void deleteCanvasFramesByIds(staleIds).catch(() => { });
+    // getAll returns ascending key order, but be explicit — flush order is
+    // capture order, which matters for command-stream replay.
+    fresh.sort((a, b) => (a.id ?? 0) - (b.id ?? 0));
+    return fresh;
+}
+export async function deleteCanvasFramesByIds(ids) {
+    if (ids.length === 0)
+        return;
+    await withStore("readwrite", (store) => {
+        for (const id of ids)
+            store.delete(id);
+    });
+}
+export async function clearCanvasFrames() {
+    await withStore("readwrite", (store) => {
+        store.clear();
+    });
+}
+/** Diagnostics: total bytes currently persisted (0 when IDB unavailable). */
+export async function countPersistedCanvasFrameBytes() {
+    const total = await withStore("readonly", (store) => {
+        return new Promise((resolve) => {
+            let sum = 0;
+            const req = store.openCursor();
+            req.onsuccess = () => {
+                const cursor = req.result;
+                if (!cursor)
+                    return resolve(sum);
+                const v = cursor.value;
+                sum += typeof v?.bytes === "number" ? v.bytes : 0;
+                cursor.continue();
+            };
+            req.onerror = () => resolve(sum);
+        });
+    });
+    return total ?? 0;
+}
+/**
+ * Prune oldest frames (lowest id first) until the store is within
+ * FRAME_STORE_MAX_BYTES. Single readwrite cursor pass; best-effort.
+ */
+async function pruneToBudget() {
+    await withStore("readwrite", (store) => {
+        return new Promise((resolve) => {
+            // First total the bytes, then delete from the front until under budget.
+            // A single forward cursor does both: sum, and once we know the overage
+            // we can't "go back", so do it in two cursor passes within the same tx.
+            let total = 0;
+            const sizes = [];
+            const countReq = store.openCursor();
+            countReq.onsuccess = () => {
+                const c = countReq.result;
+                if (c) {
+                    const v = c.value;
+                    const bytes = typeof v?.bytes === "number" ? v.bytes : 0;
+                    total += bytes;
+                    if (typeof v?.id === "number")
+                        sizes.push({ id: v.id, bytes });
+                    c.continue();
+                    return;
+                }
+                // Cursor exhausted — delete oldest until under budget.
+                let over = total - FRAME_STORE_MAX_BYTES;
+                if (over <= 0)
+                    return resolve();
+                for (const s of sizes) {
+                    if (over <= 0)
+                        break;
+                    store.delete(s.id);
+                    over -= s.bytes;
+                }
+                resolve();
+            };
+            countReq.onerror = () => resolve();
+        });
+    });
+}