@sailfish-ai/recorder 1.12.4 → 1.12.6

package/dist/chunks/canvasManager-BYn3_oyo.js

@@ -0,0 +1,1440 @@
+"use strict";
+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);
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const e = require("./index-BIj4l3CV.js"), t = require("./patch2d-9voowhJ_.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 n = null, r = 1;
+const o = /* @__PURE__ */ new Map();
+function encodeBitmap(e2, t2, s2 = false) {
+  const a2 = r++;
+  return new Promise((r2) => {
+    o.set(a2, r2), (function getImgWorker() {
+      return n || (n = 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"), n.onmessage = (e3) => {
+        const t3 = o.get(e3.data.id);
+        t3 && (o.delete(e3.data.id), t3({ size: e3.data.size, bytes: e3.data.bytes }));
+      }), n;
+    })().postMessage({ id: a2, bitmap: e2, quality: t2, wantBytes: s2 }, [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 s = { 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 = { ...s, ...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 n2 = this.snapshotState();
+    this.scratch || (this.scratch = document.createElement("canvas"), this.scratchCtx = this.scratch.getContext("2d"), this.scratchCtx && t.ignore2DContext(this.scratchCtx));
+    const r2 = this.scratch, o2 = this.scratchCtx;
+    if (!o2) return;
+    r2.width !== this.canvas.width || r2.height !== this.canvas.height ? (r2.width = this.canvas.width, r2.height = this.canvas.height) : o2.clearRect(0, 0, r2.width, r2.height);
+    try {
+      o2.drawImage(this.canvas, 0, 0);
+    } catch {
+      return;
+    }
+    const s2 = this.getMaskedRegions();
+    if (s2.length > 0) {
+      o2.save(), o2.setTransform(1, 0, 0, 1, 0, 0), o2.fillStyle = t.REDACTION_COLOR;
+      for (const e3 of s2) o2.fillRect(e3.x, e3.y, e3.w, e3.h);
+      o2.restore();
+    }
+    const a2 = r2.width, i2 = r2.height, c2 = createImageBitmap(r2).then(async (t2) => {
+      const r3 = await encodeBitmap(t2, 0.9, true);
+      r3.bytes && r3.bytes.byteLength > 0 && this.emit({ tMs: e2, w: a2, h: i2, state: n2, bytes: r3.bytes });
+    }).catch((e3) => this.note(`keyframe encode failed: ${e3.message}`));
+    this.pending.push(c2);
+  }
+  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]/, i = /* @__PURE__ */ new Set(["getUniformLocation", "getExtension"]), c = /^(get(?!Extension$|UniformLocation$)|is[A-Z]|check|read|finish$|flush$)/;
+let d = false;
+const l = /* @__PURE__ */ new WeakMap();
+let u = null;
+function texSourceToImageData(e2) {
+  if ("undefined" != typeof ImageData && e2 instanceof ImageData) return e2;
+  const n2 = e2, r2 = Number(n2.naturalWidth || n2.width) || 0, o2 = Number(n2.naturalHeight || n2.height) || 0;
+  if (!r2 || !o2) return null;
+  const s2 = (function texScratchCtx(e3, n3) {
+    if ("undefined" == typeof document) return null;
+    if (!u) {
+      u = document.createElement("canvas");
+      const e4 = u.getContext("2d");
+      e4 && t.ignore2DContext(e4);
+    }
+    u.width === e3 && u.height === n3 || (u.width = e3, u.height = n3);
+    const r3 = u.getContext("2d");
+    return r3 && t.ignore2DContext(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 f = null;
+function setUntrackedGLContextNotifier(e2) {
+  f = e2;
+}
+let p = null;
+const h = /* @__PURE__ */ new Map();
+function setGLAutoAttach(e2) {
+  p = 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, n2) {
+    var _a, _b, _c;
+    const r2 = this.assetBySource.get(e2);
+    if (void 0 !== r2) return { $: "imagedata", id: r2 };
+    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 t2 = e3;
+      return (Number(t2.naturalWidth || t2.width) || 0) * (Number(t2.naturalHeight || t2.height) || 0) * 4;
+    })(e2) > 7340032) return { $: "unsupported", kind: "texture-too-large" };
+    let o2;
+    try {
+      o2 = texSourceToImageData(e2);
+    } catch (e3) {
+      return t.isTaintError(e3) ? ((_b = (_a = this.sink).onTaint) == null ? void 0 : _b.call(_a, n2), { $: "unsupported", kind: "texture-tainted" }) : { $: "unsupported", kind: "texture" };
+    }
+    if (!o2) return { $: "unsupported", kind: ((_c = e2.constructor) == null ? void 0 : _c.name) ?? "texture" };
+    const s2 = this.nextAssetId++;
+    this.assetCount++, this.assetBySource.set(e2, s2);
+    const a2 = o2.width, i2 = o2.height, c2 = new Uint8Array(o2.data.buffer.slice(o2.data.byteOffset, o2.data.byteOffset + o2.data.byteLength));
+    return this.trackEncode(t.deflate(c2).then((e3) => {
+      var _a2, _b2;
+      this.sink.onAssetBytes(s2, e3.length, n2), (_b2 = (_a2 = this.sink).onAssetData) == null ? void 0 : _b2.call(_a2, { id: s2, format: "imagedata", w: a2, h: i2, t: n2 }, e3);
+    }).catch((e3) => this.sink.note(`GL texture asset deflate failed: ${e3.message}`))), { $: "imagedata", id: s2 };
+  }
+  swapSink(e2) {
+    var _a;
+    const n2 = this.sink;
+    if (this.sink = e2, this.bound = true, n2 instanceof t.BufferSink) {
+      for (const t2 of n2.ops) e2.onOp(t2);
+      for (const t2 of n2.assetEvents) e2.onAssetBytes(t2.id, t2.bytes, t2.t);
+      for (const t2 of n2.assetData) (_a = e2.onAssetData) == null ? void 0 : _a.call(e2, t2.info, t2.payload);
+      for (const t2 of n2.notes) e2.note(t2);
+    }
+  }
+  recordCall(e2, n2, r2) {
+    if (this.sink instanceof t.DiscardSink) return this.sink.onOp(t.DIRTY_OP), void (this.pendingSiteId = void 0);
+    const o2 = performance.now(), s2 = this.now(), c2 = this.pendingSiteId;
+    if (this.pendingSiteId = void 0, (a.test(e2) || i.has(e2)) && r2 && "object" == typeof r2) {
+      const t2 = this.nextId++;
+      this.refs.set(r2, t2), this.sink.onOp({ t: s2, op: "__create", create: true, args: [e2, t2, ...n2.map((e3) => this.arg(e3, s2))] });
+    } else {
+      const t2 = { t: s2, op: e2, args: n2.map((e3) => this.arg(e3, s2)) };
+      c2 && (t2.sfId = c2), this.sink.onOp(t2);
+    }
+    this.cpuMs += performance.now() - o2;
+  }
+  arg(e2, n2) {
+    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 r2 = e2, o2 = this.refs.get(r2);
+    return void 0 !== o2 ? { $: "obj", id: o2 } : ArrayBuffer.isView(r2) || r2 instanceof ArrayBuffer ? t.serializeTypedArray(r2) : Array.isArray(r2) ? { $: "arr", v: r2.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;
+    })(r2) ? this.captureTexSource(r2, n2) : { $: "unsupported", kind: ((_a = r2.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, l.set(s2, a2), a2;
+}
+function detachGLRecorderFromContext(e2) {
+  l.delete(e2);
+}
+const m = 7340032, v = "__gpu";
+let y = false, g = null, w = null, k = false, C = false;
+function setGPUDeviceLostNotifier(e2) {
+  w = e2, k = false, C = false;
+}
+let b = null, nowFn = () => 0, x = 0, S = 3e6, R = false, L = null, I = null;
+const M = /* @__PURE__ */ new WeakMap(), T = /* @__PURE__ */ new WeakMap(), E = /* @__PURE__ */ new WeakMap();
+function emit(e2) {
+  b == null ? void 0 : b.onOp(e2);
+}
+function intern(e2) {
+  let t2 = M.get(e2);
+  return void 0 === t2 && (t2 = S++, M.set(e2, t2)), t2;
+}
+function deproxy(e2) {
+  return e2 && "object" == typeof e2 && E.has(e2) ? E.get(e2) : e2;
+}
+function deepDeproxy(e2) {
+  if (!e2 || "object" != typeof e2) return e2;
+  if (E.has(e2)) return E.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 D = 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 n2 = deproxy(e2);
+  if (ArrayBuffer.isView(n2) || n2 instanceof ArrayBuffer) return n2.byteLength > m ? { $: "unsupported", kind: "buffer-too-large" } : t.serializeTypedArray(n2);
+  const r2 = M.get(n2);
+  if (void 0 !== r2) return { $: "obj", id: r2 };
+  try {
+    return "json:" + JSON.stringify(n2, (e3, n3) => {
+      if (n3 && "object" == typeof n3) {
+        const e4 = deproxy(n3), r3 = M.get(e4);
+        if (void 0 !== r3) return { __sfRef: r3 };
+        if (ArrayBuffer.isView(e4)) {
+          const n4 = e4;
+          if (n4.byteLength > m) return { __sfUnsupported: "buffer-too-large" };
+          const r4 = t.TYPED_ARRAY_KINDS.findIndex((e5) => n4 instanceof e5);
+          return r4 < 0 ? { __sfUnsupported: "typed-array-kind" } : { __sfTa: Array.from(n4), __sfK: r4 };
+        }
+        return e4 === n3 ? n3 : e4;
+      }
+      return n3;
+    });
+  } catch {
+    return { $: "unsupported", kind: ((_a = n2.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 n2 = T.get(e2);
+  if (n2) return n2;
+  "GPUDevice" === ((_a = e2.constructor) == null ? void 0 : _a.name) && (function watchDeviceLost(e3) {
+    const t2 = e3.lost;
+    if (t2 && "function" == typeof t2.then) {
+      if (C && !k) {
+        k = true;
+        try {
+          w == null ? void 0 : w(false);
+        } catch {
+        }
+      }
+      t2.then((e4) => {
+        if (!(e4 && "destroyed" === e4.reason || C)) {
+          C = true;
+          try {
+            w == null ? void 0 : w(true);
+          } catch {
+          }
+        }
+      }).catch(() => {
+      });
+    }
+  })(e2);
+  const r2 = new Proxy(e2, { get(e3, n3, r3) {
+    const o2 = Reflect.get(e3, n3, e3);
+    if ("symbol" == typeof n3) return o2;
+    if ("function" == typeof o2) return (...r4) => {
+      const s2 = performance.now(), a2 = r4.map(deepDeproxy), i2 = o2.apply(e3, a2);
+      if (b instanceof t.DiscardSink) return b.onOp(t.DIRTY_OP), i2 && "object" == typeof i2 && "function" == typeof i2.then ? i2.then((e4) => e4 && "object" == typeof e4 && shouldProxyResult(e4) ? (intern(e4), wrap(e4)) : e4) : shouldProxyResult(i2) ? (intern(i2), wrap(i2)) : i2;
+      if (b) {
+        const t2 = intern(e3);
+        if (i2 && "object" == typeof i2 && "function" == typeof i2.then) {
+          const e4 = S++;
+          return emit({ t: nowFn(), op: v, objcall: true, args: [t2, String(n3), e4, ...r4.map(D)] }), x += performance.now() - s2, i2.then((t3) => t3 && "object" == typeof t3 ? (M.set(t3, e4), wrap(t3)) : t3);
+        }
+        let o3 = 0;
+        return shouldProxyResult(i2) && (o3 = intern(i2)), emit({ t: nowFn(), op: v, objcall: true, args: [t2, String(n3), o3, ...r4.map(D)] }), x += performance.now() - s2, shouldProxyResult(i2) ? wrap(i2) : i2;
+      }
+      return i2 && "object" == typeof i2 && "function" == typeof i2.then ? i2.then((e4) => e4 && "object" == typeof e4 && shouldProxyResult(e4) ? (intern(e4), wrap(e4)) : e4) : shouldProxyResult(i2) ? (intern(i2), wrap(i2)) : i2;
+    };
+    if (shouldProxyResult(o2)) {
+      const r4 = M.has(o2), s2 = intern(o2);
+      return r4 || !b || b instanceof t.DiscardSink || emit({ t: nowFn(), op: "__gpuprop", objcall: true, args: [intern(e3), String(n3), s2] }), wrap(o2);
+    }
+    return o2;
+  } });
+  return T.set(e2, r2), E.set(r2, e2), r2;
+}
+function setGPUAutoAttach(e2) {
+  g = e2, e2 && (nowFn = e2.now, b || (b = new t.BufferSink(), R = false));
+}
+const P = ["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 P) 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 B = 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: B, 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: B, 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 A = /* @__PURE__ */ new WeakMap(), O = /* @__PURE__ */ new Map();
+let G = false, V = null;
+function setWorkerAssociationNotifier(e2) {
+  V = e2;
+}
+const U = 1048576, W = { deviceClass: "desktop", sessionByteBudget: 256 * U, maxConcurrentVideo: 4, governor: {}, preferMediaRecorder: false }, F = { deviceClass: "mobile", sessionByteBudget: 96 * U, maxConcurrentVideo: 2, governor: { maxBytesPerSec: 262144, maxOpsPerFrame: 3e3 }, preferMediaRecorder: false }, K = { deviceClass: "mobile-lowend", sessionByteBudget: 48 * U, 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 W;
+  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 ? K : F : o2 && s2 ? K : W, 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));
+}
+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 $ = null;
+const now = () => Date.now(), encodeImage = (e2) => encodeBitmap(e2, 0.85, true);
+function noteOnce(e2) {
+  var _a;
+  if ($ && !$.notes.has(e2)) {
+    $.notes.add(e2);
+    try {
+      (_a = console.debug) == null ? void 0 : _a.call(console, "[Sailfish][canvas]", e2);
+    } catch {
+    }
+  }
+}
+function emitEvent(e2) {
+  if ($) try {
+    $.deps.addSailfishEvent(e2);
+  } catch {
+  }
+}
+function sendFrame(e2, n2, r2, o2, s2 = Date.now()) {
+  const a2 = $;
+  if (!a2) return;
+  const i2 = null == o2 ? 0 : o2.byteLength;
+  if (i2 > 8388608) return void noteOnce(`oversize ${n2} frame dropped (${i2}B > 8MiB)`);
+  const c2 = a2.budgets.sessionByteBudget;
+  if (a2.lastBudgetTickMs > 0 && (a2.totalBytes = decayBytes(a2.totalBytes, c2, 6e4, s2 - a2.lastBudgetTickMs)), a2.lastBudgetTickMs = Math.max(a2.lastBudgetTickMs, s2), a2.totalBytes > c2) return void (a2.budgetExceeded || (a2.budgetExceeded = true, noteOnce("per-session canvas byte budget exceeded — capture paused (auto-resumes as it drains)")));
+  a2.budgetExceeded && (a2.budgetExceeded = false);
+  const d2 = a2.deps.getContextIds(), l2 = t.buildFrame({ v: 1, kind: n2, sessionId: d2.session_id ?? "", pageVisitUuid: d2.page_visit_uuid ?? "", canvasId: e2.canvasId, seq: e2.seq++, tMs: s2, meta: r2 }, o2);
+  try {
+    a2.deps.sendBinary(l2);
+  } catch {
+    return;
+  }
+  a2.totalBytes += l2.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, !$ || 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, n2) {
+  if (!e2.encoder || 0 === e2.encoder.ops) return;
+  const r2 = e2.encoder.takeBatch(), o2 = t.deflate(r2);
+  e2.flushChain = e2.flushChain.then(async () => {
+    const t2 = await o2;
+    e2.governor.addBytes(t2.length), sendFrame(e2, "commands", { codec: "sfc-bin-1", compression: "deflate" }, t2), 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, n2) {
+  var _a;
+  e2.demoted = true, flushBatch(e2), (_a = e2.keyframes) == null ? void 0 : _a.takeKeyframe(now());
+  const r2 = new t.DiscardSink(() => markDirty(e2));
+  if (e2.recorder2d && e2.recorder2d.swapSink(r2), e2.recorderGL && e2.recorderGL.swapSink(r2), e2.recorderGPU && (function swapGPUSink(e3) {
+    b && (b = e3);
+  })(r2), !($ == null ? void 0 : $.budgets.preferMediaRecorder) || !tryStartMediaRecorder(e2, n2)) if (VideoCapture.supported()) {
+    if (!tryAcquireVideoSlot(e2)) return e2.mode = "none", noteOnce(`video-encoder cap (${($ == null ? void 0 : $.budgets.maxConcurrentVideo) ?? 4}) reached — canvas kept on keyframes`), void emitEvent({ op: "mode", canvasId: e2.canvasId, mode: "none", reason: `${n2} (video-encoder cap reached — keyframes only)` });
+    e2.mode = "video", emitEvent({ op: "mode", canvasId: e2.canvasId, mode: "video", reason: n2 });
+    const t2 = makeVideo(e2, false);
+    e2.video = t2, t2.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, n2) || (e2.mode = "none", emitEvent({ op: "mode", canvasId: e2.canvasId, mode: "none", reason: `${n2} (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 n2 = $;
+  if (n2 && e2.keyframes && !t.wasPreAttachMaskUsed(e2.canvas) && n2.preExisting.has(e2.canvas)) {
+    n2.preExisting.delete(e2.canvas);
+    try {
+      e2.keyframes.initialKeyframe(now());
+    } catch {
+    }
+  }
+}
+function tryAcquireVideoSlot(e2) {
+  const t2 = $;
+  return !!t2 && (!!e2.hasVideoSlot || !!t2.videoSlots.acquire() && (e2.hasVideoSlot = true, true));
+}
+function releaseVideoSlot(e2) {
+  e2.hasVideoSlot && (e2.hasVideoSlot = false, $ == null ? void 0 : $.videoSlots.release());
+}
+function makeVideo(e2, n2) {
+  return new VideoCapture(e2.canvas, now, { onInit: (n3, r2) => sendFrame(e2, "video-init", { codec: n3, description: r2 ? t.bytesToBase64(r2) : null }, null), onChunk: (t2, n3, r2) => sendFrame(e2, "video-chunk", { key: t2, timestampUs: n3 }, r2), note: noteOnce, isTransportSaturated: ($ == null ? void 0 : $.deps.isTransportSaturated) ? () => {
+    var _a, _b;
+    return !!((_b = $ == null ? void 0 : (_a = $.deps).isTransportSaturated) == null ? void 0 : _b.call(_a));
+  } : void 0 }, { intervalPaced: n2 });
+}
+function tryStartMediaRecorder(e2, t2) {
+  if (!MediaRecorderCapture.supported()) return false;
+  if (!tryAcquireVideoSlot(e2)) return noteOnce(`video-encoder cap (${($ == null ? void 0 : $.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 = $ == null ? void 0 : $.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 $ ? t.classifyCanvasPrivacy(e2, $.privacySettings) : "normal";
+}
+function makeTextRedactor(e2) {
+  if ("redact" === e2) return (e3) => t.redactCanvasText(e3, "redact", {});
+  if ("normal" === e2 && (function contentDetectionActive() {
+    const e3 = $ == null ? void 0 : $.contentFlags;
+    return !!e3 && (false === e3.recordCreditCardInfo || false === e3.recordSsn || false === e3.recordDob);
+  })()) {
+    const e3 = $.contentFlags;
+    return (n2) => t.redactCanvasText(n2, "normal", e3);
+  }
+}
+function emitMasked(e2, n2) {
+  const r2 = $ ? t.suppressReason(e2, $.privacySettings) : void 0, o2 = { op: "masked", canvasId: n2 };
+  r2 && (o2.reason = r2), emitEvent(o2), $ == null ? void 0 : $.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 (!$ || $.stopped) return t2(null);
+      let r2 = -1;
+      try {
+        r2 = $.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 = $;
+  t2 && !t2.stopped && (t2.handled.delete(e2), t2.suppressed.delete(e2), considerCanvas(e2));
+}
+function reevaluateAllMasking() {
+  const e2 = $;
+  if (e2 && !e2.stopped) {
+    for (const n2 of [...e2.controllers.values()]) {
+      if (n2.stopped) continue;
+      const r2 = n2.canvas, o2 = t.classifyCanvasPrivacy(r2, e2.privacySettings);
+      if ("suppress" === o2) {
+        const t2 = n2.canvasId;
+        teardownController(n2), e2.handled.add(r2), emitMasked(r2, t2);
+        continue;
+      }
+      o2 !== n2.privacyMode && (teardownController(n2), r2.isConnected && rearmCanvas(r2));
+    }
+    for (const n2 of [...e2.suppressed]) {
+      if (!n2.isConnected) {
+        e2.suppressed.delete(n2);
+        continue;
+      }
+      "suppress" !== t.classifyCanvasPrivacy(n2, e2.privacySettings) && rearmCanvas(n2);
+    }
+  }
+}
+function onCanvasRemoved(e2) {
+  const t2 = $;
+  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 n2 = $;
+  if (!n2 || n2.stopped || n2.handled.has(e2)) return;
+  if (!e2.isConnected) return t.releaseAutoRecorder(e2), void noteOnce("disconnected canvas skipped — recorded only if attached to the document");
+  const r2 = classify(e2);
+  if ("suppress" === r2) return n2.handled.add(e2), void resolveCanvasId(e2).then((t2) => {
+    null != t2 && emitMasked(e2, t2);
+  });
+  const o2 = (function getWorkerForCanvas(e3) {
+    return O.get(e3);
+  })(e2), s2 = t.getContextInfo(e2);
+  (o2 || s2) && (n2.handled.add(e2), resolveCanvasId(e2).then((n3) => {
+    if (null != n3 && $ && !$.stopped) if (o2) {
+      if ("redact" === r2) return noteOnce("redact worker/offscreen canvas — escalated to suppress (no DOM to redact)"), void emitMasked(e2, n3);
+      !(async function buildWorkerController(e3, t2, n4) {
+        const r3 = await (function pingWorkerShim(e4, t3 = 500) {
+          return new Promise((n5) => {
+            let r4 = false;
+            const finish = (t4) => {
+              r4 || (r4 = true, clearTimeout(o4), e4.removeEventListener("message", onMsg), n5(t4));
+            }, onMsg = (e5) => {
+              var _a;
+              "sf-record-pong" === ((_a = e5.data) == null ? void 0 : _a.type) && finish(true);
+            }, o4 = setTimeout(() => finish(false), t3);
+            e4.addEventListener("message", onMsg);
+            try {
+              e4.postMessage({ type: "sf-record-ping" });
+            } catch {
+              finish(false);
+            }
+          });
+        })(n4), o3 = $;
+        if (!o3 || o3.stopped) return;
+        if (r3) {
+          const r4 = baseController(e3, t2, "worker", "commands");
+          let s4;
+          r4.worker = n4, r4.workerDone = new Promise((e4) => {
+            s4 = e4;
+          });
+          const onMsg = (e4) => {
+            const t3 = e4.data;
+            if ("sf-record-done" === (t3 == null ? void 0 : t3.type)) s4(t3);
+            else if ("sf-record-noctx" === (t3 == null ? void 0 : t3.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 (${($ == null ? void 0 : $.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" === (t3 == null ? void 0 : t3.type) && (sendFrame(r4, "commands", { codec: "sfc-bin-1", compression: "deflate" }, new Uint8Array(t3.deflated), t3.tMs), r4.governor.addBytes(t3.deflated.byteLength));
+          };
+          n4.addEventListener("message", onMsg), r4.removeWorkerListener = () => n4.removeEventListener("message", onMsg);
+          try {
+            n4.postMessage({ type: "sf-record-start", contentFlags: o3.contentFlags });
+          } catch {
+            noteOnce("worker postMessage failed — worker canvas not recorded");
+          }
+          return o3.controllers.set(e3, r4), void emitStart(r4);
+        }
+        const s3 = baseController(e3, t2, "worker", "none");
+        if (o3.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 (${($ == null ? void 0 : $.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, n3, o2);
+    } else if ("2d" === s2.type) build2DController(e2, n3, null, r2);
+    else if ("webgl" === s2.type || "webgl2" === s2.type || "experimental-webgl" === s2.type) {
+      const o3 = escalateRedactIfPixelText(r2, s2.type);
+      if ("suppress" === o3) return void emitMasked(e2, n3);
+      !(function buildGLController(e3, n4, r3, o4, s3 = "normal") {
+        const a2 = $;
+        if (!a2 || a2.stopped) return;
+        const i2 = "experimental-webgl" === r3 ? "webgl" : r3;
+        if ("suppress" === escalateRedactIfPixelText(s3, i2)) return void emitMasked(e3, n4);
+        const c2 = baseController(e3, n4, i2, "commands", s3);
+        c2.encoder = new t.CommandEncoder();
+        const d2 = makeCommandSink(c2);
+        let l2;
+        l2 = attachGLRecorder(e3, r3, d2, now), l2 || (c2.mode = "none", noteOnce("GL context not reachable — nothing recorded"));
+        c2.recorderGL = l2, c2.keyframes = makeKeyframes(c2), installGLContextLossHandling(c2), a2.controllers.set(e3, c2), emitStart(c2), maybeInitialKeyframe(c2);
+      })(e2, n3, s2.type, 0, o3);
+    } else if ("webgpu" === s2.type) {
+      const o3 = escalateRedactIfPixelText(r2, "webgpu");
+      if ("suppress" === o3) return void emitMasked(e2, n3);
+      !(function buildGPUController(e3, n4, r3 = "normal") {
+        const o4 = $;
+        if (!o4 || o4.stopped) return;
+        if ("suppress" === escalateRedactIfPixelText(r3, "webgpu")) return void emitMasked(e3, n4);
+        const s3 = baseController(e3, n4, "webgpu", "commands", r3);
+        s3.encoder = new t.CommandEncoder();
+        const a2 = (function attachGPURecorder(e4, n5, r4) {
+          if (L !== e4 || !b) return null;
+          I = e4, nowFn = r4;
+          const o5 = b;
+          if (b = n5, o5 instanceof t.BufferSink) {
+            for (const e5 of o5.ops) n5.onOp(e5);
+            for (const e5 of o5.notes) n5.note(e5);
+          }
+          return { detach() {
+            b = null, I = null, L = 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((t2) => {
+            var _a;
+            if (!e4.stopped) if (t2) {
+              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), o4.controllers.set(e3, s3), emitStart(s3), maybeInitialKeyframe(s3);
+      })(e2, n3, o3);
+    } else {
+      const t2 = baseController(e2, n3, "unknown", "none");
+      $.controllers.set(e2, t2), emitStart(t2), noteOnce(`unsupported context type "${s2.type}" — not captured`);
+    }
+  }));
+}
+function build2DController(e2, n2, r2, o2 = "normal") {
+  const s2 = $;
+  if (!s2 || s2.stopped) return;
+  const a2 = baseController(e2, n2, "2d", "commands", o2);
+  a2.encoder = new t.CommandEncoder();
+  const i2 = makeCommandSink(a2);
+  let c2 = r2;
+  c2 ? c2.swapSink(i2) : c2 = t.attachRecorder(e2, i2, now, "cas", encodeImage, { retainAssets: false }), c2 || (a2.mode = "none", noteOnce("canvas has no readable 2D context — nothing recorded")), c2 && (c2.textRedactor = makeTextRedactor(o2), c2.redactStyle = s2.redactStyle), a2.recorder2d = c2, a2.keyframes = makeKeyframes(a2), s2.controllers.set(e2, a2), emitStart(a2), maybeInitialKeyframe(a2);
+}
+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 n2 = $;
+  if (!n2 || n2.stopped || n2.seenContexts.has(e2)) return;
+  n2.seenContexts.add(e2);
+  const r2 = e2.canvas;
+  if (!(r2 instanceof HTMLCanvasElement)) return;
+  if (!r2.isConnected) return;
+  if (n2.handled.has(r2)) return;
+  const o2 = classify(r2);
+  if ("suppress" === o2) return n2.handled.add(r2), void resolveCanvasId(r2).then((e3) => {
+    null != e3 && emitMasked(r2, e3);
+  });
+  n2.handled.add(r2);
+  const s2 = t.attachRecorderToContext(e2, new t.BufferSink(), now, "cas", encodeImage, { retainAssets: false });
+  resolveCanvasId(r2).then((n3) => {
+    null != n3 && $ && !$.stopped ? build2DController(r2, n3, s2, o2) : t.detachRecorderFromContext(e2);
+  });
+}
+function onUntrackedGL(e2) {
+  const n2 = $;
+  if (!n2 || n2.stopped || n2.seenContexts.has(e2)) return;
+  n2.seenContexts.add(e2);
+  const r2 = e2.canvas;
+  if (!(r2 instanceof HTMLCanvasElement)) return;
+  if (!r2.isConnected) return;
+  if (n2.handled.has(r2)) return;
+  const o2 = classify(r2), s2 = "undefined" != typeof WebGL2RenderingContext && e2 instanceof WebGL2RenderingContext ? "webgl2" : "webgl";
+  if ("suppress" === o2 || "suppress" === escalateRedactIfPixelText(o2, s2)) return n2.handled.add(r2), void resolveCanvasId(r2).then((e3) => {
+    null != e3 && emitMasked(r2, e3);
+  });
+  n2.handled.add(r2);
+  const a2 = s2, i2 = new t.BufferSink(), c2 = (function attachGLRecorderToContext(e3, t2, n3) {
+    const r3 = new GLRecorder(t2, n3);
+    return r3.rawCtx = e3, r3.bound = true, l.set(e3, r3), r3;
+  })(e2, i2, now);
+  resolveCanvasId(r2).then((n3) => {
+    if (null == n3 || !$ || $.stopped) return void detachGLRecorderFromContext(e2);
+    const s3 = $, i3 = baseController(r2, n3, a2, "commands", o2);
+    i3.encoder = new t.CommandEncoder(), c2.swapSink(makeCommandSink(i3)), i3.recorderGL = c2, i3.keyframes = makeKeyframes(i3), installGLContextLossHandling(i3), s3.controllers.set(r2, i3), emitStart(i3), maybeInitialKeyframe(i3);
+  });
+}
+function teardownController(e2) {
+  var _a, _b, _c, _d, _e, _f, _g;
+  if (e2.stopped) $ == null ? void 0 : $.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 && t.detachRecorderFromContext(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 {
+    }
+    $ == null ? void 0 : $.controllers.delete(e2.canvas);
+  }
+}
+function settleOrTimeout(e2, t2) {
+  return Promise.race([e2.catch(() => {
+  }), new Promise((e3) => setTimeout(e3, t2))]);
+}
+async function stopController(e2, n2) {
+  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 n3 = await Promise.race([e2.workerDone, new Promise((e3) => setTimeout(() => e3(null), 5e3))]);
+      (_b = e2.removeWorkerListener) == null ? void 0 : _b.call(e2), n3 && await (async function convertWorkerResult(e3, n4) {
+        for (const e4 of n4.notes ?? []) noteOnce(`worker: ${e4}`);
+        for (const r2 of n4.batches ?? []) try {
+          sendFrame(e3, "commands", { codec: "sfc-bin-1", compression: "deflate" }, await t.deflate(r2));
+        } catch {
+        }
+        for (const r2 of n4.assets ?? []) try {
+          if (r2.bitmap) {
+            const t2 = r2.w ?? r2.bitmap.width, n5 = r2.h ?? r2.bitmap.height, o2 = await encodeBitmap(r2.bitmap, 0.85, true);
+            o2.bytes && sendFrame(e3, "asset", { assetId: r2.id, format: "webp", w: t2, h: n5 }, o2.bytes);
+          } else if (r2.imageData) {
+            const n5 = r2.imageData, o2 = await t.deflate(new Uint8Array(n5.data.buffer, n5.data.byteOffset, n5.data.byteLength));
+            sendFrame(e3, "asset", { assetId: r2.id, format: "imagedata", w: n5.width, h: n5.height }, o2);
+          }
+        } catch {
+        }
+      })(e2, n3), 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(n2), await e2.keyframes.stop(n2)), e2.recorder2d && (t.detachRecorderFromContext(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 });
+  }
+}
+const N = { initState(e2) {
+  $ = { deps: e2, maskSelector: ".sailfishSanitize, [data-sf-mask]", privacySettings: derivePrivacySettings(e2.settings), contentFlags: deriveContentFlags(e2.settings), redactStyle: t.resolveRedactStyle(t.DEFAULT_REDACT_STYLE, 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 $.controllers.set(e2, r2), r2;
+}, classify: (e2) => classify(e2), makeTextRedactor: (e2) => makeTextRedactor(e2), reevaluate() {
+  reevaluateAllMasking();
+}, escalate: (e2, t2) => escalateRedactIfPixelText(e2, t2), isTracked: (e2) => !!($ == null ? void 0 : $.controllers.get(e2)), isSuppressed: (e2) => !!($ == null ? void 0 : $.suppressed.has(e2)), markSuppressed(e2) {
+  $ == null ? void 0 : $.handled.add(e2), $ == null ? void 0 : $.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: $ == null ? void 0 : $.controllers.get(e2), redactor: r2.textRedactor };
+}, demote(e2, t2 = "bytes") {
+  demote(e2, t2);
+}, teardown(e2) {
+  teardownController(e2);
+}, slotsInUse: () => ($ == null ? void 0 : $.videoSlots.inUse) ?? -1, controllerHasSlot: (e2) => e2.hasVideoSlot, reset() {
+  $ = null;
+} };
+exports.MAX_CONCURRENT_VIDEO_CANVASES = 4, exports.VideoSlotPool = VideoSlotPool, exports.__canvasManagerTestHooks = N, exports.collectMalformedSelectors = collectMalformedSelectors, exports.decayBytes = decayBytes, exports.flushAllCanvas = async function flushAllCanvas() {
+  const e2 = $;
+  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(() => {
+  });
+}, exports.isCanvasRecordingActive = function isCanvasRecordingActive() {
+  return null != $ && !$.stopped;
+}, exports.settleOrTimeout = settleOrTimeout, exports.startCanvasRecording = function startCanvasRecording(n2) {
+  if ("undefined" == typeof window || "undefined" == typeof document) return;
+  if ($) return;
+  const r2 = n2.settings.maskCanvasClass || "sailfishSanitize", o2 = resolveDeviceBudgets();
+  $ = { deps: n2, maskSelector: `.${r2}, [data-sf-mask]`, privacySettings: derivePrivacySettings(n2.settings), contentFlags: deriveContentFlags(n2.settings), redactStyle: t.resolveRedactStyle(t.DEFAULT_REDACT_STYLE, n2.settings.canvasRedactStyle), budgets: o2, 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(o2.maxConcurrentVideo) };
+  for (const e2 of collectMalformedSelectors(n2.settings)) noteOnce(`malformed canvas privacy selector "${e2}" is invalid and will not match — that privacy rule is disabled`);
+  t.installCommandHooks(), (function installGLHooks() {
+    if (d) return;
+    d = true;
+    const e2 = [];
+    "undefined" != typeof WebGLRenderingContext && e2.push(WebGLRenderingContext.prototype), "undefined" != typeof WebGL2RenderingContext && e2.push(WebGL2RenderingContext.prototype);
+    for (const t2 of e2) for (const e3 of Object.getOwnPropertyNames(t2)) {
+      const n4 = Object.getOwnPropertyDescriptor(t2, e3);
+      if (!n4 || "function" != typeof n4.value || "constructor" === e3) continue;
+      if (c.test(e3) && !i.has(e3)) continue;
+      const r3 = n4.value;
+      t2[e3] = function(...t3) {
+        const n5 = r3.apply(this, t3), o3 = l.get(this);
+        return o3 ? o3.recordCall(e3, t3, n5) : f && f(this), n5;
+      };
+    }
+    if ("undefined" == typeof HTMLCanvasElement) return;
+    const n3 = HTMLCanvasElement.prototype.getContext;
+    HTMLCanvasElement.prototype.getContext = function(e3, r3) {
+      const o3 = n3.call(this, e3, r3);
+      if (("webgl" === e3 || "webgl2" === e3 || "experimental-webgl" === e3) && o3 && p && !l.has(o3)) {
+        const e4 = new GLRecorder(new t.BufferSink(), p.now);
+        e4.rawCtx = o3, l.set(o3, e4), h.set(this, e4);
+      }
+      return o3;
+    };
+  })(), (function installGPUHooks() {
+    if (y) return;
+    if (y = true, "undefined" == typeof navigator || !("gpu" in navigator)) return;
+    const e2 = navigator.gpu;
+    if (Object.defineProperty(navigator, "gpu", { configurable: true, get() {
+      if (g || b) {
+        if (!R) {
+          R = true;
+          const t3 = intern(e2);
+          emit({ t: nowFn(), op: "__gpuroot", args: [t3] });
+        }
+        return wrap(e2);
+      }
+      return e2;
+    } }), "undefined" == typeof HTMLCanvasElement) return;
+    const t2 = HTMLCanvasElement.prototype.getContext;
+    HTMLCanvasElement.prototype.getContext = function(e3, n3) {
+      const r3 = t2.call(this, e3, n3);
+      if ("webgpu" === e3 && r3 && (g || b)) {
+        L = this;
+        const e4 = M.has(r3), t3 = intern(r3);
+        return e4 || emit({ t: nowFn(), op: "__gpuctx", args: [t3] }), wrap(r3);
+      }
+      return r3;
+    };
+  })(), (function installWorkerRelay() {
+    if (!G) {
+      if (G = true, "undefined" != typeof HTMLCanvasElement && "function" == typeof HTMLCanvasElement.prototype.transferControlToOffscreen) {
+        const e2 = HTMLCanvasElement.prototype.transferControlToOffscreen;
+        HTMLCanvasElement.prototype.transferControlToOffscreen = function() {
+          const t2 = e2.call(this);
+          return A.set(t2, this), t2;
+        };
+      }
+      if ("undefined" != typeof Worker) {
+        const e2 = Worker.prototype.postMessage;
+        Worker.prototype.postMessage = function(t2, n3) {
+          const r3 = Array.isArray(n3) ? n3 : n3 == null ? void 0 : n3.transfer;
+          if (r3) for (const e3 of r3) {
+            const t3 = e3 && "object" == typeof e3 ? A.get(e3) : void 0;
+            t3 && !O.has(t3) && (O.set(t3, this), V == null ? void 0 : V(t3, this));
+          }
+          return e2.apply(this, [t2, n3]);
+        };
+      }
+    }
+  })(), t.setAutoAttach({ now, assetMode: "cas", encodeImage, retainAssets: false }), setGLAutoAttach({ now }), setGPUAutoAttach({ now }), t.setContextCreatedNotifier((e2) => {
+    queueMicrotask(() => considerCanvas(e2));
+  }), t.setUntracked2DContextNotifier(onUntracked2D), setUntrackedGLContextNotifier(onUntrackedGL), setWorkerAssociationNotifier((e2) => considerCanvas(e2)), globalThis.__sfDrawSite = (e2, n3) => (e2 && "object" == typeof e2 && (t.noteCtxPendingSiteId(e2, n3) || (function noteGLPendingSiteId(e3, t2) {
+    const n4 = l.get(e3);
+    return !!n4 && (n4.pendingSiteId = t2, true);
+  })(e2, n3)), e2), e.installAdapters({ canvasIdFor: (e2) => {
+    var _a;
+    return ((_a = $ == null ? void 0 : $.controllers.get(e2)) == null ? void 0 : _a.canvasId) ?? null;
+  }, emitHit: (e2) => emitEvent(e2), now });
+  const onInteraction = () => {
+    var _a, _b, _c;
+    const e2 = $;
+    if (!e2 || e2.stopped) return;
+    const t2 = now();
+    for (const n3 of e2.controllers.values()) n3.stopped || ("video" === n3.mode ? ((_a = n3.video) == null ? void 0 : _a.onInteraction(t2), (_b = n3.mediaRecorder) == null ? void 0 : _b.onInteraction(t2)) : (_c = n3.keyframes) == null ? void 0 : _c.onInteraction(t2));
+  };
+  window.addEventListener("pointerdown", onInteraction, { capture: true, passive: true }), window.addEventListener("keydown", onInteraction, { capture: true, passive: true }), $.removeListeners.push(() => {
+    window.removeEventListener("pointerdown", onInteraction, { capture: true }), window.removeEventListener("keydown", onInteraction, { capture: true });
+  });
+  const s2 = new MutationObserver((e2) => {
+    let t2 = 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)));
+    })) : t2 = true;
+    t2 && reevaluateAllMasking();
+  });
+  s2.observe(document.documentElement, { childList: true, subtree: true, attributes: true }), $.observer = s2, document.querySelectorAll("canvas").forEach((e2) => {
+    $.preExisting.add(e2), considerCanvas(e2);
+  });
+}, exports.stopCanvasRecording = async function stopCanvasRecording() {
+  var _a;
+  const r2 = $;
+  if (!r2 || r2.stopped) return;
+  r2.stopped = true, t.setAutoAttach(null), setGLAutoAttach(null), setGPUAutoAttach(null), setGPUDeviceLostNotifier(null), t.setContextCreatedNotifier(null), t.setUntracked2DContextNotifier(null), setUntrackedGLContextNotifier(null), setWorkerAssociationNotifier(null), delete globalThis.__sfDrawSite, e.uninstallAdapters(), (_a = r2.observer) == null ? void 0 : _a.disconnect();
+  for (const e2 of r2.removeListeners) try {
+    e2();
+  } catch {
+  }
+  const s2 = now();
+  await Promise.all([...r2.controllers.values()].map((e2) => stopController(e2, s2).catch(() => {
+  }))), t.pruneUnboundRecorders(), (function pruneUnboundGLRecorders() {
+    for (const [e2, t2] of h) t2.bound || (l.delete(t2.rawCtx), h.delete(e2));
+  })(), (function pruneUnboundGPURecorders() {
+    b instanceof t.BufferSink && !I && (L || (b = null));
+  })(), (function terminateImgEncoder() {
+    n && (n.terminate(), n = null);
+    for (const [e2, t2] of o) o.delete(e2), t2({ size: 0 });
+  })(), $ = null;
+};