@sailfish-ai/recorder 1.12.4 → 1.12.6

package/dist/chunks/canvasManager-CoX5072G.js

@@ -0,0 +1,1456 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { i as e, u as t } from "./index-DIYomvdD.js";
+import { k as n, R as r, B as o, o as s, d as a, D as i, q as c, s as d, T as l, i as u, t as f, u as h, v as p, w as m, x as v, y, C as g, z as w, A as k, E as b, F as C, G as x, H as S, I as R, J as L, K as M, L as I, M as T, a as E } from "./patch2d-PQxcaE6r.js";
+function createBlobWorker(e2) {
+  const t2 = new Blob([e2], { type: "application/javascript" }), n2 = URL.createObjectURL(t2), r2 = new Worker(n2);
+  return URL.revokeObjectURL(n2), r2;
+}
+let P = null, D = 1;
+const B = /* @__PURE__ */ new Map();
+function encodeBitmap(e2, t2, n2 = false) {
+  const r2 = D++;
+  return new Promise((o2) => {
+    B.set(r2, o2), (function getImgWorker() {
+      return P || (P = createBlobWorker("\nself.onmessage = async (e) => {\n  const { id, bitmap, quality, wantBytes } = e.data;\n  try {\n    const off = new OffscreenCanvas(bitmap.width, bitmap.height);\n    const ctx = off.getContext('2d');\n    ctx.drawImage(bitmap, 0, 0);\n    bitmap.close();\n    const blob = await off.convertToBlob({ type: 'image/webp', quality });\n    if (wantBytes) {\n      const buf = await blob.arrayBuffer();\n      self.postMessage({ id, size: buf.byteLength, bytes: buf }, [buf]);\n    } else {\n      self.postMessage({ id, size: blob.size });\n    }\n  } catch (err) {\n    self.postMessage({ id, size: 0, error: String(err) });\n  }\n};\n"), P.onmessage = (e3) => {
+        const t3 = B.get(e3.data.id);
+        t3 && (B.delete(e3.data.id), t3({ size: e3.data.size, bytes: e3.data.bytes }));
+      }), P;
+    })().postMessage({ id: r2, bitmap: e2, quality: t2, wantBytes: n2 }, [e2]);
+  });
+}
+class VideoEncoderClient {
+  constructor(e2) {
+    __publicField(this, "worker");
+    __publicField(this, "configured", false);
+    __publicField(this, "doneResolve", null);
+    __publicField(this, "flushResolve", null);
+    __publicField(this, "configResolve", null);
+    this.events = e2, this.worker = createBlobWorker("\nlet encoder = null;\nlet decoderConfig = null;\nlet sentConfig = false;\n\nasync function pickCodec(codecs, width, height, bitrate) {\n  for (const codec of codecs) {\n    try {\n      const support = await VideoEncoder.isConfigSupported({\n        codec, width, height, bitrate, framerate: 30,\n        ...(codec.startsWith('avc1') ? { avc: { format: 'avc' } } : {}),\n      });\n      if (support.supported) return codec;\n    } catch (e) { /* try next */ }\n  }\n  return null;\n}\n\nself.onmessage = async (e) => {\n  const msg = e.data;\n  if (msg.type === 'config') {\n    const codec = await pickCodec(msg.codecs, msg.width, msg.height, msg.bitrate);\n    if (!codec) {\n      self.postMessage({ type: 'config-failed' });\n      return;\n    }\n    encoder = new VideoEncoder({\n      output: (chunk, meta) => {\n        if (meta && meta.decoderConfig && !decoderConfig) {\n          const desc = meta.decoderConfig.description;\n          decoderConfig = {\n            codec: meta.decoderConfig.codec,\n            description: desc\n              ? (desc instanceof ArrayBuffer\n                  ? desc.slice(0)\n                  : desc.buffer.slice(desc.byteOffset, desc.byteOffset + desc.byteLength))\n              : null,\n          };\n        }\n        if (decoderConfig && !sentConfig) {\n          sentConfig = true;\n          self.postMessage({\n            type: 'decoder-config',\n            codec: decoderConfig.codec,\n            description: decoderConfig.description,\n          });\n        }\n        const data = new ArrayBuffer(chunk.byteLength);\n        chunk.copyTo(data);\n        self.postMessage({\n          type: 'chunk',\n          data,\n          timestampUs: chunk.timestamp,\n          key: chunk.type === 'key',\n        }, [data]);\n      },\n      error: (err) => self.postMessage({ type: 'error', message: String(err) }),\n    });\n    encoder.configure({\n      codec,\n      width: msg.width,\n      height: msg.height,\n      bitrate: msg.bitrate,\n      framerate: 30,\n      latencyMode: 'realtime',\n      ...(codec.startsWith('avc1') ? { avc: { format: 'avc' } } : {}),\n    });\n    self.postMessage({ type: 'configured', codec });\n    return;\n  }\n  if (msg.type === 'frame') {\n    try {\n      if (encoder) encoder.encode(msg.frame, { keyFrame: msg.key });\n    } catch (err) {\n      self.postMessage({ type: 'error', message: String(err) });\n    } finally {\n      msg.frame.close();\n    }\n    return;\n  }\n  if (msg.type === 'flush') {\n    // Non-terminal drain (visibilitychange:hidden): push queued frames out as\n    // chunks WITHOUT closing the encoder, so capture can resume if the tab\n    // returns. Chunks stream through the existing output handler above.\n    try {\n      if (encoder) await encoder.flush();\n    } catch (e) { /* flush may fail when nothing was encoded */ }\n    self.postMessage({ type: 'flushed' });\n    return;\n  }\n  if (msg.type === 'stop') {\n    try {\n      if (encoder) await encoder.flush();\n    } catch (e) { /* flush may fail when nothing was encoded */ }\n    self.postMessage({ type: 'done' });\n    if (encoder) encoder.close();\n    encoder = null;\n  }\n};\n"), this.worker.onmessage = (e3) => {
+      var _a, _b, _c, _d;
+      const t2 = e3.data;
+      switch (t2.type) {
+        case "configured":
+          this.configured = true, (_a = this.configResolve) == null ? void 0 : _a.call(this, true), this.configResolve = null;
+          break;
+        case "config-failed":
+          (_b = this.configResolve) == null ? void 0 : _b.call(this, false), this.configResolve = null;
+          break;
+        case "decoder-config":
+          this.events.onDecoderConfig(t2.codec, t2.description ?? null);
+          break;
+        case "chunk":
+          this.events.onChunk(t2.data, t2.timestampUs, t2.key);
+          break;
+        case "error":
+          this.events.onError(String(t2.message));
+          break;
+        case "done":
+          (_c = this.doneResolve) == null ? void 0 : _c.call(this), this.doneResolve = null;
+          break;
+        case "flushed":
+          (_d = this.flushResolve) == null ? void 0 : _d.call(this), this.flushResolve = null;
+      }
+    };
+  }
+  get isConfigured() {
+    return this.configured;
+  }
+  configure(e2) {
+    return new Promise((t2) => {
+      this.configResolve = t2, this.worker.postMessage({ type: "config", ...e2 });
+    });
+  }
+  encodeFrame(e2, t2) {
+    this.worker.postMessage({ type: "frame", frame: e2, key: t2 }, [e2]);
+  }
+  flush(e2 = 3e3) {
+    return new Promise((t2) => {
+      const n2 = setTimeout(() => {
+        this.flushResolve = null, t2();
+      }, e2);
+      this.flushResolve = () => {
+        clearTimeout(n2), t2();
+      };
+      try {
+        this.worker.postMessage({ type: "flush" });
+      } catch {
+        clearTimeout(n2), this.flushResolve = null, t2();
+      }
+    });
+  }
+  stop(e2 = 3e3) {
+    return new Promise((t2) => {
+      const n2 = setTimeout(() => {
+        this.doneResolve = null, t2();
+      }, e2);
+      this.doneResolve = () => {
+        clearTimeout(n2), t2();
+      };
+      try {
+        this.worker.postMessage({ type: "stop" });
+      } catch {
+        clearTimeout(n2), this.doneResolve = null, t2();
+      }
+    });
+  }
+  terminate() {
+    this.worker.terminate();
+  }
+}
+const G = { maxBytesPerSec: 524288, sustainMs: 3e3, maxVideoDrawsPerSec: 2, maxOpsPerFrame: 5e3 };
+class CanvasGovernor {
+  constructor(e2, t2) {
+    __publicField(this, "thresholds");
+    __publicField(this, "byteSamples", []);
+    __publicField(this, "videoDraws", []);
+    __publicField(this, "frameT", NaN);
+    __publicField(this, "frameOps", 0);
+    __publicField(this, "opsExceeded", false);
+    this.now = e2, this.thresholds = { ...G, ...t2 };
+  }
+  addBytes(e2) {
+    const t2 = this.now();
+    this.byteSamples.push({ t: t2, n: e2 }), this.pruneBytes(t2);
+  }
+  addVideoDraw() {
+    const e2 = this.now();
+    this.videoDraws.push(e2), this.pruneVideo(e2);
+  }
+  addOp(e2) {
+    e2 !== this.frameT && (this.frameT = e2, this.frameOps = 0), ++this.frameOps > this.thresholds.maxOpsPerFrame && (this.opsExceeded = true);
+  }
+  shouldDemote() {
+    if (this.opsExceeded) return "ops";
+    const e2 = this.now();
+    if (this.pruneVideo(e2), this.videoDraws.length > this.thresholds.maxVideoDrawsPerSec) return "video-source";
+    this.pruneBytes(e2);
+    let t2 = 0;
+    for (const e3 of this.byteSamples) t2 += e3.n;
+    return t2 > this.thresholds.maxBytesPerSec * this.thresholds.sustainMs / 1e3 ? "bytes" : null;
+  }
+  pruneBytes(e2) {
+    const t2 = e2 - this.thresholds.sustainMs;
+    for (; this.byteSamples.length > 0 && this.byteSamples[0].t < t2; ) this.byteSamples.shift();
+  }
+  pruneVideo(e2) {
+    const t2 = e2 - 1e3;
+    for (; this.videoDraws.length > 0 && this.videoDraws[0] < t2; ) this.videoDraws.shift();
+  }
+}
+class KeyframeCapturer {
+  constructor(e2, t2, n2, r2, o2 = () => []) {
+    __publicField(this, "scratch", null);
+    __publicField(this, "scratchCtx", null);
+    __publicField(this, "lastKeyframe", -1 / 0);
+    __publicField(this, "dirtySinceKeyframe", false);
+    __publicField(this, "interactionRequested", false);
+    __publicField(this, "pending", []);
+    __publicField(this, "stopped", false);
+    this.canvas = e2, this.snapshotState = t2, this.emit = n2, this.note = r2, this.getMaskedRegions = o2;
+  }
+  onInteraction(e2) {
+    e2 - this.lastKeyframe >= 250 && (this.interactionRequested = true);
+  }
+  initialKeyframe(e2) {
+    if (this.stopped) return false;
+    if (!this.canvas.width || !this.canvas.height) return false;
+    const t2 = this.pending.length;
+    return this.takeKeyframe(e2), this.pending.length > t2;
+  }
+  afterRender(e2) {
+    this.dirtySinceKeyframe = true, (this.interactionRequested && (this.interactionRequested = false, e2 - this.lastKeyframe >= 250) || e2 - this.lastKeyframe >= 4e3) && this.takeKeyframe(e2);
+  }
+  takeKeyframe(e2) {
+    if (this.stopped) return;
+    this.lastKeyframe = e2, this.dirtySinceKeyframe = false;
+    const t2 = this.snapshotState();
+    this.scratch || (this.scratch = document.createElement("canvas"), this.scratchCtx = this.scratch.getContext("2d"), this.scratchCtx && n(this.scratchCtx));
+    const o2 = this.scratch, s2 = this.scratchCtx;
+    if (!s2) return;
+    o2.width !== this.canvas.width || o2.height !== this.canvas.height ? (o2.width = this.canvas.width, o2.height = this.canvas.height) : s2.clearRect(0, 0, o2.width, o2.height);
+    try {
+      s2.drawImage(this.canvas, 0, 0);
+    } catch {
+      return;
+    }
+    const a2 = this.getMaskedRegions();
+    if (a2.length > 0) {
+      s2.save(), s2.setTransform(1, 0, 0, 1, 0, 0), s2.fillStyle = r;
+      for (const e3 of a2) s2.fillRect(e3.x, e3.y, e3.w, e3.h);
+      s2.restore();
+    }
+    const i2 = o2.width, c2 = o2.height, d2 = createImageBitmap(o2).then(async (n2) => {
+      const r2 = await encodeBitmap(n2, 0.9, true);
+      r2.bytes && r2.bytes.byteLength > 0 && this.emit({ tMs: e2, w: i2, h: c2, state: t2, bytes: r2.bytes });
+    }).catch((e3) => this.note(`keyframe encode failed: ${e3.message}`));
+    this.pending.push(d2);
+  }
+  async stop(e2) {
+    this.dirtySinceKeyframe && this.takeKeyframe(e2), this.stopped = true, await Promise.all(this.pending);
+  }
+  dispose() {
+    if (this.stopped = true, this.scratch) try {
+      this.scratch.width = 0, this.scratch.height = 0;
+    } catch {
+    }
+    this.scratch = null, this.scratchCtx = null;
+  }
+}
+const A = /^create[A-Z]/, O = /* @__PURE__ */ new Set(["getUniformLocation", "getExtension"]), V = /^(get(?!Extension$|UniformLocation$)|is[A-Z]|check|read|finish$|flush$)/;
+let W = false;
+const U = /* @__PURE__ */ new WeakMap();
+let F = null;
+function texSourceToImageData(e2) {
+  if ("undefined" != typeof ImageData && e2 instanceof ImageData) return e2;
+  const t2 = e2, r2 = Number(t2.naturalWidth || t2.width) || 0, o2 = Number(t2.naturalHeight || t2.height) || 0;
+  if (!r2 || !o2) return null;
+  const s2 = (function texScratchCtx(e3, t3) {
+    if ("undefined" == typeof document) return null;
+    if (!F) {
+      F = document.createElement("canvas");
+      const e4 = F.getContext("2d");
+      e4 && n(e4);
+    }
+    F.width === e3 && F.height === t3 || (F.width = e3, F.height = t3);
+    const r3 = F.getContext("2d");
+    return r3 && n(r3), r3;
+  })(r2, o2);
+  return s2 ? (s2.clearRect(0, 0, r2, o2), s2.drawImage(e2, 0, 0), s2.getImageData(0, 0, r2, o2)) : null;
+}
+let K = null;
+function setUntrackedGLContextNotifier(e2) {
+  K = e2;
+}
+let $ = null;
+const H = /* @__PURE__ */ new Map();
+function setGLAutoAttach(e2) {
+  $ = e2, e2 && H.clear();
+}
+class GLRecorder {
+  constructor(e2, t2) {
+    __publicField(this, "cpuMs", 0);
+    __publicField(this, "bound", false);
+    __publicField(this, "rawCtx", null);
+    __publicField(this, "refs", /* @__PURE__ */ new WeakMap());
+    __publicField(this, "nextId", 1e6);
+    __publicField(this, "sink");
+    __publicField(this, "pendingEncodes", /* @__PURE__ */ new Set());
+    __publicField(this, "assetBySource", /* @__PURE__ */ new WeakMap());
+    __publicField(this, "nextAssetId", 2e6);
+    __publicField(this, "assetCount", 0);
+    __publicField(this, "pendingSiteId");
+    this.now = t2, this.sink = e2;
+  }
+  async settle() {
+    for (; this.pendingEncodes.size; ) await Promise.all([...this.pendingEncodes]);
+  }
+  trackEncode(e2) {
+    this.pendingEncodes.add(e2), e2.then(() => {
+    }, () => {
+    }).finally(() => this.pendingEncodes.delete(e2));
+  }
+  captureTexSource(e2, t2) {
+    var _a, _b, _c;
+    const n2 = this.assetBySource.get(e2);
+    if (void 0 !== n2) return { $: "imagedata", id: n2 };
+    if (this.assetCount >= 64) return { $: "unsupported", kind: "texture-cap" };
+    if ((function texSourceRawBytes(e3) {
+      if ("undefined" != typeof ImageData && e3 instanceof ImageData) return e3.width * e3.height * 4;
+      const t3 = e3;
+      return (Number(t3.naturalWidth || t3.width) || 0) * (Number(t3.naturalHeight || t3.height) || 0) * 4;
+    })(e2) > 7340032) return { $: "unsupported", kind: "texture-too-large" };
+    let r2;
+    try {
+      r2 = texSourceToImageData(e2);
+    } catch (e3) {
+      return s(e3) ? ((_b = (_a = this.sink).onTaint) == null ? void 0 : _b.call(_a, t2), { $: "unsupported", kind: "texture-tainted" }) : { $: "unsupported", kind: "texture" };
+    }
+    if (!r2) return { $: "unsupported", kind: ((_c = e2.constructor) == null ? void 0 : _c.name) ?? "texture" };
+    const o2 = this.nextAssetId++;
+    this.assetCount++, this.assetBySource.set(e2, o2);
+    const i2 = r2.width, c2 = r2.height, d2 = new Uint8Array(r2.data.buffer.slice(r2.data.byteOffset, r2.data.byteOffset + r2.data.byteLength));
+    return this.trackEncode(a(d2).then((e3) => {
+      var _a2, _b2;
+      this.sink.onAssetBytes(o2, e3.length, t2), (_b2 = (_a2 = this.sink).onAssetData) == null ? void 0 : _b2.call(_a2, { id: o2, format: "imagedata", w: i2, h: c2, t: t2 }, e3);
+    }).catch((e3) => this.sink.note(`GL texture asset deflate failed: ${e3.message}`))), { $: "imagedata", id: o2 };
+  }
+  swapSink(e2) {
+    var _a;
+    const t2 = this.sink;
+    if (this.sink = e2, this.bound = true, t2 instanceof o) {
+      for (const n2 of t2.ops) e2.onOp(n2);
+      for (const n2 of t2.assetEvents) e2.onAssetBytes(n2.id, n2.bytes, n2.t);
+      for (const n2 of t2.assetData) (_a = e2.onAssetData) == null ? void 0 : _a.call(e2, n2.info, n2.payload);
+      for (const n2 of t2.notes) e2.note(n2);
+    }
+  }
+  recordCall(e2, t2, n2) {
+    if (this.sink instanceof i) return this.sink.onOp(c), void (this.pendingSiteId = void 0);
+    const r2 = performance.now(), o2 = this.now(), s2 = this.pendingSiteId;
+    if (this.pendingSiteId = void 0, (A.test(e2) || O.has(e2)) && n2 && "object" == typeof n2) {
+      const r3 = this.nextId++;
+      this.refs.set(n2, r3), this.sink.onOp({ t: o2, op: "__create", create: true, args: [e2, r3, ...t2.map((e3) => this.arg(e3, o2))] });
+    } else {
+      const n3 = { t: o2, op: e2, args: t2.map((e3) => this.arg(e3, o2)) };
+      s2 && (n3.sfId = s2), this.sink.onOp(n3);
+    }
+    this.cpuMs += performance.now() - r2;
+  }
+  arg(e2, t2) {
+    var _a;
+    if (null == e2) return null;
+    switch (typeof e2) {
+      case "number":
+        return Number.isFinite(e2) ? e2 : 0;
+      case "string":
+      case "boolean":
+        return e2;
+      case "object":
+        break;
+      default:
+        return { $: "unsupported", kind: typeof e2 };
+    }
+    const n2 = e2, r2 = this.refs.get(n2);
+    return void 0 !== r2 ? { $: "obj", id: r2 } : ArrayBuffer.isView(n2) || n2 instanceof ArrayBuffer ? d(n2) : Array.isArray(n2) ? { $: "arr", v: n2.map((e3) => Number(e3) || 0) } : (function isStaticTexSource(e3) {
+      return "undefined" != typeof ImageData && e3 instanceof ImageData || "undefined" != typeof HTMLImageElement && e3 instanceof HTMLImageElement || "undefined" != typeof ImageBitmap && e3 instanceof ImageBitmap;
+    })(n2) ? this.captureTexSource(n2, t2) : { $: "unsupported", kind: ((_a = n2.constructor) == null ? void 0 : _a.name) ?? "object" };
+  }
+}
+function attachGLRecorder(e2, t2, n2, r2) {
+  const o2 = H.get(e2);
+  if (o2) return o2.swapSink(n2), o2;
+  const s2 = e2.getContext(t2);
+  if (!s2) return null;
+  const a2 = new GLRecorder(n2, r2);
+  return a2.rawCtx = s2, a2.bound = true, U.set(s2, a2), a2;
+}
+function detachGLRecorderFromContext(e2) {
+  U.delete(e2);
+}
+const j = 7340032, q = "__gpu";
+let N = false, z = null, _ = null, J = false, Z = false;
+function setGPUDeviceLostNotifier(e2) {
+  _ = e2, J = false, Z = false;
+}
+let Q = null, nowFn = () => 0, X = 0, Y = 3e6, ee = false, te = null, ne = null;
+const re = /* @__PURE__ */ new WeakMap(), oe = /* @__PURE__ */ new WeakMap(), se = /* @__PURE__ */ new WeakMap();
+function emit(e2) {
+  Q == null ? void 0 : Q.onOp(e2);
+}
+function intern(e2) {
+  let t2 = re.get(e2);
+  return void 0 === t2 && (t2 = Y++, re.set(e2, t2)), t2;
+}
+function deproxy(e2) {
+  return e2 && "object" == typeof e2 && se.has(e2) ? se.get(e2) : e2;
+}
+function deepDeproxy(e2) {
+  if (!e2 || "object" != typeof e2) return e2;
+  if (se.has(e2)) return se.get(e2);
+  if (ArrayBuffer.isView(e2) || e2 instanceof ArrayBuffer) return e2;
+  if (Array.isArray(e2)) {
+    let t3 = false;
+    const n2 = e2.map((e3) => {
+      const n3 = deepDeproxy(e3);
+      return n3 !== e3 && (t3 = true), n3;
+    });
+    return t3 ? n2 : e2;
+  }
+  const t2 = Object.getPrototypeOf(e2);
+  if (t2 === Object.prototype || null === t2) {
+    let t3 = false;
+    const n2 = {};
+    for (const [r2, o2] of Object.entries(e2)) {
+      const e3 = deepDeproxy(o2);
+      e3 !== o2 && (t3 = true), n2[r2] = e3;
+    }
+    return t3 ? n2 : e2;
+  }
+  return e2;
+}
+const ae = function serializeGPUArg(e2) {
+  var _a;
+  if (null == e2) return null;
+  switch (typeof e2) {
+    case "number":
+      return Number.isFinite(e2) ? e2 : 0;
+    case "string":
+    case "boolean":
+      return e2;
+    case "object":
+      break;
+    default:
+      return { $: "unsupported", kind: typeof e2 };
+  }
+  const t2 = deproxy(e2);
+  if (ArrayBuffer.isView(t2) || t2 instanceof ArrayBuffer) return t2.byteLength > j ? { $: "unsupported", kind: "buffer-too-large" } : d(t2);
+  const n2 = re.get(t2);
+  if (void 0 !== n2) return { $: "obj", id: n2 };
+  try {
+    return "json:" + JSON.stringify(t2, (e3, t3) => {
+      if (t3 && "object" == typeof t3) {
+        const e4 = deproxy(t3), n3 = re.get(e4);
+        if (void 0 !== n3) return { __sfRef: n3 };
+        if (ArrayBuffer.isView(e4)) {
+          const t4 = e4;
+          if (t4.byteLength > j) return { __sfUnsupported: "buffer-too-large" };
+          const n4 = l.findIndex((e5) => t4 instanceof e5);
+          return n4 < 0 ? { __sfUnsupported: "typed-array-kind" } : { __sfTa: Array.from(t4), __sfK: n4 };
+        }
+        return e4 === t3 ? t3 : e4;
+      }
+      return t3;
+    });
+  } catch {
+    return { $: "unsupported", kind: ((_a = t2.constructor) == null ? void 0 : _a.name) ?? "object" };
+  }
+};
+function shouldProxyResult(e2) {
+  var _a;
+  if (!e2 || "object" != typeof e2) return false;
+  return (((_a = e2.constructor) == null ? void 0 : _a.name) ?? "").startsWith("GPU");
+}
+function wrap(e2) {
+  var _a;
+  const t2 = oe.get(e2);
+  if (t2) return t2;
+  "GPUDevice" === ((_a = e2.constructor) == null ? void 0 : _a.name) && (function watchDeviceLost(e3) {
+    const t3 = e3.lost;
+    if (t3 && "function" == typeof t3.then) {
+      if (Z && !J) {
+        J = true;
+        try {
+          _ == null ? void 0 : _(false);
+        } catch {
+        }
+      }
+      t3.then((e4) => {
+        if (!(e4 && "destroyed" === e4.reason || Z)) {
+          Z = true;
+          try {
+            _ == null ? void 0 : _(true);
+          } catch {
+          }
+        }
+      }).catch(() => {
+      });
+    }
+  })(e2);
+  const n2 = new Proxy(e2, { get(e3, t3, n3) {
+    const r2 = Reflect.get(e3, t3, e3);
+    if ("symbol" == typeof t3) return r2;
+    if ("function" == typeof r2) return (...n4) => {
+      const o2 = performance.now(), s2 = n4.map(deepDeproxy), a2 = r2.apply(e3, s2);
+      if (Q instanceof i) return Q.onOp(c), a2 && "object" == typeof a2 && "function" == typeof a2.then ? a2.then((e4) => e4 && "object" == typeof e4 && shouldProxyResult(e4) ? (intern(e4), wrap(e4)) : e4) : shouldProxyResult(a2) ? (intern(a2), wrap(a2)) : a2;
+      if (Q) {
+        const r3 = intern(e3);
+        if (a2 && "object" == typeof a2 && "function" == typeof a2.then) {
+          const e4 = Y++;
+          return emit({ t: nowFn(), op: q, objcall: true, args: [r3, String(t3), e4, ...n4.map(ae)] }), X += performance.now() - o2, a2.then((t4) => t4 && "object" == typeof t4 ? (re.set(t4, e4), wrap(t4)) : t4);
+        }
+        let s3 = 0;
+        return shouldProxyResult(a2) && (s3 = intern(a2)), emit({ t: nowFn(), op: q, objcall: true, args: [r3, String(t3), s3, ...n4.map(ae)] }), X += performance.now() - o2, shouldProxyResult(a2) ? wrap(a2) : a2;
+      }
+      return a2 && "object" == typeof a2 && "function" == typeof a2.then ? a2.then((e4) => e4 && "object" == typeof e4 && shouldProxyResult(e4) ? (intern(e4), wrap(e4)) : e4) : shouldProxyResult(a2) ? (intern(a2), wrap(a2)) : a2;
+    };
+    if (shouldProxyResult(r2)) {
+      const n4 = re.has(r2), o2 = intern(r2);
+      return n4 || !Q || Q instanceof i || emit({ t: nowFn(), op: "__gpuprop", objcall: true, args: [intern(e3), String(t3), o2] }), wrap(r2);
+    }
+    return r2;
+  } });
+  return oe.set(e2, n2), se.set(n2, e2), n2;
+}
+function setGPUAutoAttach(e2) {
+  z = e2, e2 && (nowFn = e2.now, Q || (Q = new o(), ee = false));
+}
+const ie = ["video/webm;codecs=vp9", "video/webm;codecs=vp8", "video/webm", "video/mp4"];
+function pickMime() {
+  if ("undefined" == typeof MediaRecorder || "function" != typeof MediaRecorder.isTypeSupported) return null;
+  for (const e2 of ie) try {
+    if (MediaRecorder.isTypeSupported(e2)) return e2;
+  } catch {
+  }
+  return null;
+}
+class MediaRecorderCapture {
+  constructor(e2, t2) {
+    __publicField(this, "recorder", null);
+    __publicField(this, "stream", null);
+    __publicField(this, "stopped", false);
+    __publicField(this, "started", false);
+    __publicField(this, "seq", 0);
+    __publicField(this, "emitChain", Promise.resolve());
+    this.canvas = e2, this.out = t2;
+  }
+  static supported() {
+    return (function mediaRecorderSupported() {
+      return "undefined" != typeof MediaRecorder && "undefined" != typeof HTMLCanvasElement && "function" == typeof HTMLCanvasElement.prototype.captureStream && "function" == typeof MediaRecorder.isTypeSupported && null !== pickMime();
+    })();
+  }
+  async start() {
+    if (this.stopped) return false;
+    const e2 = this.canvas.width, t2 = this.canvas.height;
+    if (!e2 || !t2) return this.out.note("zero-size canvas — MediaRecorder capture unavailable"), false;
+    const n2 = pickMime();
+    if (!n2) return this.out.note("no MediaRecorder-supported mime — keyframes only"), false;
+    let r2, o2;
+    try {
+      r2 = this.canvas.captureStream(30);
+    } catch (e3) {
+      return this.out.note(`captureStream failed: ${e3.message}`), false;
+    }
+    try {
+      o2 = new MediaRecorder(r2, { mimeType: n2 });
+    } catch (e3) {
+      this.out.note(`MediaRecorder construct failed: ${e3.message}`);
+      try {
+        stopStream(r2);
+      } catch {
+      }
+      return false;
+    }
+    this.stream = r2, this.recorder = o2, o2.ondataavailable = (e3) => this.onData(e3.data), o2.onerror = (e3) => {
+      this.out.note(`MediaRecorder error: ${String(e3.error ?? e3)}`);
+    };
+    try {
+      o2.start(1e3);
+    } catch (e3) {
+      return this.out.note(`MediaRecorder start failed: ${e3.message}`), this.teardownStream(), false;
+    }
+    return this.started = true, this.out.onInit(o2.mimeType || n2, e2, t2), true;
+  }
+  onData(e2) {
+    if (!e2 || 0 === e2.size) return;
+    const t2 = this.seq++;
+    this.emitChain = this.emitChain.then(async () => {
+      try {
+        const n2 = await e2.arrayBuffer();
+        n2.byteLength > 0 && this.out.onChunk(t2, n2);
+      } catch (e3) {
+        this.out.note(`chunk read failed: ${e3.message}`);
+      }
+    });
+  }
+  afterRender(e2) {
+  }
+  onInteraction(e2) {
+  }
+  async flush() {
+    if (!this.stopped && this.recorder) {
+      try {
+        "recording" === this.recorder.state && this.recorder.requestData();
+      } catch {
+      }
+      await Promise.resolve(), await this.emitChain.catch(() => {
+      });
+    }
+  }
+  async stop() {
+    if (this.stopped) return;
+    this.stopped = true;
+    const e2 = this.recorder;
+    if (e2 && this.started) {
+      const t2 = new Promise((t3) => {
+        const done = () => t3();
+        e2.addEventListener("stop", done, { once: true }), setTimeout(done, 3e3);
+      });
+      try {
+        "inactive" !== e2.state && (e2.requestData(), e2.stop());
+      } catch {
+      }
+      await t2;
+    }
+    await this.emitChain.catch(() => {
+    }), this.teardownStream();
+  }
+  abort() {
+    if (!this.stopped) {
+      this.stopped = true;
+      try {
+        this.recorder && "inactive" !== this.recorder.state && this.recorder.stop();
+      } catch {
+      }
+      this.teardownStream();
+    }
+  }
+  teardownStream() {
+    this.recorder && (this.recorder.ondataavailable = null, this.recorder.onerror = null, this.recorder = null), this.stream && (stopStream(this.stream), this.stream = null);
+  }
+}
+function stopStream(e2) {
+  try {
+    for (const t2 of e2.getTracks()) try {
+      t2.stop();
+    } catch {
+    }
+  } catch {
+  }
+}
+const ce = 18e5;
+class VideoCapture {
+  constructor(e2, t2, n2, r2) {
+    __publicField(this, "client", null);
+    __publicField(this, "configured", false);
+    __publicField(this, "failed", false);
+    __publicField(this, "stopped", false);
+    __publicField(this, "lastFrame", -1 / 0);
+    __publicField(this, "lastKey", -1 / 0);
+    __publicField(this, "boostUntil", -1 / 0);
+    __publicField(this, "configuredW", 0);
+    __publicField(this, "configuredH", 0);
+    __publicField(this, "intervalId", null);
+    __publicField(this, "throttledNoted", false);
+    __publicField(this, "restarting", false);
+    __publicField(this, "forceKeyNext", false);
+    this.canvas = e2, this.now = t2, this.out = n2, this.opts = r2;
+  }
+  static supported() {
+    return "function" == typeof VideoEncoder && "function" == typeof VideoFrame;
+  }
+  async start() {
+    var _a;
+    if (!VideoCapture.supported()) return this.failed = true, this.out.note("no WebCodecs — video capture unavailable"), false;
+    const e2 = this.canvas.width, t2 = this.canvas.height;
+    if (!e2 || !t2) return this.failed = true, this.out.note("zero-size canvas — video capture unavailable"), false;
+    this.client = new VideoEncoderClient({ onDecoderConfig: (e3, t3) => this.out.onInit(e3, t3), onChunk: (e3, t3, n2) => this.out.onChunk(n2, t3, e3), onError: (e3) => this.out.note(e3) });
+    return await this.client.configure({ width: e2, height: t2, bitrate: ce, codecs: ["avc1.42001f", "vp8", "vp09.00.10.08"] }) ? (this.configured = true, this.configuredW = e2, this.configuredH = t2, ((_a = this.opts) == null ? void 0 : _a.intervalPaced) && (this.intervalId = setInterval(() => this.afterRender(this.now()), 50)), true) : (this.failed = true, this.out.note("no supported video codec"), this.client.terminate(), this.client = null, false);
+  }
+  onInteraction(e2) {
+    this.boostUntil = e2 + 1500, this.lastKey = -1 / 0;
+  }
+  afterRender(e2) {
+    var _a, _b;
+    if (!this.configured || this.failed || this.stopped || !this.client) return;
+    if ((_b = (_a = this.out).isTransportSaturated) == null ? void 0 : _b.call(_a)) return void (this.throttledNoted || (this.throttledNoted = true, this.out.note("transport saturated — video frames throttled")));
+    if (this.throttledNoted = false, this.canvas.width !== this.configuredW || this.canvas.height !== this.configuredH) return void this.requestRestart();
+    const t2 = e2 < this.boostUntil ? 30 : 20;
+    if (e2 - this.lastFrame < 1e3 / t2) return;
+    this.lastFrame = e2;
+    const n2 = this.forceKeyNext;
+    this.forceKeyNext = false;
+    const r2 = n2 || e2 - this.lastKey >= 2e3;
+    r2 && (this.lastKey = e2);
+    try {
+      const t3 = new VideoFrame(this.canvas, { timestamp: Math.round(1e3 * e2) });
+      this.client.encodeFrame(t3, r2);
+    } catch (e3) {
+      this.out.note(String(e3));
+    }
+  }
+  requestRestart() {
+    if (this.restarting || this.stopped) return;
+    const e2 = this.canvas.width, t2 = this.canvas.height;
+    if (!e2 || !t2) return;
+    this.restarting = true;
+    const n2 = this.client;
+    this.client = null, this.configured = false, this.out.note(`canvas resized to ${e2}x${t2} during video capture — restarting encoder`), (async () => {
+      try {
+        if (n2) try {
+          n2.terminate();
+        } catch {
+        }
+        if (this.stopped) return;
+        const r2 = new VideoEncoderClient({ onDecoderConfig: (e3, t3) => this.out.onInit(e3, t3), onChunk: (e3, t3, n3) => this.out.onChunk(n3, t3, e3), onError: (e3) => this.out.note(e3) }), o2 = await r2.configure({ width: e2, height: t2, bitrate: ce, codecs: ["avc1.42001f", "vp8", "vp09.00.10.08"] });
+        if (this.stopped || !o2) return r2.terminate(), void (o2 || this.out.note("encoder restart failed after resize — frames dropped until next resize"));
+        this.client = r2, this.configuredW = e2, this.configuredH = t2, this.configured = true, this.forceKeyNext = true, this.lastFrame = -1 / 0, this.lastKey = -1 / 0;
+      } finally {
+        this.restarting = false;
+      }
+    })();
+  }
+  async flush() {
+    !this.stopped && this.client && await this.client.flush();
+  }
+  abort() {
+    this.stopped || (this.stopped = true, null != this.intervalId && (clearInterval(this.intervalId), this.intervalId = null), this.client && (this.client.terminate(), this.client = null));
+  }
+  async stop() {
+    this.stopped || (this.stopped = true, null != this.intervalId && (clearInterval(this.intervalId), this.intervalId = null), this.client && (await this.client.stop(), this.client.terminate(), this.client = null));
+  }
+}
+const de = /* @__PURE__ */ new WeakMap(), le = /* @__PURE__ */ new Map();
+let ue = false, fe = null;
+function setWorkerAssociationNotifier(e2) {
+  fe = e2;
+}
+const he = 1048576, pe = { deviceClass: "desktop", sessionByteBudget: 256 * he, maxConcurrentVideo: 4, governor: {}, preferMediaRecorder: false }, me = { deviceClass: "mobile", sessionByteBudget: 96 * he, maxConcurrentVideo: 2, governor: { maxBytesPerSec: 262144, maxOpsPerFrame: 3e3 }, preferMediaRecorder: false }, ve = { deviceClass: "mobile-lowend", sessionByteBudget: 48 * he, maxConcurrentVideo: 1, governor: { maxBytesPerSec: 131072, maxOpsPerFrame: 2e3, maxVideoDrawsPerSec: 1 }, preferMediaRecorder: false };
+function resolveDeviceBudgets(e2) {
+  const t2 = "undefined" != typeof navigator ? navigator : void 0;
+  if (!t2) return pe;
+  const n2 = t2.deviceMemory, r2 = t2.hardwareConcurrency, o2 = "number" == typeof n2 && n2 <= 2, s2 = "number" == typeof r2 && r2 <= 4, a2 = (function isExplicitIOS(e3) {
+    return /iPhone|iPad|iPod/.test(e3.userAgent ?? "");
+  })(t2);
+  let i2;
+  return i2 = (function isMobileUA(e3) {
+    return /Mobi|Android|iPhone|iPad|iPod/.test(e3.userAgent ?? "") || (function isIPadDesktopUA(e4) {
+      return /Macintosh/.test(e4.userAgent ?? "") && (e4.maxTouchPoints ?? 0) > 1;
+    })(e3);
+  })(t2) ? o2 && s2 ? ve : me : o2 && s2 ? ve : pe, a2 ? { ...i2, preferMediaRecorder: true } : i2;
+}
+function decayBytes(e2, t2, n2, r2) {
+  return r2 <= 0 || t2 <= 0 || n2 <= 0 ? Math.max(0, e2) : Math.max(0, e2 - r2 * (t2 / n2));
+}
+const ye = 4;
+class VideoSlotPool {
+  constructor(e2 = 4) {
+    __publicField(this, "used", 0);
+    this.max = e2;
+  }
+  acquire() {
+    return !(this.used >= this.max) && (this.used++, true);
+  }
+  release() {
+    this.used > 0 && this.used--;
+  }
+  get inUse() {
+    return this.used;
+  }
+  get available() {
+    return this.max - this.used;
+  }
+}
+let ge = null;
+const now = () => Date.now(), encodeImage = (e2) => encodeBitmap(e2, 0.85, true);
+function noteOnce(e2) {
+  var _a;
+  if (ge && !ge.notes.has(e2)) {
+    ge.notes.add(e2);
+    try {
+      (_a = console.debug) == null ? void 0 : _a.call(console, "[Sailfish][canvas]", e2);
+    } catch {
+    }
+  }
+}
+function emitEvent(e2) {
+  if (ge) try {
+    ge.deps.addSailfishEvent(e2);
+  } catch {
+  }
+}
+function sendFrame(e2, t2, n2, r2, o2 = Date.now()) {
+  const s2 = ge;
+  if (!s2) return;
+  const a2 = null == r2 ? 0 : r2.byteLength;
+  if (a2 > 8388608) return void noteOnce(`oversize ${t2} frame dropped (${a2}B > 8MiB)`);
+  const i2 = s2.budgets.sessionByteBudget;
+  if (s2.lastBudgetTickMs > 0 && (s2.totalBytes = decayBytes(s2.totalBytes, i2, 6e4, o2 - s2.lastBudgetTickMs)), s2.lastBudgetTickMs = Math.max(s2.lastBudgetTickMs, o2), s2.totalBytes > i2) return void (s2.budgetExceeded || (s2.budgetExceeded = true, noteOnce("per-session canvas byte budget exceeded — capture paused (auto-resumes as it drains)")));
+  s2.budgetExceeded && (s2.budgetExceeded = false);
+  const c2 = s2.deps.getContextIds(), d2 = M({ v: 1, kind: t2, sessionId: c2.session_id ?? "", pageVisitUuid: c2.page_visit_uuid ?? "", canvasId: e2.canvasId, seq: e2.seq++, tMs: o2, meta: n2 }, r2);
+  try {
+    s2.deps.sendBinary(d2);
+  } catch {
+    return;
+  }
+  s2.totalBytes += d2.byteLength;
+}
+function markDirty(e2) {
+  e2.dirty = true, e2.everDirty = true, e2.pumpScheduled || (e2.pumpScheduled = true, queueMicrotask(() => (function pumpCanvas(e3) {
+    var _a, _b, _c, _d, _e;
+    if (e3.pumpScheduled = false, !ge || e3.stopped || !e3.dirty) return;
+    if (e3.contextLost) return void (e3.dirty = false);
+    e3.dirty = false;
+    const t2 = now();
+    maybeEmitResize(e3, t2), ((_a = e3.recorder2d) == null ? void 0 : _a.keyframeUnsafe) && !e3.pixelSuppressed && suppressPixelCapture(e3);
+    ((_b = e3.recorder2d) == null ? void 0 : _b.hasMaskedDraws) && !e3.pixelSuppressed && "video" === e3.mode && suppressPixelCapture(e3);
+    "video" === e3.mode ? ((_c = e3.video) == null ? void 0 : _c.afterRender(t2), (_d = e3.mediaRecorder) == null ? void 0 : _d.afterRender(t2)) : (_e = e3.keyframes) == null ? void 0 : _e.afterRender(t2);
+    maybeDemote(e3);
+  })(e2)));
+}
+function suppressPixelCapture(e2) {
+  if (e2.pixelSuppressed = true, e2.keyframes = null, e2.video && (e2.video.stop(), e2.video = null, releaseVideoSlot(e2)), e2.mediaRecorder) {
+    try {
+      e2.mediaRecorder.stop();
+    } catch {
+    }
+    e2.mediaRecorder = null;
+  }
+  "video" === e2.mode && (e2.mode = "none", emitEvent({ op: "mode", canvasId: e2.canvasId, mode: "none", reason: "maskCanvasDraws-pixel-suppressed" })), noteOnce("maskCanvasDraws used — pixel capture (keyframes/video) suppressed; sanitized command-only replay");
+}
+function flushBatch(e2, t2) {
+  if (!e2.encoder || 0 === e2.encoder.ops) return;
+  const n2 = e2.encoder.takeBatch(), r2 = a(n2);
+  e2.flushChain = e2.flushChain.then(async () => {
+    const t3 = await r2;
+    e2.governor.addBytes(t3.length), sendFrame(e2, "commands", { codec: "sfc-bin-1", compression: "deflate" }, t3), maybeDemote(e2);
+  }).catch(() => {
+  });
+}
+function makeCommandSink(e2) {
+  return { onOp(t2) {
+    e2.contextLost || (e2.encoder.encode(t2), e2.governor.addOp(t2.t), 0 === e2.batchStart && (e2.batchStart = t2.t), t2.t - e2.batchStart >= 1e3 ? (flushBatch(e2, t2.t), e2.batchStart = t2.t) : null === e2.flushTimer && (e2.flushTimer = setTimeout(() => {
+      e2.flushTimer = null, e2.stopped || (flushBatch(e2), e2.batchStart = 0);
+    }, 1100)), markDirty(e2));
+  }, onAssetBytes() {
+  }, onAssetData(t2, n2) {
+    sendFrame(e2, "asset", { assetId: t2.id, format: t2.format, w: t2.w, h: t2.h }, n2);
+  }, onVideoSource() {
+    e2.governor.addVideoDraw();
+  }, onTaint(t2) {
+    !(function emitTaint(e3, t3) {
+      if (e3.taintEmitted) return;
+      e3.taintEmitted = true, emitEvent({ op: "taint", canvasId: e3.canvasId, t: t3 });
+    })(e2, t2);
+  }, note(e3) {
+    noteOnce(e3);
+  } };
+}
+function maybeDemote(e2) {
+  var _a;
+  if ("commands" !== e2.mode || e2.demoted || e2.stopped || e2.worker) return;
+  if ("redact" === e2.privacyMode) return;
+  if ((_a = e2.recorder2d) == null ? void 0 : _a.hasMaskedDraws) return;
+  const t2 = e2.governor.shouldDemote();
+  t2 && demote(e2, t2);
+}
+function demote(e2, t2) {
+  var _a;
+  e2.demoted = true, flushBatch(e2), (_a = e2.keyframes) == null ? void 0 : _a.takeKeyframe(now());
+  const n2 = new i(() => markDirty(e2));
+  if (e2.recorder2d && e2.recorder2d.swapSink(n2), e2.recorderGL && e2.recorderGL.swapSink(n2), e2.recorderGPU && (function swapGPUSink(e3) {
+    Q && (Q = e3);
+  })(n2), !(ge == null ? void 0 : ge.budgets.preferMediaRecorder) || !tryStartMediaRecorder(e2, t2)) if (VideoCapture.supported()) {
+    if (!tryAcquireVideoSlot(e2)) return e2.mode = "none", noteOnce(`video-encoder cap (${(ge == null ? void 0 : ge.budgets.maxConcurrentVideo) ?? 4}) reached — canvas kept on keyframes`), void emitEvent({ op: "mode", canvasId: e2.canvasId, mode: "none", reason: `${t2} (video-encoder cap reached — keyframes only)` });
+    e2.mode = "video", emitEvent({ op: "mode", canvasId: e2.canvasId, mode: "video", reason: t2 });
+    const n3 = makeVideo(e2, false);
+    e2.video = n3, n3.start().then((t3) => {
+      t3 || e2.stopped || (e2.video = null, releaseVideoSlot(e2), e2.mode = "none", emitEvent({ op: "mode", canvasId: e2.canvasId, mode: "none", reason: "video-start-failed" }));
+    });
+  } else tryStartMediaRecorder(e2, t2) || (e2.mode = "none", emitEvent({ op: "mode", canvasId: e2.canvasId, mode: "none", reason: `${t2} (no WebCodecs — keyframes only)` }));
+}
+function makeKeyframes(e2) {
+  return new KeyframeCapturer(e2.canvas, () => e2.recorder2d && !e2.demoted ? e2.recorder2d.snapshotState() : null, (t2) => sendFrame(e2, "keyframe", { format: "webp", w: t2.w, h: t2.h, state: t2.state }, t2.bytes, t2.tMs), noteOnce, () => {
+    var _a;
+    return ((_a = e2.recorder2d) == null ? void 0 : _a.maskedRegions) ?? [];
+  });
+}
+function maybeInitialKeyframe(e2) {
+  const t2 = ge;
+  if (t2 && e2.keyframes && !R(e2.canvas) && t2.preExisting.has(e2.canvas)) {
+    t2.preExisting.delete(e2.canvas);
+    try {
+      e2.keyframes.initialKeyframe(now());
+    } catch {
+    }
+  }
+}
+function tryAcquireVideoSlot(e2) {
+  const t2 = ge;
+  return !!t2 && (!!e2.hasVideoSlot || !!t2.videoSlots.acquire() && (e2.hasVideoSlot = true, true));
+}
+function releaseVideoSlot(e2) {
+  e2.hasVideoSlot && (e2.hasVideoSlot = false, ge == null ? void 0 : ge.videoSlots.release());
+}
+function makeVideo(e2, t2) {
+  return new VideoCapture(e2.canvas, now, { onInit: (t3, n2) => sendFrame(e2, "video-init", { codec: t3, description: n2 ? S(n2) : null }, null), onChunk: (t3, n2, r2) => sendFrame(e2, "video-chunk", { key: t3, timestampUs: n2 }, r2), note: noteOnce, isTransportSaturated: (ge == null ? void 0 : ge.deps.isTransportSaturated) ? () => {
+    var _a, _b;
+    return !!((_b = ge == null ? void 0 : (_a = ge.deps).isTransportSaturated) == null ? void 0 : _b.call(_a));
+  } : void 0 }, { intervalPaced: t2 });
+}
+function tryStartMediaRecorder(e2, t2) {
+  if (!MediaRecorderCapture.supported()) return false;
+  if (!tryAcquireVideoSlot(e2)) return noteOnce(`video-encoder cap (${(ge == null ? void 0 : ge.budgets.maxConcurrentVideo) ?? 4}) reached — canvas kept on keyframes`), false;
+  const n2 = (function makeMediaRecorder(e3) {
+    return new MediaRecorderCapture(e3.canvas, { onInit: (t3, n3, r2) => sendFrame(e3, "video-init", { codec: "mediarecorder", mimeType: t3, w: n3, h: r2 }, null), onChunk: (t3, n3) => sendFrame(e3, "video-chunk", { codec: "mediarecorder", seq: t3 }, n3), note: noteOnce });
+  })(e2);
+  return e2.mediaRecorder = n2, e2.mode = "video", emitEvent({ op: "mode", canvasId: e2.canvasId, mode: "video", reason: `${t2} (MediaRecorder fallback)` }), n2.start().then((t3) => {
+    t3 || e2.stopped || (e2.mediaRecorder = null, releaseVideoSlot(e2), e2.mode = "none", emitEvent({ op: "mode", canvasId: e2.canvasId, mode: "none", reason: "mediarecorder-start-failed" }));
+  }), true;
+}
+function baseController(e2, t2, n2, r2, o2 = "normal") {
+  var _a;
+  return { canvas: e2, canvasId: t2, contextType: n2, mode: r2, privacyMode: o2, seq: 0, dirty: false, everDirty: false, pumpScheduled: false, flushTimer: null, stopped: false, demoted: false, hasVideoSlot: false, contextLost: false, taintEmitted: false, lastW: e2.width, lastH: e2.height, removeContextLossListeners: null, governor: new CanvasGovernor(now, (_a = ge == null ? void 0 : ge.budgets) == null ? void 0 : _a.governor), encoder: null, batchStart: 0, flushChain: Promise.resolve(), keyframes: null, video: null, mediaRecorder: null, recorder2d: null, recorderGL: null, recorderGPU: null, worker: null, workerDone: null, removeWorkerListener: null, pixelSuppressed: false };
+}
+function dpr() {
+  return "undefined" != typeof window ? window.devicePixelRatio : 1;
+}
+function emitStart(e2) {
+  e2.lastW = e2.canvas.width, e2.lastH = e2.canvas.height, emitEvent({ op: "start", canvasId: e2.canvasId, contextType: e2.contextType, mode: e2.mode, w: e2.canvas.width, h: e2.canvas.height, dpr: dpr() });
+}
+function maybeEmitResize(e2, t2) {
+  var _a, _b, _c;
+  const n2 = e2.canvas.width, r2 = e2.canvas.height;
+  n2 === e2.lastW && r2 === e2.lastH || (e2.lastW = n2, e2.lastH = r2, "video" !== e2.mode && (emitEvent({ op: "resize", canvasId: e2.canvasId, w: n2, h: r2, dpr: dpr() }), ((_a = e2.recorder2d) == null ? void 0 : _a.keyframeUnsafe) && !e2.pixelSuppressed && suppressPixelCapture(e2), e2.pixelSuppressed || ((_b = e2.keyframes) == null ? void 0 : _b.takeKeyframe(t2)), (_c = e2.recorder2d) == null ? void 0 : _c.resetMaskedRegions()));
+}
+function collectMalformedSelectors(e2) {
+  if ("undefined" == typeof document) return [];
+  const t2 = [["maskTextSelector", e2.maskTextSelector], ["blockSelector", e2.blockSelector], ["unmaskSelector", e2.unmaskSelector]], n2 = [];
+  for (const [e3, r2] of t2) if (r2) try {
+    document.querySelector(r2);
+  } catch {
+    n2.push(e3);
+  }
+  return n2;
+}
+function derivePrivacySettings(e2) {
+  const nz = (e3) => e3 && e3.length > 0 ? e3 : void 0;
+  return { maskCanvasClass: e2.maskCanvasClass, maskTextClass: nz(e2.maskTextClass), maskTextSelector: nz(e2.maskTextSelector), blockSelector: nz(e2.blockSelector), unmaskSelector: nz(e2.unmaskSelector), maskCanvasText: e2.maskCanvasText, recordSsn: e2.recordSsn, recordCreditCardInfo: e2.recordCreditCardInfo, recordDob: e2.recordDob };
+}
+function deriveContentFlags(e2) {
+  return { recordSsn: e2.recordSsn, recordCreditCardInfo: e2.recordCreditCardInfo, recordDob: e2.recordDob };
+}
+function classify(e2) {
+  return ge ? k(e2, ge.privacySettings) : "normal";
+}
+function makeTextRedactor(e2) {
+  if ("redact" === e2) return (e3) => b(e3, "redact", {});
+  if ("normal" === e2 && (function contentDetectionActive() {
+    const e3 = ge == null ? void 0 : ge.contentFlags;
+    return !!e3 && (false === e3.recordCreditCardInfo || false === e3.recordSsn || false === e3.recordDob);
+  })()) {
+    const e3 = ge.contentFlags;
+    return (t2) => b(t2, "normal", e3);
+  }
+}
+function emitMasked(e2, t2) {
+  const n2 = ge ? L(e2, ge.privacySettings) : void 0, r2 = { op: "masked", canvasId: t2 };
+  n2 && (r2.reason = n2), emitEvent(r2), ge == null ? void 0 : ge.suppressed.add(e2);
+}
+function escalateRedactIfPixelText(e2, t2) {
+  return "redact" !== e2 ? e2 : "webgl" === t2 || "webgl2" === t2 || "experimental-webgl" === t2 || "webgpu" === t2 || "worker" === t2 ? (noteOnce(`redact canvas with pixel-only text (${t2}) — escalated to suppress`), "suppress") : e2;
+}
+function resolveCanvasId(e2) {
+  return new Promise((t2) => {
+    let n2 = 0;
+    const attempt = () => {
+      if (!ge || ge.stopped) return t2(null);
+      let r2 = -1;
+      try {
+        r2 = ge.deps.mirror.getId(e2);
+      } catch {
+      }
+      return "number" == typeof r2 && r2 >= 0 ? t2(String(r2)) : ++n2 > 30 ? (noteOnce("canvas never received an rrweb mirror id — not recorded"), t2(null)) : void setTimeout(attempt, 300);
+    };
+    attempt();
+  });
+}
+function rearmCanvas(e2) {
+  const t2 = ge;
+  t2 && !t2.stopped && (t2.handled.delete(e2), t2.suppressed.delete(e2), considerCanvas(e2));
+}
+function reevaluateAllMasking() {
+  const e2 = ge;
+  if (e2 && !e2.stopped) {
+    for (const t2 of [...e2.controllers.values()]) {
+      if (t2.stopped) continue;
+      const n2 = t2.canvas, r2 = k(n2, e2.privacySettings);
+      if ("suppress" === r2) {
+        const r3 = t2.canvasId;
+        teardownController(t2), e2.handled.add(n2), emitMasked(n2, r3);
+        continue;
+      }
+      r2 !== t2.privacyMode && (teardownController(t2), n2.isConnected && rearmCanvas(n2));
+    }
+    for (const t2 of [...e2.suppressed]) {
+      if (!t2.isConnected) {
+        e2.suppressed.delete(t2);
+        continue;
+      }
+      "suppress" !== k(t2, e2.privacySettings) && rearmCanvas(t2);
+    }
+  }
+}
+function onCanvasRemoved(e2) {
+  const t2 = ge;
+  if (!t2 || t2.stopped) return;
+  if (e2.isConnected) return;
+  const n2 = t2.controllers.get(e2);
+  if (n2) {
+    const e3 = n2.canvasId;
+    teardownController(n2), emitEvent({ op: "stop", canvasId: e3 });
+  }
+  t2.handled.delete(e2), t2.suppressed.delete(e2);
+}
+function considerCanvas(e2) {
+  const t2 = ge;
+  if (!t2 || t2.stopped || t2.handled.has(e2)) return;
+  if (!e2.isConnected) return C(e2), void noteOnce("disconnected canvas skipped — recorded only if attached to the document");
+  const n2 = classify(e2);
+  if ("suppress" === n2) return t2.handled.add(e2), void resolveCanvasId(e2).then((t3) => {
+    null != t3 && emitMasked(e2, t3);
+  });
+  const r2 = (function getWorkerForCanvas(e3) {
+    return le.get(e3);
+  })(e2), s2 = x(e2);
+  (r2 || s2) && (t2.handled.add(e2), resolveCanvasId(e2).then((t3) => {
+    if (null != t3 && ge && !ge.stopped) if (r2) {
+      if ("redact" === n2) return noteOnce("redact worker/offscreen canvas — escalated to suppress (no DOM to redact)"), void emitMasked(e2, t3);
+      !(async function buildWorkerController(e3, t4, n3) {
+        const r3 = await (function pingWorkerShim(e4, t5 = 500) {
+          return new Promise((n4) => {
+            let r4 = false;
+            const finish = (t6) => {
+              r4 || (r4 = true, clearTimeout(o3), e4.removeEventListener("message", onMsg), n4(t6));
+            }, onMsg = (e5) => {
+              var _a;
+              "sf-record-pong" === ((_a = e5.data) == null ? void 0 : _a.type) && finish(true);
+            }, o3 = setTimeout(() => finish(false), t5);
+            e4.addEventListener("message", onMsg);
+            try {
+              e4.postMessage({ type: "sf-record-ping" });
+            } catch {
+              finish(false);
+            }
+          });
+        })(n3), o2 = ge;
+        if (!o2 || o2.stopped) return;
+        if (r3) {
+          const r4 = baseController(e3, t4, "worker", "commands");
+          let s4;
+          r4.worker = n3, r4.workerDone = new Promise((e4) => {
+            s4 = e4;
+          });
+          const onMsg = (e4) => {
+            const t5 = e4.data;
+            if ("sf-record-done" === (t5 == null ? void 0 : t5.type)) s4(t5);
+            else if ("sf-record-noctx" === (t5 == null ? void 0 : t5.type)) {
+              if (!r4.stopped && "commands" === r4.mode && !r4.video && !r4.mediaRecorder) {
+                const e5 = VideoCapture.supported() && tryAcquireVideoSlot(r4);
+                if (VideoCapture.supported() && !e5 && noteOnce(`video-encoder cap (${(ge == null ? void 0 : ge.budgets.maxConcurrentVideo) ?? 4}) reached — worker canvas kept on keyframes`), e5) {
+                  r4.mode = "video", emitEvent({ op: "mode", canvasId: r4.canvasId, mode: "video", reason: "worker-no-2d-context" });
+                  const e6 = makeVideo(r4, true);
+                  r4.video = e6, e6.start().then((e7) => {
+                    e7 || r4.stopped || (r4.video = null, releaseVideoSlot(r4), r4.mode = "none", emitEvent({ op: "mode", canvasId: r4.canvasId, mode: "none", reason: "video-start-failed" }));
+                  });
+                } else !VideoCapture.supported() && tryStartMediaRecorder(r4, "worker-no-2d-context") || (r4.mode = "none", emitEvent({ op: "mode", canvasId: r4.canvasId, mode: "none", reason: "worker-no-2d-context" }));
+              }
+            } else "sf-record-batch" === (t5 == null ? void 0 : t5.type) && (sendFrame(r4, "commands", { codec: "sfc-bin-1", compression: "deflate" }, new Uint8Array(t5.deflated), t5.tMs), r4.governor.addBytes(t5.deflated.byteLength));
+          };
+          n3.addEventListener("message", onMsg), r4.removeWorkerListener = () => n3.removeEventListener("message", onMsg);
+          try {
+            n3.postMessage({ type: "sf-record-start", contentFlags: o2.contentFlags });
+          } catch {
+            noteOnce("worker postMessage failed — worker canvas not recorded");
+          }
+          return o2.controllers.set(e3, r4), void emitStart(r4);
+        }
+        const s3 = baseController(e3, t4, "worker", "none");
+        if (o2.controllers.set(e3, s3), VideoCapture.supported() && tryAcquireVideoSlot(s3)) {
+          s3.mode = "video";
+          const e4 = makeVideo(s3, true);
+          s3.video = e4, e4.start().then((e5) => {
+            e5 || s3.stopped || (s3.video = null, releaseVideoSlot(s3), s3.mode = "none", emitEvent({ op: "mode", canvasId: s3.canvasId, mode: "none", reason: "video-start-failed" }));
+          });
+        } else VideoCapture.supported() ? noteOnce(`video-encoder cap (${(ge == null ? void 0 : ge.budgets.maxConcurrentVideo) ?? 4}) reached — worker placeholder canvas not captured`) : tryStartMediaRecorder(s3, "worker-no-shim") || noteOnce("worker canvas without shim and no usable video backend — not captured");
+        emitStart(s3);
+      })(e2, t3, r2);
+    } else if ("2d" === s2.type) build2DController(e2, t3, null, n2);
+    else if ("webgl" === s2.type || "webgl2" === s2.type || "experimental-webgl" === s2.type) {
+      const r3 = escalateRedactIfPixelText(n2, s2.type);
+      if ("suppress" === r3) return void emitMasked(e2, t3);
+      !(function buildGLController(e3, t4, n3, r4, o2 = "normal") {
+        const s3 = ge;
+        if (!s3 || s3.stopped) return;
+        const a2 = "experimental-webgl" === n3 ? "webgl" : n3;
+        if ("suppress" === escalateRedactIfPixelText(o2, a2)) return void emitMasked(e3, t4);
+        const i2 = baseController(e3, t4, a2, "commands", o2);
+        i2.encoder = new g();
+        const c2 = makeCommandSink(i2);
+        let d2;
+        d2 = attachGLRecorder(e3, n3, c2, now), d2 || (i2.mode = "none", noteOnce("GL context not reachable — nothing recorded"));
+        i2.recorderGL = d2, i2.keyframes = makeKeyframes(i2), installGLContextLossHandling(i2), s3.controllers.set(e3, i2), emitStart(i2), maybeInitialKeyframe(i2);
+      })(e2, t3, s2.type, 0, r3);
+    } else if ("webgpu" === s2.type) {
+      const r3 = escalateRedactIfPixelText(n2, "webgpu");
+      if ("suppress" === r3) return void emitMasked(e2, t3);
+      !(function buildGPUController(e3, t4, n3 = "normal") {
+        const r4 = ge;
+        if (!r4 || r4.stopped) return;
+        if ("suppress" === escalateRedactIfPixelText(n3, "webgpu")) return void emitMasked(e3, t4);
+        const s3 = baseController(e3, t4, "webgpu", "commands", n3);
+        s3.encoder = new g();
+        const a2 = (function attachGPURecorder(e4, t5, n4) {
+          if (te !== e4 || !Q) return null;
+          ne = e4, nowFn = n4;
+          const r5 = Q;
+          if (Q = t5, r5 instanceof o) {
+            for (const e5 of r5.ops) t5.onOp(e5);
+            for (const e5 of r5.notes) t5.note(e5);
+          }
+          return { detach() {
+            Q = null, ne = null, te = null;
+          }, cpuMs: () => X };
+        })(e3, makeCommandSink(s3), now);
+        a2 || (s3.mode = "none", noteOnce("WebGPU recorder not armed for this canvas — nothing recorded"));
+        s3.recorderGPU = a2, s3.keyframes = makeKeyframes(s3), (function installGPUContextLossHandling(e4) {
+          setGPUDeviceLostNotifier((t5) => {
+            var _a;
+            if (!e4.stopped) if (t5) {
+              if (e4.contextLost) return;
+              e4.contextLost = true;
+              try {
+                flushBatch(e4, now());
+              } catch {
+              }
+              emitEvent({ op: "context-lost", canvasId: e4.canvasId });
+            } else {
+              if (!e4.contextLost) return;
+              e4.contextLost = false, emitEvent({ op: "context-restored", canvasId: e4.canvasId, w: e4.canvas.width, h: e4.canvas.height, dpr: dpr() }), e4.everDirty = true, markDirty(e4), (_a = e4.keyframes) == null ? void 0 : _a.onInteraction(now());
+            }
+          }), e4.removeContextLossListeners = () => setGPUDeviceLostNotifier(null);
+        })(s3), r4.controllers.set(e3, s3), emitStart(s3), maybeInitialKeyframe(s3);
+      })(e2, t3, r3);
+    } else {
+      const n3 = baseController(e2, t3, "unknown", "none");
+      ge.controllers.set(e2, n3), emitStart(n3), noteOnce(`unsupported context type "${s2.type}" — not captured`);
+    }
+  }));
+}
+function build2DController(e2, t2, n2, r2 = "normal") {
+  const o2 = ge;
+  if (!o2 || o2.stopped) return;
+  const s2 = baseController(e2, t2, "2d", "commands", r2);
+  s2.encoder = new g();
+  const a2 = makeCommandSink(s2);
+  let i2 = n2;
+  i2 ? i2.swapSink(a2) : i2 = w(e2, a2, now, "cas", encodeImage, { retainAssets: false }), i2 || (s2.mode = "none", noteOnce("canvas has no readable 2D context — nothing recorded")), i2 && (i2.textRedactor = makeTextRedactor(r2), i2.redactStyle = o2.redactStyle), s2.recorder2d = i2, s2.keyframes = makeKeyframes(s2), o2.controllers.set(e2, s2), emitStart(s2), maybeInitialKeyframe(s2);
+}
+function installGLContextLossHandling(e2) {
+  const t2 = e2.canvas, onLost = (t3) => {
+    try {
+      t3.preventDefault();
+    } catch {
+    }
+    if (!e2.stopped && !e2.contextLost) {
+      e2.contextLost = true;
+      try {
+        flushBatch(e2, now());
+      } catch {
+      }
+      emitEvent({ op: "context-lost", canvasId: e2.canvasId });
+    }
+  }, onRestored = () => {
+    var _a, _b;
+    if (e2.stopped || !e2.contextLost) return;
+    try {
+      ((_a = e2.recorderGL) == null ? void 0 : _a.rawCtx) && detachGLRecorderFromContext(e2.recorderGL.rawCtx);
+    } catch {
+    }
+    const n2 = "webgl2" === e2.contextType ? "webgl2" : "webgl", r2 = attachGLRecorder(t2, n2, makeCommandSink(e2), now);
+    e2.recorderGL = r2, e2.contextLost = false, emitEvent({ op: "context-restored", canvasId: e2.canvasId, w: t2.width, h: t2.height, dpr: dpr() }), e2.everDirty = true, markDirty(e2), (_b = e2.keyframes) == null ? void 0 : _b.onInteraction(now());
+  };
+  t2.addEventListener("webglcontextlost", onLost, false), t2.addEventListener("webglcontextrestored", onRestored, false), e2.removeContextLossListeners = () => {
+    t2.removeEventListener("webglcontextlost", onLost, false), t2.removeEventListener("webglcontextrestored", onRestored, false);
+  };
+}
+function onUntracked2D(e2) {
+  const t2 = ge;
+  if (!t2 || t2.stopped || t2.seenContexts.has(e2)) return;
+  t2.seenContexts.add(e2);
+  const n2 = e2.canvas;
+  if (!(n2 instanceof HTMLCanvasElement)) return;
+  if (!n2.isConnected) return;
+  if (t2.handled.has(n2)) return;
+  const r2 = classify(n2);
+  if ("suppress" === r2) return t2.handled.add(n2), void resolveCanvasId(n2).then((e3) => {
+    null != e3 && emitMasked(n2, e3);
+  });
+  t2.handled.add(n2);
+  const s2 = E(e2, new o(), now, "cas", encodeImage, { retainAssets: false });
+  resolveCanvasId(n2).then((t3) => {
+    null != t3 && ge && !ge.stopped ? build2DController(n2, t3, s2, r2) : y(e2);
+  });
+}
+function onUntrackedGL(e2) {
+  const t2 = ge;
+  if (!t2 || t2.stopped || t2.seenContexts.has(e2)) return;
+  t2.seenContexts.add(e2);
+  const n2 = e2.canvas;
+  if (!(n2 instanceof HTMLCanvasElement)) return;
+  if (!n2.isConnected) return;
+  if (t2.handled.has(n2)) return;
+  const r2 = classify(n2), s2 = "undefined" != typeof WebGL2RenderingContext && e2 instanceof WebGL2RenderingContext ? "webgl2" : "webgl";
+  if ("suppress" === r2 || "suppress" === escalateRedactIfPixelText(r2, s2)) return t2.handled.add(n2), void resolveCanvasId(n2).then((e3) => {
+    null != e3 && emitMasked(n2, e3);
+  });
+  t2.handled.add(n2);
+  const a2 = s2, i2 = new o(), c2 = (function attachGLRecorderToContext(e3, t3, n3) {
+    const r3 = new GLRecorder(t3, n3);
+    return r3.rawCtx = e3, r3.bound = true, U.set(e3, r3), r3;
+  })(e2, i2, now);
+  resolveCanvasId(n2).then((t3) => {
+    if (null == t3 || !ge || ge.stopped) return void detachGLRecorderFromContext(e2);
+    const o2 = ge, s3 = baseController(n2, t3, a2, "commands", r2);
+    s3.encoder = new g(), c2.swapSink(makeCommandSink(s3)), s3.recorderGL = c2, s3.keyframes = makeKeyframes(s3), installGLContextLossHandling(s3), o2.controllers.set(n2, s3), emitStart(s3), maybeInitialKeyframe(s3);
+  });
+}
+function startCanvasRecording(t2) {
+  if ("undefined" == typeof window || "undefined" == typeof document) return;
+  if (ge) return;
+  const n2 = t2.settings.maskCanvasClass || "sailfishSanitize", r2 = resolveDeviceBudgets();
+  ge = { deps: t2, maskSelector: `.${n2}, [data-sf-mask]`, privacySettings: derivePrivacySettings(t2.settings), contentFlags: deriveContentFlags(t2.settings), redactStyle: u(f, t2.settings.canvasRedactStyle), budgets: r2, controllers: /* @__PURE__ */ new Map(), handled: /* @__PURE__ */ new WeakSet(), suppressed: /* @__PURE__ */ new Set(), preExisting: /* @__PURE__ */ new WeakSet(), seenContexts: /* @__PURE__ */ new WeakSet(), observer: null, removeListeners: [], totalBytes: 0, budgetExceeded: false, lastBudgetTickMs: 0, notes: /* @__PURE__ */ new Set(), stopped: false, videoSlots: new VideoSlotPool(r2.maxConcurrentVideo) };
+  for (const e2 of collectMalformedSelectors(t2.settings)) noteOnce(`malformed canvas privacy selector "${e2}" is invalid and will not match — that privacy rule is disabled`);
+  h(), (function installGLHooks() {
+    if (W) return;
+    W = true;
+    const e2 = [];
+    "undefined" != typeof WebGLRenderingContext && e2.push(WebGLRenderingContext.prototype), "undefined" != typeof WebGL2RenderingContext && e2.push(WebGL2RenderingContext.prototype);
+    for (const t4 of e2) for (const e3 of Object.getOwnPropertyNames(t4)) {
+      const n3 = Object.getOwnPropertyDescriptor(t4, e3);
+      if (!n3 || "function" != typeof n3.value || "constructor" === e3) continue;
+      if (V.test(e3) && !O.has(e3)) continue;
+      const r3 = n3.value;
+      t4[e3] = function(...t5) {
+        const n4 = r3.apply(this, t5), o2 = U.get(this);
+        return o2 ? o2.recordCall(e3, t5, n4) : K && K(this), n4;
+      };
+    }
+    if ("undefined" == typeof HTMLCanvasElement) return;
+    const t3 = HTMLCanvasElement.prototype.getContext;
+    HTMLCanvasElement.prototype.getContext = function(e3, n3) {
+      const r3 = t3.call(this, e3, n3);
+      if (("webgl" === e3 || "webgl2" === e3 || "experimental-webgl" === e3) && r3 && $ && !U.has(r3)) {
+        const e4 = new GLRecorder(new o(), $.now);
+        e4.rawCtx = r3, U.set(r3, e4), H.set(this, e4);
+      }
+      return r3;
+    };
+  })(), (function installGPUHooks() {
+    if (N) return;
+    if (N = true, "undefined" == typeof navigator || !("gpu" in navigator)) return;
+    const e2 = navigator.gpu;
+    if (Object.defineProperty(navigator, "gpu", { configurable: true, get() {
+      if (z || Q) {
+        if (!ee) {
+          ee = true;
+          const t4 = intern(e2);
+          emit({ t: nowFn(), op: "__gpuroot", args: [t4] });
+        }
+        return wrap(e2);
+      }
+      return e2;
+    } }), "undefined" == typeof HTMLCanvasElement) return;
+    const t3 = HTMLCanvasElement.prototype.getContext;
+    HTMLCanvasElement.prototype.getContext = function(e3, n3) {
+      const r3 = t3.call(this, e3, n3);
+      if ("webgpu" === e3 && r3 && (z || Q)) {
+        te = this;
+        const e4 = re.has(r3), t4 = intern(r3);
+        return e4 || emit({ t: nowFn(), op: "__gpuctx", args: [t4] }), wrap(r3);
+      }
+      return r3;
+    };
+  })(), (function installWorkerRelay() {
+    if (!ue) {
+      if (ue = true, "undefined" != typeof HTMLCanvasElement && "function" == typeof HTMLCanvasElement.prototype.transferControlToOffscreen) {
+        const e2 = HTMLCanvasElement.prototype.transferControlToOffscreen;
+        HTMLCanvasElement.prototype.transferControlToOffscreen = function() {
+          const t3 = e2.call(this);
+          return de.set(t3, this), t3;
+        };
+      }
+      if ("undefined" != typeof Worker) {
+        const e2 = Worker.prototype.postMessage;
+        Worker.prototype.postMessage = function(t3, n3) {
+          const r3 = Array.isArray(n3) ? n3 : n3 == null ? void 0 : n3.transfer;
+          if (r3) for (const e3 of r3) {
+            const t4 = e3 && "object" == typeof e3 ? de.get(e3) : void 0;
+            t4 && !le.has(t4) && (le.set(t4, this), fe == null ? void 0 : fe(t4, this));
+          }
+          return e2.apply(this, [t3, n3]);
+        };
+      }
+    }
+  })(), p({ now, assetMode: "cas", encodeImage, retainAssets: false }), setGLAutoAttach({ now }), setGPUAutoAttach({ now }), I((e2) => {
+    queueMicrotask(() => considerCanvas(e2));
+  }), T(onUntracked2D), setUntrackedGLContextNotifier(onUntrackedGL), setWorkerAssociationNotifier((e2) => considerCanvas(e2));
+  globalThis.__sfDrawSite = (e2, t3) => (e2 && "object" == typeof e2 && (m(e2, t3) || (function noteGLPendingSiteId(e3, t4) {
+    const n3 = U.get(e3);
+    return !!n3 && (n3.pendingSiteId = t4, true);
+  })(e2, t3)), e2), e({ canvasIdFor: (e2) => {
+    var _a;
+    return ((_a = ge == null ? void 0 : ge.controllers.get(e2)) == null ? void 0 : _a.canvasId) ?? null;
+  }, emitHit: (e2) => emitEvent(e2), now });
+  const onInteraction = () => {
+    var _a, _b, _c;
+    const e2 = ge;
+    if (!e2 || e2.stopped) return;
+    const t3 = now();
+    for (const n3 of e2.controllers.values()) n3.stopped || ("video" === n3.mode ? ((_a = n3.video) == null ? void 0 : _a.onInteraction(t3), (_b = n3.mediaRecorder) == null ? void 0 : _b.onInteraction(t3)) : (_c = n3.keyframes) == null ? void 0 : _c.onInteraction(t3));
+  };
+  window.addEventListener("pointerdown", onInteraction, { capture: true, passive: true }), window.addEventListener("keydown", onInteraction, { capture: true, passive: true }), ge.removeListeners.push(() => {
+    window.removeEventListener("pointerdown", onInteraction, { capture: true }), window.removeEventListener("keydown", onInteraction, { capture: true });
+  });
+  const s2 = new MutationObserver((e2) => {
+    let t3 = false;
+    for (const n3 of e2) "attributes" !== n3.type ? (n3.addedNodes.forEach((e3) => {
+      e3 instanceof Element && (e3 instanceof HTMLCanvasElement ? considerCanvas(e3) : e3.querySelectorAll("canvas").forEach((e4) => considerCanvas(e4)));
+    }), n3.removedNodes.forEach((e3) => {
+      e3 instanceof Element && (e3 instanceof HTMLCanvasElement ? onCanvasRemoved(e3) : e3.querySelectorAll("canvas").forEach((e4) => onCanvasRemoved(e4)));
+    })) : t3 = true;
+    t3 && reevaluateAllMasking();
+  });
+  s2.observe(document.documentElement, { childList: true, subtree: true, attributes: true }), ge.observer = s2, document.querySelectorAll("canvas").forEach((e2) => {
+    ge.preExisting.add(e2), considerCanvas(e2);
+  });
+}
+function teardownController(e2) {
+  var _a, _b, _c, _d, _e, _f, _g;
+  if (e2.stopped) ge == null ? void 0 : ge.controllers.delete(e2.canvas);
+  else {
+    e2.stopped = true;
+    try {
+      null !== e2.flushTimer && (clearTimeout(e2.flushTimer), e2.flushTimer = null);
+    } catch {
+    }
+    try {
+      (_a = e2.removeContextLossListeners) == null ? void 0 : _a.call(e2);
+    } catch {
+    }
+    e2.removeContextLossListeners = null;
+    try {
+      (_b = e2.video) == null ? void 0 : _b.abort();
+    } catch {
+    }
+    e2.video = null;
+    try {
+      (_c = e2.mediaRecorder) == null ? void 0 : _c.abort();
+    } catch {
+    }
+    e2.mediaRecorder = null, releaseVideoSlot(e2);
+    try {
+      (_d = e2.keyframes) == null ? void 0 : _d.dispose();
+    } catch {
+    }
+    if (e2.keyframes = null, e2.worker) try {
+      e2.worker.postMessage({ type: "sf-record-stop" });
+    } catch {
+    }
+    try {
+      (_e = e2.removeWorkerListener) == null ? void 0 : _e.call(e2);
+    } catch {
+    }
+    e2.removeWorkerListener = null;
+    try {
+      e2.recorder2d && y(e2.recorder2d.rawCtx);
+    } catch {
+    }
+    try {
+      ((_f = e2.recorderGL) == null ? void 0 : _f.rawCtx) && detachGLRecorderFromContext(e2.recorderGL.rawCtx);
+    } catch {
+    }
+    try {
+      (_g = e2.recorderGPU) == null ? void 0 : _g.detach();
+    } catch {
+    }
+    ge == null ? void 0 : ge.controllers.delete(e2.canvas);
+  }
+}
+function settleOrTimeout(e2, t2) {
+  return Promise.race([e2.catch(() => {
+  }), new Promise((e3) => setTimeout(e3, t2))]);
+}
+async function stopController(e2, t2) {
+  var _a, _b, _c;
+  if (!e2.stopped) {
+    e2.stopped = true;
+    try {
+      (_a = e2.removeContextLossListeners) == null ? void 0 : _a.call(e2);
+    } catch {
+    }
+    if (e2.removeContextLossListeners = null, null !== e2.flushTimer && (clearTimeout(e2.flushTimer), e2.flushTimer = null), e2.worker && e2.workerDone) {
+      try {
+        e2.worker.postMessage({ type: "sf-record-stop" });
+      } catch {
+      }
+      const t3 = await Promise.race([e2.workerDone, new Promise((e3) => setTimeout(() => e3(null), 5e3))]);
+      (_b = e2.removeWorkerListener) == null ? void 0 : _b.call(e2), t3 && await (async function convertWorkerResult(e3, t4) {
+        for (const e4 of t4.notes ?? []) noteOnce(`worker: ${e4}`);
+        for (const n2 of t4.batches ?? []) try {
+          sendFrame(e3, "commands", { codec: "sfc-bin-1", compression: "deflate" }, await a(n2));
+        } catch {
+        }
+        for (const n2 of t4.assets ?? []) try {
+          if (n2.bitmap) {
+            const t5 = n2.w ?? n2.bitmap.width, r2 = n2.h ?? n2.bitmap.height, o2 = await encodeBitmap(n2.bitmap, 0.85, true);
+            o2.bytes && sendFrame(e3, "asset", { assetId: n2.id, format: "webp", w: t5, h: r2 }, o2.bytes);
+          } else if (n2.imageData) {
+            const t5 = n2.imageData, r2 = await a(new Uint8Array(t5.data.buffer, t5.data.byteOffset, t5.data.byteLength));
+            sendFrame(e3, "asset", { assetId: n2.id, format: "imagedata", w: t5.width, h: t5.height }, r2);
+          }
+        } catch {
+        }
+      })(e2, t3), e2.video && await e2.video.stop(), e2.mediaRecorder && await e2.mediaRecorder.stop();
+    } else flushBatch(e2), e2.video && await e2.video.stop(), e2.mediaRecorder && await e2.mediaRecorder.stop(), e2.keyframes && (e2.everDirty && e2.keyframes.takeKeyframe(t2), await e2.keyframes.stop(t2)), e2.recorder2d && (y(e2.recorder2d.rawCtx), flushBatch(e2), await settleOrTimeout(e2.recorder2d.settle(), 5e3)), e2.recorderGL && (e2.recorderGL.rawCtx && detachGLRecorderFromContext(e2.recorderGL.rawCtx), await settleOrTimeout(e2.recorderGL.settle(), 5e3)), (_c = e2.recorderGPU) == null ? void 0 : _c.detach(), await e2.flushChain;
+    releaseVideoSlot(e2), emitEvent({ op: "stop", canvasId: e2.canvasId });
+  }
+}
+async function stopCanvasRecording() {
+  var _a;
+  const e2 = ge;
+  if (!e2 || e2.stopped) return;
+  e2.stopped = true, p(null), setGLAutoAttach(null), setGPUAutoAttach(null), setGPUDeviceLostNotifier(null), I(null), T(null), setUntrackedGLContextNotifier(null), setWorkerAssociationNotifier(null), delete globalThis.__sfDrawSite, t(), (_a = e2.observer) == null ? void 0 : _a.disconnect();
+  for (const t2 of e2.removeListeners) try {
+    t2();
+  } catch {
+  }
+  const n2 = now();
+  await Promise.all([...e2.controllers.values()].map((e3) => stopController(e3, n2).catch(() => {
+  }))), v(), (function pruneUnboundGLRecorders() {
+    for (const [e3, t2] of H) t2.bound || (U.delete(t2.rawCtx), H.delete(e3));
+  })(), (function pruneUnboundGPURecorders() {
+    Q instanceof o && !ne && (te || (Q = null));
+  })(), (function terminateImgEncoder() {
+    P && (P.terminate(), P = null);
+    for (const [e3, t2] of B) B.delete(e3), t2({ size: 0 });
+  })(), ge = null;
+}
+async function flushAllCanvas() {
+  const e2 = ge;
+  if (!e2 || e2.stopped) return;
+  now();
+  const t2 = [];
+  for (const n2 of e2.controllers.values()) if (!n2.stopped) {
+    try {
+      flushBatch(n2);
+    } catch {
+    }
+    n2.video && t2.push(n2.video.flush().catch(() => {
+    })), n2.mediaRecorder && t2.push(n2.mediaRecorder.flush().catch(() => {
+    })), t2.push(n2.flushChain.catch(() => {
+    }));
+  }
+  await Promise.all(t2).catch(() => {
+  });
+}
+function isCanvasRecordingActive() {
+  return null != ge && !ge.stopped;
+}
+const we = { initState(e2) {
+  ge = { deps: e2, maskSelector: ".sailfishSanitize, [data-sf-mask]", privacySettings: derivePrivacySettings(e2.settings), contentFlags: deriveContentFlags(e2.settings), redactStyle: u(f, e2.settings.canvasRedactStyle), budgets: resolveDeviceBudgets(), controllers: /* @__PURE__ */ new Map(), handled: /* @__PURE__ */ new WeakSet(), suppressed: /* @__PURE__ */ new Set(), preExisting: /* @__PURE__ */ new WeakSet(), seenContexts: /* @__PURE__ */ new WeakSet(), observer: null, removeListeners: [], totalBytes: 0, budgetExceeded: false, lastBudgetTickMs: 0, notes: /* @__PURE__ */ new Set(), stopped: false, videoSlots: new VideoSlotPool(resolveDeviceBudgets().maxConcurrentVideo) };
+}, addController(e2, t2, n2 = "normal") {
+  const r2 = baseController(e2, t2, "2d", "commands", n2);
+  return ge.controllers.set(e2, r2), r2;
+}, classify: (e2) => classify(e2), makeTextRedactor: (e2) => makeTextRedactor(e2), reevaluate() {
+  reevaluateAllMasking();
+}, escalate: (e2, t2) => escalateRedactIfPixelText(e2, t2), isTracked: (e2) => !!(ge == null ? void 0 : ge.controllers.get(e2)), isSuppressed: (e2) => !!(ge == null ? void 0 : ge.suppressed.has(e2)), markSuppressed(e2) {
+  ge == null ? void 0 : ge.handled.add(e2), ge == null ? void 0 : ge.suppressed.add(e2);
+}, controllerPrivacy: (e2) => ({ mode: e2.privacyMode, hasKeyframes: null != e2.keyframes }), tryDemote(e2) {
+  maybeDemote(e2);
+}, emitResize(e2) {
+  maybeEmitResize(e2, now());
+}, build2DWithFakeRecorder(e2, t2, n2) {
+  const r2 = { swapSink: () => {
+  }, textRedactor: void 0, rawCtx: {} };
+  return build2DController(e2, t2, r2, n2), { ctl: ge == null ? void 0 : ge.controllers.get(e2), redactor: r2.textRedactor };
+}, demote(e2, t2 = "bytes") {
+  demote(e2, t2);
+}, teardown(e2) {
+  teardownController(e2);
+}, slotsInUse: () => (ge == null ? void 0 : ge.videoSlots.inUse) ?? -1, controllerHasSlot: (e2) => e2.hasVideoSlot, reset() {
+  ge = null;
+} };
+export {
+  ye as MAX_CONCURRENT_VIDEO_CANVASES,
+  VideoSlotPool,
+  we as __canvasManagerTestHooks,
+  collectMalformedSelectors,
+  decayBytes,
+  flushAllCanvas,
+  isCanvasRecordingActive,
+  settleOrTimeout,
+  startCanvasRecording,
+  stopCanvasRecording
+};