@capturly/capture-sdk 2.10.2

package/dist/index.js

@@ -0,0 +1,4556 @@
+var MP4_MIME = "video/mp4;codecs=avc1.42E01E,mp4a.40.2";
+function pickMuxStrategy() {
+  if (typeof MediaRecorder !== "undefined" && MediaRecorder.isTypeSupported(MP4_MIME)) {
+    return "mediarecorder-mp4";
+  }
+  if (typeof globalThis.VideoEncoder !== "undefined" && typeof globalThis.AudioEncoder !== "undefined" && "MediaStreamTrackProcessor" in globalThis) {
+    return "webcodecs-mp4";
+  }
+  return null;
+}
+function detectCapabilities() {
+  const hasMediaRecorder = typeof MediaRecorder !== "undefined";
+  const hasWebCodecs = typeof globalThis.VideoEncoder !== "undefined" && typeof globalThis.AudioEncoder !== "undefined";
+  const hasMediaDevices = typeof navigator !== "undefined" && typeof navigator.mediaDevices !== "undefined";
+  const hasWebRTC = typeof RTCPeerConnection !== "undefined";
+  const hasOpfs = typeof navigator !== "undefined" && typeof navigator.storage !== "undefined" && typeof navigator.storage.getDirectory === "function";
+  return {
+    mux: pickMuxStrategy(),
+    opfs: hasOpfs,
+    webcodecs: hasWebCodecs,
+    mediaRecorder: hasMediaRecorder,
+    mediaDevices: hasMediaDevices,
+    webRTC: hasWebRTC
+  };
+}
+
+var RecordingEngineError = class _RecordingEngineError extends Error {
+  code;
+  details;
+  constructor(code, message, details, options) {
+    super(message, options);
+    this.name = "RecordingEngineError";
+    this.code = code;
+    this.details = details;
+  }
+  static capability(missing, message) {
+    return new _RecordingEngineError("capability", message ?? `Required capability missing: ${missing}`, { missing });
+  }
+  static state(attempted, current) {
+    return new _RecordingEngineError("state", `Cannot ${attempted}: current state is ${current}`, {
+      current,
+      attempted
+    });
+  }
+  static invalidArg(argName, message) {
+    return new _RecordingEngineError("invalid-arg", message, { argName });
+  }
+  static transferHttp(status, action, detail = "") {
+    return new _RecordingEngineError("transfer-http", `Failed to ${action}: HTTP ${status}${detail ? ` \u2014 ${detail}` : ""}`, { status, action, detail });
+  }
+  static transferNetwork(action, opts) {
+    return new _RecordingEngineError("transfer-network", `Failed to ${action}: ${opts?.kind ?? "network"} error`, { action, ...opts?.kind ? { kind: opts.kind } : {} }, opts?.cause !== void 0 ? { cause: opts.cause } : void 0);
+  }
+  static emptyBlob() {
+    return new _RecordingEngineError("transfer-empty-blob", "Cannot upload an empty blob", {});
+  }
+  static muxWrite(position, expected) {
+    return new _RecordingEngineError("mux-write", `Non-sequential muxer write at position ${position} (expected ${expected})`, { position, expected });
+  }
+  static internal(message, cause) {
+    return new _RecordingEngineError("internal", message, {}, cause ? { cause } : void 0);
+  }
+};
+
+var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]", "::1"]);
+function isSecureTransportUrl(value) {
+  if (typeof value !== "string")
+    return false;
+  let url2;
+  try {
+    url2 = new URL(value);
+  } catch {
+    return false;
+  }
+  if (url2.protocol === "https:")
+    return true;
+  if (url2.protocol === "http:")
+    return LOOPBACK_HOSTS.has(url2.hostname);
+  return false;
+}
+
+var CHUNK_ALIGNMENT = 256 * 1024;
+var RESUMABLE_CHUNK_BYTES = 32 * CHUNK_ALIGNMENT;
+var CHUNK_TIMEOUT_MS = 4 * 60 * 1e3;
+function parseRangeHeader(value) {
+  if (!value)
+    return null;
+  const match = /^bytes=0-(\d+)$/.exec(value.trim());
+  if (!match?.[1])
+    return null;
+  const lastByte = Number(match[1]);
+  if (!Number.isFinite(lastByte) || lastByte < 0)
+    return null;
+  return lastByte + 1;
+}
+function isRetriableStatus(status) {
+  return status >= 500 || status === 408 || status === 429;
+}
+
+var FIRST_FLUSH_BYTES = 1 * 1024 * 1024;
+var FLUSH_BYTES = 8 * 1024 * 1024;
+var FLUSH_INTERVAL_MS = 1e4;
+var HARD_BACK_PRESSURE_BYTES = 64 * 1024 * 1024;
+var MAX_PUT_BYTES = 8 * 1024 * 1024;
+var PUT_TIMEOUT_MS = 3e4;
+var PUT_MIN_BYTES_PER_SEC = 128 * 1024;
+var CLOSE_TIMEOUT_MS = 6e4;
+var MAX_PUT_ATTEMPTS = 4;
+var RETRY_BASE_MS = 1e3;
+var SPILL_RETRY_MS = FLUSH_INTERVAL_MS;
+var SPILL_PACE_MS = 1e3;
+var SPILL_PACE_PUT_BYTES = 2 * 1024 * 1024;
+var PermanentUploadError = class extends Error {
+};
+function defaultScheduler() {
+  return {
+    schedule(cb, ms) {
+      const id = setTimeout(cb, ms);
+      return { cancel: () => clearTimeout(id) };
+    }
+  };
+}
+var CloudFileSinkHandle = class {
+  path;
+  state = "idle";
+  queue = [];
+  queueBytes = 0;
+  // Bytes confirmed uploaded to GCS (advances on each successful PUT).
+  globalOffset = 0;
+  // Bytes seen via write(). Used as the final TOTAL in Content-Range on close.
+  totalWrittenBytes = 0;
+  sessionUrl = null;
+  // Worker promise so concurrent kicks coalesce — only one drain loop at a time.
+  worker = Promise.resolve();
+  flushTimer = null;
+  hasFlushedFirst = false;
+  closing = false;
+  fetchImpl;
+  scheduler;
+  // In-flight request controller; abort()/markFailed() trigger it so a dead
+  // network can't pin teardown behind retry budgets.
+  inflightAbort = null;
+  callbacks;
+  recordingId;
+  fileId;
+  initUrl;
+  contentType;
+  // True once the memory queue was abandoned for the durable local file.
+  // One-way: the file always has the full stream, so there's no reason to
+  // switch back to queueing once we're here.
+  spilling = false;
+  readSource;
+  spillRetryTimer = null;
+  constructor(config) {
+    this.path = `cloud:${config.recordingId}/${config.fileId}`;
+    this.initUrl = config.initUrl;
+    this.contentType = config.contentType;
+    this.recordingId = config.recordingId;
+    this.fileId = config.fileId;
+    this.callbacks = config.callbacks ?? {};
+    this.fetchImpl = config.fetchImpl ?? globalThis.fetch.bind(globalThis);
+    this.readSource = config.readSource ?? null;
+    const scheduleFn = config.scheduleFn;
+    this.scheduler = scheduleFn ? { schedule: (cb, ms) => scheduleFn(cb, ms) } : defaultScheduler();
+  }
+  getState() {
+    return this.state;
+  }
+  /**
+   * Externally fail the backup (e.g. the macOS cloud-tail poller died) so
+   * close() can't seal a truncated object as 'completed'. Idempotent.
+   */
+  fail(reason) {
+    this.markFailed(reason);
+  }
+  async write(chunk) {
+    if (this.isTerminal()) {
+      return;
+    }
+    if (chunk.byteLength === 0)
+      return;
+    this.totalWrittenBytes += chunk.byteLength;
+    if (this.spilling) {
+      if (!this.spillRetryTimer)
+        this.armFlushTimer();
+      return;
+    }
+    this.queue.push(chunk);
+    this.queueBytes += chunk.byteLength;
+    if (this.queueBytes > HARD_BACK_PRESSURE_BYTES) {
+      if (!this.enterSpillMode("back-pressure-exceeded")) {
+        this.markFailed("back-pressure-exceeded");
+      }
+      return;
+    }
+    const threshold = this.hasFlushedFirst ? FLUSH_BYTES : FIRST_FLUSH_BYTES;
+    if (this.queueBytes >= threshold) {
+      this.cancelFlushTimer();
+      this.kickWorker();
+    } else {
+      this.armFlushTimer();
+    }
+  }
+  async close() {
+    if (this.isTerminal())
+      return;
+    this.closing = true;
+    this.transitionTo("flushing");
+    this.cancelFlushTimer();
+    this.cancelSpillRetry();
+    this.kickWorker();
+    const timerHolder = { current: null };
+    const timeout = new Promise((resolve) => {
+      timerHolder.current = this.scheduler.schedule(() => {
+        this.markFailed("close-timeout");
+        resolve();
+      }, CLOSE_TIMEOUT_MS);
+    });
+    await Promise.race([this.worker.catch(() => void 0), timeout]);
+    timerHolder.current?.cancel();
+  }
+  async abort() {
+    if (this.state === "aborted" || this.state === "completed")
+      return;
+    this.transitionTo("aborted");
+    this.cancelFlushTimer();
+    this.cancelSpillRetry();
+    this.queue = [];
+    this.queueBytes = 0;
+    this.inflightAbort?.abort();
+    await this.worker.catch(() => void 0);
+    if (this.sessionUrl) {
+      const sessionUrl = this.sessionUrl;
+      this.sessionUrl = null;
+      await this.terminateSession(sessionUrl).catch((err) => {
+        this.notifyCleanupError("terminate-session", err);
+      });
+    }
+  }
+  async discard() {
+    await this.abort();
+  }
+  isTerminal() {
+    return this.state === "completed" || this.state === "failed" || this.state === "aborted";
+  }
+  transitionTo(next, info) {
+    if (this.state === next)
+      return;
+    if (this.isTerminal())
+      return;
+    this.state = next;
+    try {
+      this.callbacks.onState?.(next, info);
+    } catch {
+    }
+  }
+  markFailed(reason) {
+    if (this.isTerminal())
+      return;
+    this.state = "failed";
+    this.queue = [];
+    this.queueBytes = 0;
+    this.cancelFlushTimer();
+    this.cancelSpillRetry();
+    this.inflightAbort?.abort();
+    try {
+      this.callbacks.onState?.("failed", { reason });
+    } catch {
+    }
+  }
+  notifyCleanupError(context, err) {
+    try {
+      this.callbacks.onCleanupError?.(context, err);
+    } catch {
+    }
+  }
+  /**
+   * Abandon the memory queue and drain from the durable local file instead.
+   * Returns false when no readSource is wired (caller falls back to the
+   * terminal path). Everything up to `globalOffset` is committed in GCS;
+   * everything after is in the local file, so dropping the queue loses
+   * nothing.
+   */
+  enterSpillMode(reason) {
+    if (!this.readSource || this.isTerminal())
+      return false;
+    const first = !this.spilling;
+    this.spilling = true;
+    this.queue = [];
+    this.queueBytes = 0;
+    if (first) {
+      try {
+        this.callbacks.onLagging?.(reason);
+      } catch {
+      }
+    }
+    return true;
+  }
+  /** Schedule a spill-drain retry after a transient upload failure. */
+  armSpillRetry() {
+    if (this.spillRetryTimer || this.isTerminal())
+      return;
+    this.spillRetryTimer = this.scheduler.schedule(() => {
+      this.spillRetryTimer = null;
+      this.kickWorker();
+    }, SPILL_RETRY_MS);
+  }
+  /** Schedule the next paced spill PUT (mid-call yield, not a failure). */
+  armSpillPace() {
+    if (this.spillRetryTimer || this.isTerminal())
+      return;
+    this.spillRetryTimer = this.scheduler.schedule(() => {
+      this.spillRetryTimer = null;
+      this.kickWorker();
+    }, SPILL_PACE_MS);
+  }
+  cancelSpillRetry() {
+    if (this.spillRetryTimer) {
+      this.spillRetryTimer.cancel();
+      this.spillRetryTimer = null;
+    }
+  }
+  armFlushTimer() {
+    if (this.flushTimer)
+      return;
+    this.flushTimer = this.scheduler.schedule(() => {
+      this.flushTimer = null;
+      this.kickWorker();
+    }, FLUSH_INTERVAL_MS);
+  }
+  cancelFlushTimer() {
+    if (this.flushTimer) {
+      this.flushTimer.cancel();
+      this.flushTimer = null;
+    }
+  }
+  kickWorker() {
+    this.worker = this.worker.then(() => this.drainOnce()).catch(() => void 0);
+  }
+  async drainOnce() {
+    if (this.isTerminal())
+      return;
+    const spillHasBytes = this.spilling && this.totalWrittenBytes > this.globalOffset;
+    if (this.queue.length === 0 && !this.sessionUrl && !spillHasBytes) {
+      if (this.closing)
+        this.markFailed("no-bytes");
+      return;
+    }
+    if (!this.sessionUrl) {
+      try {
+        this.transitionTo("initializing");
+        this.sessionUrl = await this.initSession();
+        try {
+          this.callbacks.onSessionAcquired?.(this.sessionUrl);
+        } catch {
+        }
+        this.transitionTo("uploading");
+      } catch (err) {
+        if (!(err instanceof PermanentUploadError) && this.enterSpillMode("init-retry")) {
+          this.armSpillRetry();
+          return;
+        }
+        this.markFailed(`init-failed (recording=${this.recordingId} file=${this.fileId}): ${describeErr(err)}`);
+        return;
+      }
+    }
+    if (this.spilling) {
+      await this.drainFromSource();
+      return;
+    }
+    while (this.queue.length > 0 && !this.isTerminal()) {
+      const isFinal = this.closing && this.queueBytes <= MAX_PUT_BYTES;
+      let takeBytes;
+      if (isFinal) {
+        takeBytes = this.queueBytes;
+      } else {
+        takeBytes = Math.min(Math.floor(this.queueBytes / CHUNK_ALIGNMENT) * CHUNK_ALIGNMENT, MAX_PUT_BYTES);
+        if (takeBytes === 0) {
+          return;
+        }
+      }
+      const toSend = takeFromQueue(this.queue, takeBytes);
+      this.queueBytes -= takeBytes;
+      try {
+        await this.putChunk(toSend, isFinal);
+        this.globalOffset += toSend.byteLength;
+        this.hasFlushedFirst = true;
+        try {
+          this.callbacks.onProgress?.(this.globalOffset);
+        } catch {
+        }
+        if (isFinal) {
+          this.transitionTo("completed");
+          return;
+        }
+      } catch (err) {
+        if (!(err instanceof PermanentUploadError) && this.enterSpillMode("put-retry-exhausted")) {
+          this.armSpillRetry();
+          return;
+        }
+        this.markFailed(`put-failed (recording=${this.recordingId} file=${this.fileId} offset=${this.globalOffset}): ${describeErr(err)}`);
+        return;
+      }
+    }
+    if (this.closing && !this.isTerminal() && this.sessionUrl && this.globalOffset > 0) {
+      try {
+        await this.finalizeEmpty();
+        this.transitionTo("completed");
+      } catch (err) {
+        if (!(err instanceof PermanentUploadError) && this.enterSpillMode("finalize-retry")) {
+          this.armSpillRetry();
+          return;
+        }
+        this.markFailed(`finalize-failed (recording=${this.recordingId} file=${this.fileId}): ${describeErr(err)}`);
+      }
+    }
+  }
+  /**
+   * Spill-mode drain: upload the gap between what GCS has committed and what
+   * the caller has written, reading it back from the durable local file.
+   * Transient failures arm a retry instead of failing the backup; only a
+   * permanent 4xx (or a missing/short local read that never heals before
+   * close-timeout) ends the cloud copy.
+   */
+  async drainFromSource() {
+    const read = this.readSource;
+    if (!read)
+      return;
+    while (!this.isTerminal() && this.globalOffset < this.totalWrittenBytes) {
+      const remaining = this.totalWrittenBytes - this.globalOffset;
+      const isFinal = this.closing && remaining <= MAX_PUT_BYTES;
+      const maxPut = this.closing ? MAX_PUT_BYTES : SPILL_PACE_PUT_BYTES;
+      const takeBytes = isFinal ? remaining : Math.min(Math.floor(remaining / CHUNK_ALIGNMENT) * CHUNK_ALIGNMENT, maxPut);
+      if (takeBytes === 0) {
+        this.armFlushTimer();
+        return;
+      }
+      let chunk;
+      try {
+        chunk = await read(this.globalOffset, takeBytes);
+      } catch {
+        this.armSpillRetry();
+        return;
+      }
+      if (chunk.byteLength < takeBytes) {
+        this.armSpillRetry();
+        return;
+      }
+      try {
+        await this.putChunk(chunk, isFinal);
+        this.globalOffset += chunk.byteLength;
+        this.hasFlushedFirst = true;
+        try {
+          this.callbacks.onProgress?.(this.globalOffset);
+        } catch {
+        }
+        if (isFinal) {
+          this.transitionTo("completed");
+          return;
+        }
+        if (!this.closing) {
+          this.armSpillPace();
+          return;
+        }
+      } catch (err) {
+        if (err instanceof PermanentUploadError) {
+          this.markFailed(`put-failed (recording=${this.recordingId} file=${this.fileId} offset=${this.globalOffset}): ${describeErr(err)}`);
+          return;
+        }
+        this.armSpillRetry();
+        return;
+      }
+    }
+    if (this.closing && !this.isTerminal() && this.sessionUrl && this.globalOffset > 0) {
+      try {
+        await this.finalizeEmpty();
+        this.transitionTo("completed");
+      } catch (err) {
+        if (err instanceof PermanentUploadError) {
+          this.markFailed(`finalize-failed (recording=${this.recordingId} file=${this.fileId}): ${describeErr(err)}`);
+          return;
+        }
+        this.armSpillRetry();
+      }
+    }
+  }
+  async finalizeEmpty() {
+    if (!this.sessionUrl)
+      throw new Error("no active GCS session");
+    const contentRange = `bytes */${this.totalWrittenBytes}`;
+    const res = await this.requestWithRetry(() => this.fetchWithTimeout(this.sessionUrl, {
+      method: "PUT",
+      headers: {
+        "content-range": contentRange,
+        "content-length": "0"
+      }
+    }));
+    if (res.status !== 200 && res.status !== 201) {
+      throw new PermanentUploadError(`finalize PUT returned HTTP ${res.status}`);
+    }
+  }
+  // -- HTTP layer ---------------------------------------------------------
+  async initSession() {
+    const res = await this.requestWithRetry(() => this.fetchWithTimeout(this.initUrl, {
+      method: "POST",
+      headers: {
+        // The signed URL was signed with this header, so it must appear
+        // verbatim in the request — GCS will reject the signature otherwise.
+        "x-goog-resumable": "start",
+        "content-type": this.contentType
+      }
+    }));
+    if (res.status !== 200 && res.status !== 201) {
+      throw new PermanentUploadError(`GCS init returned HTTP ${res.status}`);
+    }
+    const location = res.headers.get("location");
+    if (!location) {
+      throw new PermanentUploadError("GCS init missing Location header");
+    }
+    return location;
+  }
+  /**
+   * Upload one chunk, retrying with GCS offset reconciliation. A timed-out
+   * or failed PUT often persisted some of its bytes anyway (GCS commits in
+   * 256 KB increments), so before each retry we ask the server what landed
+   * and resend only the tail — blindly resending from the original offset
+   * would desync from the server and turn every transient timeout into a
+   * permanent failure. Resolves only once ALL bytes are committed, so the
+   * caller's `globalOffset += bytes.byteLength` accounting stays exact.
+   */
+  async putChunk(bytes2, isFinal) {
+    if (!this.sessionUrl)
+      throw new Error("no active GCS session");
+    let start = this.globalOffset;
+    let remaining = bytes2;
+    let failures = 0;
+    let lastErr = null;
+    while (failures < MAX_PUT_ATTEMPTS) {
+      if (this.isTerminal()) {
+        throw lastErr ?? new Error("sink reached a terminal state mid-upload");
+      }
+      let res = null;
+      try {
+        res = await this.sendPut(start, remaining, isFinal);
+      } catch (err) {
+        lastErr = err;
+      }
+      if (res) {
+        if (isFinal && (res.status === 200 || res.status === 201))
+          return;
+        if (res.status === 308) {
+          const committed = parseRangeHeader(res.headers.get("range")) ?? 0;
+          const expected = start + remaining.byteLength;
+          if (!isFinal && committed >= expected)
+            return;
+          if (committed > start) {
+            remaining = remaining.subarray(committed - start);
+            start = committed;
+            continue;
+          }
+          lastErr = new Error(`308 with no persisted progress (range=${committed})`);
+        } else if (isRetriableStatus(res.status)) {
+          lastErr = new Error(`HTTP ${res.status}`);
+          await res.body?.cancel().catch(() => void 0);
+        } else {
+          throw new PermanentUploadError(`${isFinal ? "final" : "non-final"} PUT returned HTTP ${res.status}`);
+        }
+      }
+      failures++;
+      let probe = null;
+      try {
+        probe = await this.probeCommitted();
+      } catch {
+      }
+      if (probe) {
+        const expected = start + remaining.byteLength;
+        if (probe.finalized) {
+          if (isFinal)
+            return;
+          throw new PermanentUploadError("GCS session finalized unexpectedly during a non-final PUT");
+        }
+        if (probe.committedBytes >= expected) {
+          if (!isFinal)
+            return;
+          remaining = remaining.subarray(remaining.byteLength);
+          start = expected;
+          failures = 0;
+        } else if (probe.committedBytes > start) {
+          remaining = remaining.subarray(probe.committedBytes - start);
+          start = probe.committedBytes;
+          failures = 0;
+        }
+      }
+      if (failures > 0 && failures < MAX_PUT_ATTEMPTS) {
+        if (this.isTerminal())
+          throw lastErr ?? new Error("sink terminated mid-upload");
+        await this.delay(RETRY_BASE_MS * Math.pow(2, failures - 1));
+      }
+    }
+    throw lastErr ?? new Error("PUT failed after retries");
+  }
+  async sendPut(start, body, isFinal) {
+    if (!this.sessionUrl)
+      throw new Error("no active GCS session");
+    if (isFinal && body.byteLength === 0) {
+      return this.fetchWithTimeout(this.sessionUrl, {
+        method: "PUT",
+        headers: {
+          "content-range": `bytes */${this.totalWrittenBytes}`,
+          "content-length": "0"
+        }
+      }, PUT_TIMEOUT_MS);
+    }
+    const end = start + body.byteLength - 1;
+    const total = isFinal ? String(this.totalWrittenBytes) : "*";
+    return this.fetchWithTimeout(this.sessionUrl, {
+      method: "PUT",
+      headers: {
+        "content-range": `bytes ${start}-${end}/${total}`,
+        "content-length": String(body.byteLength)
+      },
+      body
+    }, putTimeoutMs(body.byteLength));
+  }
+  /**
+   * GCS resumable status query: zero-body PUT with `Content-Range: bytes * / *`.
+   * Using '*' for the total guarantees the probe itself can never finalize
+   * the session. 308 + Range header reports the persisted byte count;
+   * 200/201 means a previous final PUT actually landed.
+   */
+  async probeCommitted() {
+    if (!this.sessionUrl)
+      throw new Error("no active GCS session");
+    const res = await this.fetchWithTimeout(this.sessionUrl, {
+      method: "PUT",
+      headers: { "content-range": "bytes */*", "content-length": "0" }
+    }, PUT_TIMEOUT_MS);
+    if (res.status === 200 || res.status === 201) {
+      return { finalized: true, committedBytes: this.totalWrittenBytes };
+    }
+    if (res.status === 308) {
+      const committed = parseRangeHeader(res.headers.get("range"));
+      return { finalized: false, committedBytes: committed ?? 0 };
+    }
+    await res.body?.cancel().catch(() => void 0);
+    throw new Error(`status probe returned HTTP ${res.status}`);
+  }
+  async terminateSession(sessionUrl) {
+    let lastErr = null;
+    for (let attempt = 0; attempt < 2; attempt++) {
+      if (attempt > 0)
+        await this.delay(RETRY_BASE_MS);
+      try {
+        const res = await this.fetchWithTimeout(sessionUrl, { method: "DELETE" });
+        const cancelled = res.status < 300 || res.status === 499 || res.status === 404 || res.status === 410;
+        await res.body?.cancel().catch(() => void 0);
+        if (cancelled)
+          return;
+        lastErr = new Error(`DELETE returned HTTP ${res.status}`);
+        if (!isRetriableStatus(res.status))
+          break;
+      } catch (err) {
+        lastErr = err;
+      }
+    }
+    throw lastErr ?? new Error("terminate-session failed");
+  }
+  async requestWithRetry(call) {
+    let lastErr = null;
+    for (let attempt = 0; attempt < MAX_PUT_ATTEMPTS; attempt++) {
+      if (attempt > 0 && this.isTerminal()) {
+        throw lastErr ?? new Error("sink reached a terminal state mid-request");
+      }
+      try {
+        const res = await call();
+        if (isRetriableStatus(res.status)) {
+          lastErr = new Error(`HTTP ${res.status}`);
+          await res.body?.cancel().catch(() => void 0);
+        } else {
+          return res;
+        }
+      } catch (err) {
+        lastErr = err;
+      }
+      if (attempt < MAX_PUT_ATTEMPTS - 1) {
+        if (this.isTerminal())
+          throw lastErr ?? new Error("sink terminated mid-request");
+        await this.delay(RETRY_BASE_MS * Math.pow(2, attempt));
+      }
+    }
+    throw lastErr ?? new Error("request failed after retries");
+  }
+  // Backoff via the injected scheduler so fake timers drive it deterministically.
+  delay(ms) {
+    return new Promise((resolve) => {
+      this.scheduler.schedule(resolve, ms);
+    });
+  }
+  async fetchWithTimeout(input, init, timeoutMs = PUT_TIMEOUT_MS) {
+    const controller = new AbortController();
+    this.inflightAbort = controller;
+    const timer = this.scheduler.schedule(() => controller.abort(), timeoutMs);
+    try {
+      return await this.fetchImpl(input, { ...init, signal: controller.signal });
+    } finally {
+      timer.cancel();
+      if (this.inflightAbort === controller)
+        this.inflightAbort = null;
+    }
+  }
+};
+function putTimeoutMs(byteLength) {
+  return PUT_TIMEOUT_MS + Math.ceil(byteLength / PUT_MIN_BYTES_PER_SEC) * 1e3;
+}
+function takeFromQueue(queue, count) {
+  const out = new Uint8Array(count);
+  let written = 0;
+  while (written < count && queue.length > 0) {
+    const head = queue[0];
+    const need = count - written;
+    if (head.byteLength <= need) {
+      out.set(head, written);
+      written += head.byteLength;
+      queue.shift();
+    } else {
+      out.set(head.subarray(0, need), written);
+      queue[0] = head.subarray(need);
+      written += need;
+    }
+  }
+  return out;
+}
+function describeErr(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function createCloudFileSinkHandle(config) {
+  if (!config.initUrl) {
+    throw RecordingEngineError.invalidArg("initUrl", "CloudFileSinkHandle requires initUrl");
+  }
+  if (!isSecureTransportUrl(config.initUrl)) {
+    throw RecordingEngineError.invalidArg("initUrl", "CloudFileSinkHandle initUrl must be https:// (http:// allowed only for loopback)");
+  }
+  if (!config.contentType) {
+    throw RecordingEngineError.invalidArg("contentType", "CloudFileSinkHandle requires contentType");
+  }
+  return new CloudFileSinkHandle(config);
+}
+
+var LOGO_SIZE = 56;
+var PADDING = 20;
+var OPACITY = 0.8;
+var FALLBACK_TEXT = "Powered by Capturly";
+var DRAW_WATCHDOG_MS = 1e3;
+function watermarkSupported() {
+  return typeof document !== "undefined" && typeof HTMLCanvasElement !== "undefined" && typeof HTMLCanvasElement.prototype.captureStream === "function" && typeof HTMLVideoElement !== "undefined" && "requestVideoFrameCallback" in HTMLVideoElement.prototype;
+}
+var WatermarkCompositor = class {
+  source;
+  config;
+  video;
+  canvas;
+  ctx;
+  output = null;
+  stopped = false;
+  watchdog = null;
+  lastDrawMs = 0;
+  drawFailureLogged = false;
+  constructor(source, config) {
+    this.source = source;
+    this.config = config;
+    this.video = document.createElement("video");
+    this.canvas = document.createElement("canvas");
+    const ctx = this.canvas.getContext("2d");
+    if (!ctx)
+      throw new Error("watermark: 2d canvas context unavailable");
+    this.ctx = ctx;
+  }
+  /** Returns the composited stream to hand to the mux strategy. */
+  async start() {
+    const track = this.source.getVideoTracks()[0];
+    if (!track)
+      throw new Error("watermark: source stream has no video track");
+    const settings = track.getSettings();
+    this.canvas.width = settings.width ?? 1280;
+    this.canvas.height = settings.height ?? 720;
+    this.video.muted = true;
+    this.video.playsInline = true;
+    this.video.srcObject = new MediaStream([track]);
+    await this.video.play();
+    const drawFrame = () => {
+      if (this.stopped)
+        return;
+      this.draw();
+      this.video.requestVideoFrameCallback(drawFrame);
+    };
+    this.draw();
+    this.video.requestVideoFrameCallback(drawFrame);
+    this.watchdog = setInterval(() => {
+      if (this.stopped)
+        return;
+      if (Date.now() - this.lastDrawMs >= DRAW_WATCHDOG_MS) {
+        try {
+          this.draw();
+        } catch (err) {
+          if (!this.drawFailureLogged) {
+            this.drawFailureLogged = true;
+            const log = this.config.logError ?? ((component, message, error) => console.error(`${component}: ${message}`, error));
+            log("watermark", "draw failed; watchdog keeps ticking", err);
+          }
+        }
+      }
+    }, DRAW_WATCHDOG_MS);
+    const canvasStream = this.canvas.captureStream();
+    this.output = new MediaStream([
+      ...canvasStream.getVideoTracks(),
+      ...this.source.getAudioTracks()
+    ]);
+    return this.output;
+  }
+  draw() {
+    this.lastDrawMs = Date.now();
+    const { canvas, ctx, video } = this;
+    if (video.videoWidth > 0 && (video.videoWidth !== canvas.width || video.videoHeight !== canvas.height)) {
+      canvas.width = video.videoWidth;
+      canvas.height = video.videoHeight;
+    }
+    ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
+    ctx.save();
+    ctx.globalAlpha = OPACITY;
+    if (this.config.image) {
+      ctx.drawImage(this.config.image, canvas.width - LOGO_SIZE - PADDING, canvas.height - LOGO_SIZE - PADDING, LOGO_SIZE, LOGO_SIZE);
+    } else {
+      ctx.font = "20px system-ui, sans-serif";
+      ctx.fillStyle = "white";
+      ctx.textAlign = "right";
+      ctx.textBaseline = "bottom";
+      ctx.fillText(FALLBACK_TEXT, canvas.width - PADDING, canvas.height - PADDING);
+    }
+    ctx.restore();
+  }
+  /**
+   * Idempotent; never throws. Stops only the canvas track it created —
+   * source-track ownership stays with CaptureSession's streamOwned logic.
+   */
+  stop() {
+    if (this.stopped)
+      return;
+    this.stopped = true;
+    if (this.watchdog !== null) {
+      clearInterval(this.watchdog);
+      this.watchdog = null;
+    }
+    for (const track of this.output?.getVideoTracks() ?? []) {
+      try {
+        track.stop();
+      } catch {
+      }
+    }
+    try {
+      this.video.pause();
+    } catch {
+    }
+    this.video.srcObject = null;
+  }
+};
+
+async function getOpfsRoot() {
+  if (typeof navigator === "undefined" || typeof navigator.storage === "undefined" || typeof navigator.storage.getDirectory !== "function") {
+    throw RecordingEngineError.capability("OPFS");
+  }
+  return await navigator.storage.getDirectory();
+}
+async function resolveDir(root, segments) {
+  let dir = root;
+  for (const segment of segments) {
+    if (!segment)
+      continue;
+    dir = await dir.getDirectoryHandle(segment, { create: true });
+  }
+  return dir;
+}
+function assertSafeRelativePath(relativePath) {
+  const invalid = () => {
+    throw RecordingEngineError.invalidArg("relativePath", `Unsafe file path: '${relativePath}'`);
+  };
+  if (typeof relativePath !== "string" || relativePath.length === 0)
+    invalid();
+  if (relativePath.includes("\\") || relativePath.includes("\0"))
+    invalid();
+  if (relativePath.startsWith("/") || /^[a-zA-Z]:/.test(relativePath))
+    invalid();
+  const segments = relativePath.split("/").filter(Boolean);
+  if (segments.length === 0)
+    invalid();
+  for (const segment of segments) {
+    if (segment === "." || segment === "..")
+      invalid();
+  }
+}
+function splitPath(relativePath) {
+  assertSafeRelativePath(relativePath);
+  const parts = relativePath.split("/").filter(Boolean);
+  const fileName = parts.pop();
+  if (!fileName) {
+    throw RecordingEngineError.invalidArg("relativePath", `Invalid file path: '${relativePath}'`);
+  }
+  return { dirSegments: parts, fileName };
+}
+var OPFS_SYNC_WORKER_SOURCE = `
+let chain = Promise.resolve();
+let handle = null;
+self.onmessage = (event) => {
+  const msg = event.data;
+  chain = chain.then(async () => {
+    try {
+      if (msg.op === 'open') {
+        let dir = await navigator.storage.getDirectory();
+        for (const segment of msg.dirSegments) {
+          dir = await dir.getDirectoryHandle(segment, { create: true });
+        }
+        const fileHandle = await dir.getFileHandle(msg.fileName, { create: true });
+        handle = await fileHandle.createSyncAccessHandle();
+        handle.truncate(0);
+      } else if (msg.op === 'write') {
+        handle.write(msg.data, { at: msg.position });
+        handle.flush();
+      } else if (msg.op === 'read') {
+        const out = new Uint8Array(msg.length);
+        const n = handle.read(out, { at: msg.position });
+        self.postMessage({ id: msg.id, ok: true, data: out.subarray(0, n) }, [out.buffer]);
+        return;
+      } else if (msg.op === 'close') {
+        handle.flush();
+        handle.close();
+        handle = null;
+      } else if (msg.op === 'abort') {
+        try { if (handle) handle.close(); } catch (e) {}
+        handle = null;
+      }
+      self.postMessage({ id: msg.id, ok: true });
+    } catch (err) {
+      self.postMessage({ id: msg.id, ok: false, error: String((err && err.message) || err) });
+    }
+  });
+};
+`;
+function defaultWorkerFactory() {
+  const blob = new Blob([OPFS_SYNC_WORKER_SOURCE], { type: "text/javascript" });
+  const url2 = URL.createObjectURL(blob);
+  try {
+    const worker = new Worker(url2);
+    return {
+      worker,
+      release: () => {
+        worker.terminate();
+        URL.revokeObjectURL(url2);
+      }
+    };
+  } catch (err) {
+    URL.revokeObjectURL(url2);
+    throw err;
+  }
+}
+var WORKER_OPEN_TIMEOUT_MS = 1e4;
+function supportsRangeRead(handle) {
+  return typeof handle.readAt === "function";
+}
+var OpfsSyncWorkerFileSinkHandle = class _OpfsSyncWorkerFileSinkHandle {
+  path;
+  worker;
+  releaseWorker;
+  removeSelf;
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  bytesWritten = 0;
+  closed = false;
+  discarded = false;
+  released = false;
+  constructor(path, worker, releaseWorker, removeSelf) {
+    this.path = path;
+    this.worker = worker;
+    this.releaseWorker = releaseWorker;
+    this.removeSelf = removeSelf;
+    worker.onmessage = (event) => {
+      const data = event.data;
+      if (typeof data?.id !== "number")
+        return;
+      const entry = this.pending.get(data.id);
+      if (!entry)
+        return;
+      this.pending.delete(data.id);
+      if (data.ok)
+        entry.resolve(data.data);
+      else
+        entry.reject(RecordingEngineError.internal(`OPFS worker op failed for ${this.path}: ${data.error ?? "unknown"}`));
+    };
+    worker.onerror = () => {
+      this.failAllPending(RecordingEngineError.internal(`OPFS sync worker crashed (${this.path})`));
+    };
+  }
+  static async open(relativePath, dirSegments, fileName, factory, removeSelf) {
+    const { worker, release } = factory();
+    const handle = new _OpfsSyncWorkerFileSinkHandle(relativePath, worker, release, removeSelf);
+    const timeout = setTimeout(() => {
+      handle.failAllPending(RecordingEngineError.internal(`OPFS sync worker open timed out (${relativePath})`));
+    }, WORKER_OPEN_TIMEOUT_MS);
+    try {
+      await handle.rpc({ op: "open", dirSegments, fileName });
+      return handle;
+    } catch (err) {
+      handle.release();
+      throw err;
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  async write(chunk) {
+    if (this.closed) {
+      throw RecordingEngineError.state("write", "closed");
+    }
+    const position = this.bytesWritten;
+    this.bytesWritten += chunk.byteLength;
+    await this.rpc({ op: "write", data: chunk, position });
+  }
+  /**
+   * Ranged read through the write worker. Ordered after every write RPC
+   * posted before it, so a read at any offset the caller has already
+   * written is guaranteed to observe those bytes. Returns fewer bytes than
+   * requested only at end-of-file.
+   */
+  async readAt(position, length) {
+    if (this.closed) {
+      throw RecordingEngineError.state("readAt", "closed");
+    }
+    const result = await this.rpc({ op: "read", position, length });
+    if (!(result instanceof Uint8Array)) {
+      throw RecordingEngineError.internal(`OPFS worker read returned no data (${this.path})`);
+    }
+    return result;
+  }
+  async close() {
+    if (this.closed)
+      return;
+    this.closed = true;
+    try {
+      await this.rpc({ op: "close" });
+    } finally {
+      this.release();
+    }
+  }
+  async abort() {
+    if (this.closed)
+      return;
+    this.closed = true;
+    try {
+      await this.rpc({ op: "abort" });
+    } finally {
+      this.release();
+    }
+  }
+  async discard() {
+    if (this.discarded)
+      return;
+    this.discarded = true;
+    if (!this.closed) {
+      try {
+        await this.abort();
+      } catch {
+      }
+    }
+    try {
+      await this.removeSelf();
+    } catch {
+    }
+  }
+  rpc(msg) {
+    return new Promise((resolve, reject) => {
+      if (this.released) {
+        reject(RecordingEngineError.internal(`OPFS sync worker already released (${this.path})`));
+        return;
+      }
+      const id = this.nextId++;
+      this.pending.set(id, { resolve, reject });
+      this.worker.postMessage({ ...msg, id });
+    });
+  }
+  failAllPending(err) {
+    const entries = [...this.pending.values()];
+    this.pending.clear();
+    for (const entry of entries)
+      entry.reject(err);
+  }
+  release() {
+    if (this.released)
+      return;
+    this.released = true;
+    this.failAllPending(RecordingEngineError.internal(`OPFS sync worker released (${this.path})`));
+    this.releaseWorker();
+  }
+};
+var OpfsFileSinkHandle = class {
+  path;
+  removeSelf;
+  writable;
+  bytesWritten = 0;
+  closed = false;
+  discarded = false;
+  // Serialize position-based writes. Without this, two concurrent callers
+  // both read `bytesWritten` before either has incremented it, and the
+  // second write clobbers the first at the same offset.
+  writeChain = Promise.resolve();
+  constructor(path, writable, removeSelf) {
+    this.path = path;
+    this.removeSelf = removeSelf;
+    this.writable = writable;
+  }
+  async write(chunk) {
+    if (this.closed || !this.writable) {
+      throw RecordingEngineError.state("write", "closed");
+    }
+    const next = this.writeChain.then(async () => {
+      if (!this.writable) {
+        throw RecordingEngineError.state("write", "closed");
+      }
+      await this.writable.write({ type: "write", data: chunk, position: this.bytesWritten });
+      this.bytesWritten += chunk.byteLength;
+    });
+    this.writeChain = next.catch(() => void 0);
+    return next;
+  }
+  async close() {
+    if (this.closed)
+      return;
+    this.closed = true;
+    await this.writeChain.catch(() => void 0);
+    const w = this.writable;
+    this.writable = null;
+    if (w)
+      await w.close();
+  }
+  async abort() {
+    if (this.closed)
+      return;
+    this.closed = true;
+    const w = this.writable;
+    this.writable = null;
+    if (w)
+      await w.abort("aborted");
+  }
+  async discard() {
+    if (this.discarded)
+      return;
+    this.discarded = true;
+    if (!this.closed) {
+      try {
+        await this.abort();
+      } catch {
+      }
+    }
+    try {
+      await this.removeSelf();
+    } catch {
+    }
+  }
+};
+var OpfsFileSink = class {
+  deps;
+  constructor(deps = {}) {
+    this.deps = deps;
+  }
+  async open(relativePath) {
+    const { dirSegments, fileName } = splitPath(relativePath);
+    const factory = this.deps.workerFactory !== void 0 ? this.deps.workerFactory : typeof Worker !== "undefined" ? defaultWorkerFactory : null;
+    if (factory) {
+      try {
+        return await OpfsSyncWorkerFileSinkHandle.open(relativePath, dirSegments, fileName, factory, () => this.remove(relativePath));
+      } catch (err) {
+        this.deps.logError?.("opfs-sink", "sync-worker sink unavailable; falling back to createWritable (writes not crash-durable)", err);
+        this.deps.onDurabilityFallback?.();
+      }
+    } else if (this.deps.workerFactory === void 0) {
+      this.deps.logError?.("opfs-sink", "Worker unavailable; falling back to createWritable (writes not crash-durable)");
+      this.deps.onDurabilityFallback?.();
+    }
+    const root = await getOpfsRoot();
+    const dir = await resolveDir(root, dirSegments);
+    const fileHandle = await dir.getFileHandle(fileName, { create: true });
+    const writable = await fileHandle.createWritable({ keepExistingData: false });
+    return new OpfsFileSinkHandle(relativePath, writable, () => this.remove(relativePath));
+  }
+  async remove(relativePath) {
+    const root = await getOpfsRoot();
+    const { dirSegments, fileName } = splitPath(relativePath);
+    const dir = await resolveDir(root, dirSegments);
+    await dir.removeEntry(fileName);
+  }
+  async read(relativePath) {
+    const root = await getOpfsRoot();
+    const { dirSegments, fileName } = splitPath(relativePath);
+    const dir = await resolveDir(root, dirSegments);
+    const fileHandle = await dir.getFileHandle(fileName);
+    return await fileHandle.getFile();
+  }
+};
+
+var AVC_LEVEL_3_0 = { hex: "1E", maxFrameMbs: 1620, maxMbsPerSec: 40500 };
+var AVC_LEVELS = [
+  AVC_LEVEL_3_0,
+  { hex: "1F", maxFrameMbs: 3600, maxMbsPerSec: 108e3 },
+  // 3.1 — 720p30
+  { hex: "20", maxFrameMbs: 5120, maxMbsPerSec: 216e3 },
+  // 3.2 — 720p60
+  { hex: "28", maxFrameMbs: 8192, maxMbsPerSec: 245760 },
+  // 4.0 — 1080p30
+  { hex: "2A", maxFrameMbs: 8704, maxMbsPerSec: 522240 },
+  // 4.2 — 1080p60
+  { hex: "33", maxFrameMbs: 36864, maxMbsPerSec: 983040 }
+  // 5.1 — 4K30
+];
+var AVC_TOP_LEVEL = { hex: "34", maxFrameMbs: 36864, maxMbsPerSec: 2073600 };
+function pickAvcCodecString(width, height, frameRate) {
+  const frameMbs = Math.ceil(width / 16) * Math.ceil(height / 16);
+  const mbsPerSec = frameMbs * frameRate;
+  const level = AVC_LEVELS.find((l) => frameMbs <= l.maxFrameMbs && mbsPerSec <= l.maxMbsPerSec) ?? AVC_TOP_LEVEL;
+  return `avc1.6400${level.hex}`;
+}
+function fitsBaselineLevel(width, height, frameRate) {
+  const frameMbs = Math.ceil(width / 16) * Math.ceil(height / 16);
+  return frameMbs <= AVC_LEVEL_3_0.maxFrameMbs && frameMbs * frameRate <= AVC_LEVEL_3_0.maxMbsPerSec;
+}
+
+var LADDER = [
+  { minHeight: 2160, bps30: 4e7, bps60: 6e7 },
+  // 4K
+  { minHeight: 1440, bps30: 16e6, bps60: 24e6 },
+  // 1440p
+  { minHeight: 1080, bps30: 8e6, bps60: 12e6 },
+  // 1080p
+  { minHeight: 720, bps30: 5e6, bps60: 75e5 }
+  // 720p
+];
+var FLOOR_RUNG = { bps30: 25e5, bps60: 4e6 };
+var HIGH_FPS_THRESHOLD = 48;
+function bitrateForResolution(height, frameRate) {
+  const h = Math.max(0, Math.round(height));
+  const rung = LADDER.find((r) => h >= r.minHeight) ?? FLOOR_RUNG;
+  return frameRate >= HIGH_FPS_THRESHOLD ? rung.bps60 : rung.bps30;
+}
+
+var MP4_BASELINE_MIME = "video/mp4;codecs=avc1.42E01E,mp4a.40.2";
+var BASELINE_VIDEO_CODEC = "avc1.42E01E";
+var START_TIMEOUT_MS = 1e4;
+var STOP_TIMEOUT_MS = 3e4;
+function withTimeout(promise, ms, message) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error(message)), ms);
+    promise.then((value) => {
+      clearTimeout(timer);
+      resolve(value);
+    }, (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+  });
+}
+var MediaRecorderMp4Strategy = class {
+  kind = "mediarecorder-mp4";
+  recorder = null;
+  // Set in start() from the negotiated resolution; reported in the MuxResult.
+  videoCodec = BASELINE_VIDEO_CODEC;
+  // Rolling tail of the serialized write chain. Each blob awaits this before
+  // writing, then becomes the new tail — awaiting it awaits the whole chain
+  // without retaining one promise per chunk for the recording's lifetime.
+  writeTail = Promise.resolve();
+  firstError = null;
+  started = false;
+  errorHandler = null;
+  onError(handler) {
+    this.errorHandler = handler;
+  }
+  reportError(cause) {
+    const err = cause instanceof Error ? cause : new Error(String(cause));
+    if (!this.firstError)
+      this.firstError = err;
+    try {
+      if (this.recorder && this.recorder.state !== "inactive") {
+        this.recorder.stop();
+      }
+    } catch {
+    }
+    if (!this.started)
+      return;
+    const handler = this.errorHandler;
+    if (!handler)
+      return;
+    try {
+      handler(err);
+    } catch {
+    }
+  }
+  async start(stream, sink, opts) {
+    if (this.recorder) {
+      throw RecordingEngineError.state("start", "recording");
+    }
+    const settings = stream.getVideoTracks()[0]?.getSettings();
+    const width = settings?.width ?? 1920;
+    const height = settings?.height ?? 1080;
+    const frameRate = settings?.frameRate ?? 30;
+    const leveledVideoCodec = pickAvcCodecString(width, height, frameRate);
+    const leveledMime = `video/mp4;codecs=${leveledVideoCodec},mp4a.40.2`;
+    let mime;
+    if (MediaRecorder.isTypeSupported(leveledMime)) {
+      mime = leveledMime;
+      this.videoCodec = leveledVideoCodec;
+    } else if (MediaRecorder.isTypeSupported(MP4_BASELINE_MIME) && fitsBaselineLevel(width, height, frameRate)) {
+      mime = MP4_BASELINE_MIME;
+      this.videoCodec = BASELINE_VIDEO_CODEC;
+    } else {
+      throw RecordingEngineError.capability(`MediaRecorder MP4 (${leveledMime})`);
+    }
+    const recorder = new MediaRecorder(stream, {
+      mimeType: mime,
+      videoBitsPerSecond: opts.videoBitsPerSecond ?? bitrateForResolution(height, frameRate),
+      audioBitsPerSecond: opts.audioBitsPerSecond ?? 192e3
+    });
+    recorder.ondataavailable = (event) => {
+      if (event.data.size === 0)
+        return;
+      const previous = this.writeTail;
+      const blob = event.data;
+      const writePromise = (async () => {
+        await previous.catch(() => void 0);
+        const buf = await blob.arrayBuffer();
+        await sink.write(new Uint8Array(buf));
+      })();
+      this.writeTail = writePromise;
+      writePromise.catch((err) => this.reportError(err));
+    };
+    recorder.onerror = (event) => {
+      const cause = event.error;
+      this.reportError(cause ?? new Error("MediaRecorder error"));
+    };
+    this.recorder = recorder;
+    await withTimeout(new Promise((resolve, reject) => {
+      recorder.onstart = () => resolve();
+      const errorHandler = () => reject(this.firstError ?? new Error("MediaRecorder start failed"));
+      recorder.addEventListener("error", errorHandler, { once: true });
+      try {
+        recorder.start(1e3);
+      } catch (err) {
+        reject(err);
+      }
+    }), START_TIMEOUT_MS, `MediaRecorder never fired onstart within ${START_TIMEOUT_MS}ms`);
+    this.started = true;
+  }
+  async stop() {
+    const recorder = this.recorder;
+    if (!recorder) {
+      throw RecordingEngineError.state("stop", "idle");
+    }
+    const stopped = new Promise((resolve, reject) => {
+      recorder.onstop = () => {
+        void (async () => {
+          try {
+            await this.writeTail.catch(() => void 0);
+            if (this.firstError) {
+              reject(this.firstError);
+              return;
+            }
+            resolve({
+              videoCodec: this.videoCodec,
+              audioCodec: "mp4a.40.2",
+              containerMime: "video/mp4"
+            });
+          } catch (err) {
+            reject(err);
+          }
+        })();
+      };
+      try {
+        if (recorder.state !== "inactive") {
+          recorder.stop();
+        } else {
+          void (async () => {
+            try {
+              await this.writeTail.catch(() => void 0);
+              if (this.firstError) {
+                reject(this.firstError);
+                return;
+              }
+              resolve({
+                videoCodec: this.videoCodec,
+                audioCodec: "mp4a.40.2",
+                containerMime: "video/mp4"
+              });
+            } catch (err) {
+              reject(err);
+            }
+          })();
+        }
+      } catch (err) {
+        reject(err);
+      }
+    });
+    return await withTimeout(stopped, STOP_TIMEOUT_MS, `MediaRecorder never fired onstop within ${STOP_TIMEOUT_MS}ms`);
+  }
+  async cancel() {
+    const recorder = this.recorder;
+    this.recorder = null;
+    if (!recorder)
+      return;
+    try {
+      if (recorder.state !== "inactive") {
+        recorder.stop();
+      }
+    } catch {
+    }
+    await this.writeTail.catch(() => void 0);
+  }
+};
+
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var __privateWrapper = (obj, member, setter, getter) => ({
+  set _(value) {
+    __privateSet(obj, member, value, setter);
+  },
+  get _() {
+    return __privateGet(obj, member, getter);
+  }
+});
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
+var bytes = new Uint8Array(8);
+var view = new DataView(bytes.buffer);
+var u8 = (value) => {
+  return [(value % 256 + 256) % 256];
+};
+var u16 = (value) => {
+  view.setUint16(0, value, false);
+  return [bytes[0], bytes[1]];
+};
+var i16 = (value) => {
+  view.setInt16(0, value, false);
+  return [bytes[0], bytes[1]];
+};
+var u24 = (value) => {
+  view.setUint32(0, value, false);
+  return [bytes[1], bytes[2], bytes[3]];
+};
+var u32 = (value) => {
+  view.setUint32(0, value, false);
+  return [bytes[0], bytes[1], bytes[2], bytes[3]];
+};
+var i32 = (value) => {
+  view.setInt32(0, value, false);
+  return [bytes[0], bytes[1], bytes[2], bytes[3]];
+};
+var u64 = (value) => {
+  view.setUint32(0, Math.floor(value / 2 ** 32), false);
+  view.setUint32(4, value, false);
+  return [bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7]];
+};
+var fixed_8_8 = (value) => {
+  view.setInt16(0, 2 ** 8 * value, false);
+  return [bytes[0], bytes[1]];
+};
+var fixed_16_16 = (value) => {
+  view.setInt32(0, 2 ** 16 * value, false);
+  return [bytes[0], bytes[1], bytes[2], bytes[3]];
+};
+var fixed_2_30 = (value) => {
+  view.setInt32(0, 2 ** 30 * value, false);
+  return [bytes[0], bytes[1], bytes[2], bytes[3]];
+};
+var ascii = (text, nullTerminated = false) => {
+  let bytes2 = Array(text.length).fill(null).map((_, i) => text.charCodeAt(i));
+  if (nullTerminated)
+    bytes2.push(0);
+  return bytes2;
+};
+var last = (arr) => {
+  return arr && arr[arr.length - 1];
+};
+var lastPresentedSample = (samples) => {
+  let result = void 0;
+  for (let sample of samples) {
+    if (!result || sample.presentationTimestamp > result.presentationTimestamp) {
+      result = sample;
+    }
+  }
+  return result;
+};
+var intoTimescale = (timeInSeconds, timescale, round = true) => {
+  let value = timeInSeconds * timescale;
+  return round ? Math.round(value) : value;
+};
+var rotationMatrix = (rotationInDegrees) => {
+  let theta = rotationInDegrees * (Math.PI / 180);
+  let cosTheta = Math.cos(theta);
+  let sinTheta = Math.sin(theta);
+  return [
+    cosTheta,
+    sinTheta,
+    0,
+    -sinTheta,
+    cosTheta,
+    0,
+    0,
+    0,
+    1
+  ];
+};
+var IDENTITY_MATRIX = rotationMatrix(0);
+var matrixToBytes = (matrix) => {
+  return [
+    fixed_16_16(matrix[0]),
+    fixed_16_16(matrix[1]),
+    fixed_2_30(matrix[2]),
+    fixed_16_16(matrix[3]),
+    fixed_16_16(matrix[4]),
+    fixed_2_30(matrix[5]),
+    fixed_16_16(matrix[6]),
+    fixed_16_16(matrix[7]),
+    fixed_2_30(matrix[8])
+  ];
+};
+var deepClone = (x) => {
+  if (!x)
+    return x;
+  if (typeof x !== "object")
+    return x;
+  if (Array.isArray(x))
+    return x.map(deepClone);
+  return Object.fromEntries(Object.entries(x).map(([key, value]) => [key, deepClone(value)]));
+};
+var isU32 = (value) => {
+  return value >= 0 && value < 2 ** 32;
+};
+var box = (type, contents, children) => ({
+  type,
+  contents: contents && new Uint8Array(contents.flat(10)),
+  children
+});
+var fullBox = (type, version, flags, contents, children) => box(
+  type,
+  [u8(version), u24(flags), contents ?? []],
+  children
+);
+var ftyp = (details) => {
+  let minorVersion = 512;
+  if (details.fragmented)
+    return box("ftyp", [
+      ascii("iso5"),
+      // Major brand
+      u32(minorVersion),
+      // Minor version
+      // Compatible brands
+      ascii("iso5"),
+      ascii("iso6"),
+      ascii("mp41")
+    ]);
+  return box("ftyp", [
+    ascii("isom"),
+    // Major brand
+    u32(minorVersion),
+    // Minor version
+    // Compatible brands
+    ascii("isom"),
+    details.holdsAvc ? ascii("avc1") : [],
+    ascii("mp41")
+  ]);
+};
+var mdat = (reserveLargeSize) => ({ type: "mdat", largeSize: reserveLargeSize });
+var free = (size) => ({ type: "free", size });
+var moov = (tracks, creationTime, fragmented = false) => box("moov", null, [
+  mvhd(creationTime, tracks),
+  ...tracks.map((x) => trak(x, creationTime)),
+  fragmented ? mvex(tracks) : null
+]);
+var mvhd = (creationTime, tracks) => {
+  let duration = intoTimescale(Math.max(
+    0,
+    ...tracks.filter((x) => x.samples.length > 0).map((x) => {
+      const lastSample = lastPresentedSample(x.samples);
+      return lastSample.presentationTimestamp + lastSample.duration;
+    })
+  ), GLOBAL_TIMESCALE);
+  let nextTrackId = Math.max(...tracks.map((x) => x.id)) + 1;
+  let needsU64 = !isU32(creationTime) || !isU32(duration);
+  let u32OrU64 = needsU64 ? u64 : u32;
+  return fullBox("mvhd", +needsU64, 0, [
+    u32OrU64(creationTime),
+    // Creation time
+    u32OrU64(creationTime),
+    // Modification time
+    u32(GLOBAL_TIMESCALE),
+    // Timescale
+    u32OrU64(duration),
+    // Duration
+    fixed_16_16(1),
+    // Preferred rate
+    fixed_8_8(1),
+    // Preferred volume
+    Array(10).fill(0),
+    // Reserved
+    matrixToBytes(IDENTITY_MATRIX),
+    // Matrix
+    Array(24).fill(0),
+    // Pre-defined
+    u32(nextTrackId)
+    // Next track ID
+  ]);
+};
+var trak = (track, creationTime) => box("trak", null, [
+  tkhd(track, creationTime),
+  mdia(track, creationTime)
+]);
+var tkhd = (track, creationTime) => {
+  let lastSample = lastPresentedSample(track.samples);
+  let durationInGlobalTimescale = intoTimescale(
+    lastSample ? lastSample.presentationTimestamp + lastSample.duration : 0,
+    GLOBAL_TIMESCALE
+  );
+  let needsU64 = !isU32(creationTime) || !isU32(durationInGlobalTimescale);
+  let u32OrU64 = needsU64 ? u64 : u32;
+  let matrix;
+  if (track.info.type === "video") {
+    matrix = typeof track.info.rotation === "number" ? rotationMatrix(track.info.rotation) : track.info.rotation;
+  } else {
+    matrix = IDENTITY_MATRIX;
+  }
+  return fullBox("tkhd", +needsU64, 3, [
+    u32OrU64(creationTime),
+    // Creation time
+    u32OrU64(creationTime),
+    // Modification time
+    u32(track.id),
+    // Track ID
+    u32(0),
+    // Reserved
+    u32OrU64(durationInGlobalTimescale),
+    // Duration
+    Array(8).fill(0),
+    // Reserved
+    u16(0),
+    // Layer
+    u16(0),
+    // Alternate group
+    fixed_8_8(track.info.type === "audio" ? 1 : 0),
+    // Volume
+    u16(0),
+    // Reserved
+    matrixToBytes(matrix),
+    // Matrix
+    fixed_16_16(track.info.type === "video" ? track.info.width : 0),
+    // Track width
+    fixed_16_16(track.info.type === "video" ? track.info.height : 0)
+    // Track height
+  ]);
+};
+var mdia = (track, creationTime) => box("mdia", null, [
+  mdhd(track, creationTime),
+  hdlr(track.info.type === "video" ? "vide" : "soun"),
+  minf(track)
+]);
+var mdhd = (track, creationTime) => {
+  let lastSample = lastPresentedSample(track.samples);
+  let localDuration = intoTimescale(
+    lastSample ? lastSample.presentationTimestamp + lastSample.duration : 0,
+    track.timescale
+  );
+  let needsU64 = !isU32(creationTime) || !isU32(localDuration);
+  let u32OrU64 = needsU64 ? u64 : u32;
+  return fullBox("mdhd", +needsU64, 0, [
+    u32OrU64(creationTime),
+    // Creation time
+    u32OrU64(creationTime),
+    // Modification time
+    u32(track.timescale),
+    // Timescale
+    u32OrU64(localDuration),
+    // Duration
+    u16(21956),
+    // Language ("und", undetermined)
+    u16(0)
+    // Quality
+  ]);
+};
+var hdlr = (componentSubtype) => fullBox("hdlr", 0, 0, [
+  ascii("mhlr"),
+  // Component type
+  ascii(componentSubtype),
+  // Component subtype
+  u32(0),
+  // Component manufacturer
+  u32(0),
+  // Component flags
+  u32(0),
+  // Component flags mask
+  ascii("mp4-muxer-hdlr", true)
+  // Component name
+]);
+var minf = (track) => box("minf", null, [
+  track.info.type === "video" ? vmhd() : smhd(),
+  dinf(),
+  stbl(track)
+]);
+var vmhd = () => fullBox("vmhd", 0, 1, [
+  u16(0),
+  // Graphics mode
+  u16(0),
+  // Opcolor R
+  u16(0),
+  // Opcolor G
+  u16(0)
+  // Opcolor B
+]);
+var smhd = () => fullBox("smhd", 0, 0, [
+  u16(0),
+  // Balance
+  u16(0)
+  // Reserved
+]);
+var dinf = () => box("dinf", null, [
+  dref()
+]);
+var dref = () => fullBox("dref", 0, 0, [
+  u32(1)
+  // Entry count
+], [
+  url()
+]);
+var url = () => fullBox("url ", 0, 1);
+var stbl = (track) => {
+  const needsCtts = track.compositionTimeOffsetTable.length > 1 || track.compositionTimeOffsetTable.some((x) => x.sampleCompositionTimeOffset !== 0);
+  return box("stbl", null, [
+    stsd(track),
+    stts(track),
+    stss(track),
+    stsc(track),
+    stsz(track),
+    stco(track),
+    needsCtts ? ctts(track) : null
+  ]);
+};
+var stsd = (track) => fullBox("stsd", 0, 0, [
+  u32(1)
+  // Entry count
+], [
+  track.info.type === "video" ? videoSampleDescription(
+    VIDEO_CODEC_TO_BOX_NAME[track.info.codec],
+    track
+  ) : soundSampleDescription(
+    AUDIO_CODEC_TO_BOX_NAME[track.info.codec],
+    track
+  )
+]);
+var videoSampleDescription = (compressionType, track) => box(compressionType, [
+  Array(6).fill(0),
+  // Reserved
+  u16(1),
+  // Data reference index
+  u16(0),
+  // Pre-defined
+  u16(0),
+  // Reserved
+  Array(12).fill(0),
+  // Pre-defined
+  u16(track.info.width),
+  // Width
+  u16(track.info.height),
+  // Height
+  u32(4718592),
+  // Horizontal resolution
+  u32(4718592),
+  // Vertical resolution
+  u32(0),
+  // Reserved
+  u16(1),
+  // Frame count
+  Array(32).fill(0),
+  // Compressor name
+  u16(24),
+  // Depth
+  i16(65535)
+  // Pre-defined
+], [
+  VIDEO_CODEC_TO_CONFIGURATION_BOX[track.info.codec](track),
+  track.info.decoderConfig.colorSpace ? colr(track) : null
+]);
+var COLOR_PRIMARIES_MAP = {
+  "bt709": 1,
+  // ITU-R BT.709
+  "bt470bg": 5,
+  // ITU-R BT.470BG
+  "smpte170m": 6
+  // ITU-R BT.601 525 - SMPTE 170M
+};
+var TRANSFER_CHARACTERISTICS_MAP = {
+  "bt709": 1,
+  // ITU-R BT.709
+  "smpte170m": 6,
+  // SMPTE 170M
+  "iec61966-2-1": 13
+  // IEC 61966-2-1
+};
+var MATRIX_COEFFICIENTS_MAP = {
+  "rgb": 0,
+  // Identity
+  "bt709": 1,
+  // ITU-R BT.709
+  "bt470bg": 5,
+  // ITU-R BT.470BG
+  "smpte170m": 6
+  // SMPTE 170M
+};
+var colr = (track) => box("colr", [
+  ascii("nclx"),
+  // Colour type
+  u16(COLOR_PRIMARIES_MAP[track.info.decoderConfig.colorSpace.primaries]),
+  // Colour primaries
+  u16(TRANSFER_CHARACTERISTICS_MAP[track.info.decoderConfig.colorSpace.transfer]),
+  // Transfer characteristics
+  u16(MATRIX_COEFFICIENTS_MAP[track.info.decoderConfig.colorSpace.matrix]),
+  // Matrix coefficients
+  u8((track.info.decoderConfig.colorSpace.fullRange ? 1 : 0) << 7)
+  // Full range flag
+]);
+var avcC = (track) => track.info.decoderConfig && box("avcC", [
+  // For AVC, description is an AVCDecoderConfigurationRecord, so nothing else to do here
+  ...new Uint8Array(track.info.decoderConfig.description)
+]);
+var hvcC = (track) => track.info.decoderConfig && box("hvcC", [
+  // For HEVC, description is a HEVCDecoderConfigurationRecord, so nothing else to do here
+  ...new Uint8Array(track.info.decoderConfig.description)
+]);
+var vpcC = (track) => {
+  if (!track.info.decoderConfig) {
+    return null;
+  }
+  let decoderConfig = track.info.decoderConfig;
+  if (!decoderConfig.colorSpace) {
+    throw new Error(`'colorSpace' is required in the decoder config for VP9.`);
+  }
+  let parts = decoderConfig.codec.split(".");
+  let profile = Number(parts[1]);
+  let level = Number(parts[2]);
+  let bitDepth = Number(parts[3]);
+  let chromaSubsampling = 0;
+  let thirdByte = (bitDepth << 4) + (chromaSubsampling << 1) + Number(decoderConfig.colorSpace.fullRange);
+  let colourPrimaries = 2;
+  let transferCharacteristics = 2;
+  let matrixCoefficients = 2;
+  return fullBox("vpcC", 1, 0, [
+    u8(profile),
+    // Profile
+    u8(level),
+    // Level
+    u8(thirdByte),
+    // Bit depth, chroma subsampling, full range
+    u8(colourPrimaries),
+    // Colour primaries
+    u8(transferCharacteristics),
+    // Transfer characteristics
+    u8(matrixCoefficients),
+    // Matrix coefficients
+    u16(0)
+    // Codec initialization data size
+  ]);
+};
+var av1C = () => {
+  let marker = 1;
+  let version = 1;
+  let firstByte = (marker << 7) + version;
+  return box("av1C", [
+    firstByte,
+    0,
+    0,
+    0
+  ]);
+};
+var soundSampleDescription = (compressionType, track) => box(compressionType, [
+  Array(6).fill(0),
+  // Reserved
+  u16(1),
+  // Data reference index
+  u16(0),
+  // Version
+  u16(0),
+  // Revision level
+  u32(0),
+  // Vendor
+  u16(track.info.numberOfChannels),
+  // Number of channels
+  u16(16),
+  // Sample size (bits)
+  u16(0),
+  // Compression ID
+  u16(0),
+  // Packet size
+  fixed_16_16(track.info.sampleRate)
+  // Sample rate
+], [
+  AUDIO_CODEC_TO_CONFIGURATION_BOX[track.info.codec](track)
+]);
+var esds = (track) => {
+  let description = new Uint8Array(track.info.decoderConfig.description);
+  return fullBox("esds", 0, 0, [
+    // https://stackoverflow.com/a/54803118
+    u32(58753152),
+    // TAG(3) = Object Descriptor ([2])
+    u8(32 + description.byteLength),
+    // length of this OD (which includes the next 2 tags)
+    u16(1),
+    // ES_ID = 1
+    u8(0),
+    // flags etc = 0
+    u32(75530368),
+    // TAG(4) = ES Descriptor ([2]) embedded in above OD
+    u8(18 + description.byteLength),
+    // length of this ESD
+    u8(64),
+    // MPEG-4 Audio
+    u8(21),
+    // stream type(6bits)=5 audio, flags(2bits)=1
+    u24(0),
+    // 24bit buffer size
+    u32(130071),
+    // max bitrate
+    u32(130071),
+    // avg bitrate
+    u32(92307584),
+    // TAG(5) = ASC ([2],[3]) embedded in above OD
+    u8(description.byteLength),
+    // length
+    ...description,
+    u32(109084800),
+    // TAG(6)
+    u8(1),
+    // length
+    u8(2)
+    // data
+  ]);
+};
+var dOps = (track) => {
+  let preskip = 3840;
+  let gain = 0;
+  const description = track.info.decoderConfig?.description;
+  if (description) {
+    if (description.byteLength < 18) {
+      throw new TypeError("Invalid decoder description provided for Opus; must be at least 18 bytes long.");
+    }
+    const view2 = ArrayBuffer.isView(description) ? new DataView(description.buffer, description.byteOffset, description.byteLength) : new DataView(description);
+    preskip = view2.getUint16(10, true);
+    gain = view2.getInt16(14, true);
+  }
+  return box("dOps", [
+    u8(0),
+    // Version
+    u8(track.info.numberOfChannels),
+    // OutputChannelCount
+    u16(preskip),
+    u32(track.info.sampleRate),
+    // InputSampleRate
+    fixed_8_8(gain),
+    // OutputGain
+    u8(0)
+    // ChannelMappingFamily
+  ]);
+};
+var stts = (track) => {
+  return fullBox("stts", 0, 0, [
+    u32(track.timeToSampleTable.length),
+    // Number of entries
+    track.timeToSampleTable.map((x) => [
+      // Time-to-sample table
+      u32(x.sampleCount),
+      // Sample count
+      u32(x.sampleDelta)
+      // Sample duration
+    ])
+  ]);
+};
+var stss = (track) => {
+  if (track.samples.every((x) => x.type === "key"))
+    return null;
+  let keySamples = [...track.samples.entries()].filter(([, sample]) => sample.type === "key");
+  return fullBox("stss", 0, 0, [
+    u32(keySamples.length),
+    // Number of entries
+    keySamples.map(([index]) => u32(index + 1))
+    // Sync sample table
+  ]);
+};
+var stsc = (track) => {
+  return fullBox("stsc", 0, 0, [
+    u32(track.compactlyCodedChunkTable.length),
+    // Number of entries
+    track.compactlyCodedChunkTable.map((x) => [
+      // Sample-to-chunk table
+      u32(x.firstChunk),
+      // First chunk
+      u32(x.samplesPerChunk),
+      // Samples per chunk
+      u32(1)
+      // Sample description index
+    ])
+  ]);
+};
+var stsz = (track) => fullBox("stsz", 0, 0, [
+  u32(0),
+  // Sample size (0 means non-constant size)
+  u32(track.samples.length),
+  // Number of entries
+  track.samples.map((x) => u32(x.size))
+  // Sample size table
+]);
+var stco = (track) => {
+  if (track.finalizedChunks.length > 0 && last(track.finalizedChunks).offset >= 2 ** 32) {
+    return fullBox("co64", 0, 0, [
+      u32(track.finalizedChunks.length),
+      // Number of entries
+      track.finalizedChunks.map((x) => u64(x.offset))
+      // Chunk offset table
+    ]);
+  }
+  return fullBox("stco", 0, 0, [
+    u32(track.finalizedChunks.length),
+    // Number of entries
+    track.finalizedChunks.map((x) => u32(x.offset))
+    // Chunk offset table
+  ]);
+};
+var ctts = (track) => {
+  return fullBox("ctts", 0, 0, [
+    u32(track.compositionTimeOffsetTable.length),
+    // Number of entries
+    track.compositionTimeOffsetTable.map((x) => [
+      // Time-to-sample table
+      u32(x.sampleCount),
+      // Sample count
+      u32(x.sampleCompositionTimeOffset)
+      // Sample offset
+    ])
+  ]);
+};
+var mvex = (tracks) => {
+  return box("mvex", null, tracks.map(trex));
+};
+var trex = (track) => {
+  return fullBox("trex", 0, 0, [
+    u32(track.id),
+    // Track ID
+    u32(1),
+    // Default sample description index
+    u32(0),
+    // Default sample duration
+    u32(0),
+    // Default sample size
+    u32(0)
+    // Default sample flags
+  ]);
+};
+var moof = (sequenceNumber, tracks) => {
+  return box("moof", null, [
+    mfhd(sequenceNumber),
+    ...tracks.map(traf)
+  ]);
+};
+var mfhd = (sequenceNumber) => {
+  return fullBox("mfhd", 0, 0, [
+    u32(sequenceNumber)
+    // Sequence number
+  ]);
+};
+var fragmentSampleFlags = (sample) => {
+  let byte1 = 0;
+  let byte2 = 0;
+  let byte3 = 0;
+  let byte4 = 0;
+  let sampleIsDifferenceSample = sample.type === "delta";
+  byte2 |= +sampleIsDifferenceSample;
+  if (sampleIsDifferenceSample) {
+    byte1 |= 1;
+  } else {
+    byte1 |= 2;
+  }
+  return byte1 << 24 | byte2 << 16 | byte3 << 8 | byte4;
+};
+var traf = (track) => {
+  return box("traf", null, [
+    tfhd(track),
+    tfdt(track),
+    trun(track)
+  ]);
+};
+var tfhd = (track) => {
+  let tfFlags = 0;
+  tfFlags |= 8;
+  tfFlags |= 16;
+  tfFlags |= 32;
+  tfFlags |= 131072;
+  let referenceSample = track.currentChunk.samples[1] ?? track.currentChunk.samples[0];
+  let referenceSampleInfo = {
+    duration: referenceSample.timescaleUnitsToNextSample,
+    size: referenceSample.size,
+    flags: fragmentSampleFlags(referenceSample)
+  };
+  return fullBox("tfhd", 0, tfFlags, [
+    u32(track.id),
+    // Track ID
+    u32(referenceSampleInfo.duration),
+    // Default sample duration
+    u32(referenceSampleInfo.size),
+    // Default sample size
+    u32(referenceSampleInfo.flags)
+    // Default sample flags
+  ]);
+};
+var tfdt = (track) => {
+  return fullBox("tfdt", 1, 0, [
+    u64(intoTimescale(track.currentChunk.startTimestamp, track.timescale))
+    // Base Media Decode Time
+  ]);
+};
+var trun = (track) => {
+  let allSampleDurations = track.currentChunk.samples.map((x) => x.timescaleUnitsToNextSample);
+  let allSampleSizes = track.currentChunk.samples.map((x) => x.size);
+  let allSampleFlags = track.currentChunk.samples.map(fragmentSampleFlags);
+  let allSampleCompositionTimeOffsets = track.currentChunk.samples.map((x) => intoTimescale(x.presentationTimestamp - x.decodeTimestamp, track.timescale));
+  let uniqueSampleDurations = new Set(allSampleDurations);
+  let uniqueSampleSizes = new Set(allSampleSizes);
+  let uniqueSampleFlags = new Set(allSampleFlags);
+  let uniqueSampleCompositionTimeOffsets = new Set(allSampleCompositionTimeOffsets);
+  let firstSampleFlagsPresent = uniqueSampleFlags.size === 2 && allSampleFlags[0] !== allSampleFlags[1];
+  let sampleDurationPresent = uniqueSampleDurations.size > 1;
+  let sampleSizePresent = uniqueSampleSizes.size > 1;
+  let sampleFlagsPresent = !firstSampleFlagsPresent && uniqueSampleFlags.size > 1;
+  let sampleCompositionTimeOffsetsPresent = uniqueSampleCompositionTimeOffsets.size > 1 || [...uniqueSampleCompositionTimeOffsets].some((x) => x !== 0);
+  let flags = 0;
+  flags |= 1;
+  flags |= 4 * +firstSampleFlagsPresent;
+  flags |= 256 * +sampleDurationPresent;
+  flags |= 512 * +sampleSizePresent;
+  flags |= 1024 * +sampleFlagsPresent;
+  flags |= 2048 * +sampleCompositionTimeOffsetsPresent;
+  return fullBox("trun", 1, flags, [
+    u32(track.currentChunk.samples.length),
+    // Sample count
+    u32(track.currentChunk.offset - track.currentChunk.moofOffset || 0),
+    // Data offset
+    firstSampleFlagsPresent ? u32(allSampleFlags[0]) : [],
+    track.currentChunk.samples.map((_, i) => [
+      sampleDurationPresent ? u32(allSampleDurations[i]) : [],
+      // Sample duration
+      sampleSizePresent ? u32(allSampleSizes[i]) : [],
+      // Sample size
+      sampleFlagsPresent ? u32(allSampleFlags[i]) : [],
+      // Sample flags
+      // Sample composition time offsets
+      sampleCompositionTimeOffsetsPresent ? i32(allSampleCompositionTimeOffsets[i]) : []
+    ])
+  ]);
+};
+var mfra = (tracks) => {
+  return box("mfra", null, [
+    ...tracks.map(tfra),
+    mfro()
+  ]);
+};
+var tfra = (track, trackIndex) => {
+  let version = 1;
+  return fullBox("tfra", version, 0, [
+    u32(track.id),
+    // Track ID
+    u32(63),
+    // This specifies that traf number, trun number and sample number are 32-bit ints
+    u32(track.finalizedChunks.length),
+    // Number of entries
+    track.finalizedChunks.map((chunk) => [
+      u64(intoTimescale(chunk.startTimestamp, track.timescale)),
+      // Time
+      u64(chunk.moofOffset),
+      // moof offset
+      u32(trackIndex + 1),
+      // traf number
+      u32(1),
+      // trun number
+      u32(1)
+      // Sample number
+    ])
+  ]);
+};
+var mfro = () => {
+  return fullBox("mfro", 0, 0, [
+    // This value needs to be overwritten manually from the outside, where the actual size of the enclosing mfra box
+    // is known
+    u32(0)
+    // Size
+  ]);
+};
+var VIDEO_CODEC_TO_BOX_NAME = {
+  "avc": "avc1",
+  "hevc": "hvc1",
+  "vp9": "vp09",
+  "av1": "av01"
+};
+var VIDEO_CODEC_TO_CONFIGURATION_BOX = {
+  "avc": avcC,
+  "hevc": hvcC,
+  "vp9": vpcC,
+  "av1": av1C
+};
+var AUDIO_CODEC_TO_BOX_NAME = {
+  "aac": "mp4a",
+  "opus": "Opus"
+};
+var AUDIO_CODEC_TO_CONFIGURATION_BOX = {
+  "aac": esds,
+  "opus": dOps
+};
+var Target = class {
+};
+var ArrayBufferTarget = class extends Target {
+  constructor() {
+    super(...arguments);
+    this.buffer = null;
+  }
+};
+var StreamTarget = class extends Target {
+  constructor(options) {
+    super();
+    this.options = options;
+    if (typeof options !== "object") {
+      throw new TypeError("StreamTarget requires an options object to be passed to its constructor.");
+    }
+    if (options.onData) {
+      if (typeof options.onData !== "function") {
+        throw new TypeError("options.onData, when provided, must be a function.");
+      }
+      if (options.onData.length < 2) {
+        throw new TypeError(
+          "options.onData, when provided, must be a function that takes in at least two arguments (data and position). Ignoring the position argument, which specifies the byte offset at which the data is to be written, can lead to broken outputs."
+        );
+      }
+    }
+    if (options.chunked !== void 0 && typeof options.chunked !== "boolean") {
+      throw new TypeError("options.chunked, when provided, must be a boolean.");
+    }
+    if (options.chunkSize !== void 0 && (!Number.isInteger(options.chunkSize) || options.chunkSize < 1024)) {
+      throw new TypeError("options.chunkSize, when provided, must be an integer and not smaller than 1024.");
+    }
+  }
+};
+var FileSystemWritableFileStreamTarget = class extends Target {
+  constructor(stream, options) {
+    super();
+    this.stream = stream;
+    this.options = options;
+    if (!(stream instanceof FileSystemWritableFileStream)) {
+      throw new TypeError("FileSystemWritableFileStreamTarget requires a FileSystemWritableFileStream instance.");
+    }
+    if (options !== void 0 && typeof options !== "object") {
+      throw new TypeError("FileSystemWritableFileStreamTarget's options, when provided, must be an object.");
+    }
+    if (options) {
+      if (options.chunkSize !== void 0 && (!Number.isInteger(options.chunkSize) || options.chunkSize <= 0)) {
+        throw new TypeError("options.chunkSize, when provided, must be a positive integer");
+      }
+    }
+  }
+};
+var _helper;
+var _helperView;
+var Writer = class {
+  constructor() {
+    this.pos = 0;
+    __privateAdd(this, _helper, new Uint8Array(8));
+    __privateAdd(this, _helperView, new DataView(__privateGet(this, _helper).buffer));
+    this.offsets = /* @__PURE__ */ new WeakMap();
+  }
+  /** Sets the current position for future writes to a new one. */
+  seek(newPos) {
+    this.pos = newPos;
+  }
+  writeU32(value) {
+    __privateGet(this, _helperView).setUint32(0, value, false);
+    this.write(__privateGet(this, _helper).subarray(0, 4));
+  }
+  writeU64(value) {
+    __privateGet(this, _helperView).setUint32(0, Math.floor(value / 2 ** 32), false);
+    __privateGet(this, _helperView).setUint32(4, value, false);
+    this.write(__privateGet(this, _helper).subarray(0, 8));
+  }
+  writeAscii(text) {
+    for (let i = 0; i < text.length; i++) {
+      __privateGet(this, _helperView).setUint8(i % 8, text.charCodeAt(i));
+      if (i % 8 === 7)
+        this.write(__privateGet(this, _helper));
+    }
+    if (text.length % 8 !== 0) {
+      this.write(__privateGet(this, _helper).subarray(0, text.length % 8));
+    }
+  }
+  writeBox(box2) {
+    this.offsets.set(box2, this.pos);
+    if (box2.contents && !box2.children) {
+      this.writeBoxHeader(box2, box2.size ?? box2.contents.byteLength + 8);
+      this.write(box2.contents);
+    } else {
+      let startPos = this.pos;
+      this.writeBoxHeader(box2, 0);
+      if (box2.contents)
+        this.write(box2.contents);
+      if (box2.children) {
+        for (let child of box2.children)
+          if (child)
+            this.writeBox(child);
+      }
+      let endPos = this.pos;
+      let size = box2.size ?? endPos - startPos;
+      this.seek(startPos);
+      this.writeBoxHeader(box2, size);
+      this.seek(endPos);
+    }
+  }
+  writeBoxHeader(box2, size) {
+    this.writeU32(box2.largeSize ? 1 : size);
+    this.writeAscii(box2.type);
+    if (box2.largeSize)
+      this.writeU64(size);
+  }
+  measureBoxHeader(box2) {
+    return 8 + (box2.largeSize ? 8 : 0);
+  }
+  patchBox(box2) {
+    let endPos = this.pos;
+    this.seek(this.offsets.get(box2));
+    this.writeBox(box2);
+    this.seek(endPos);
+  }
+  measureBox(box2) {
+    if (box2.contents && !box2.children) {
+      let headerSize = this.measureBoxHeader(box2);
+      return headerSize + box2.contents.byteLength;
+    } else {
+      let result = this.measureBoxHeader(box2);
+      if (box2.contents)
+        result += box2.contents.byteLength;
+      if (box2.children) {
+        for (let child of box2.children)
+          if (child)
+            result += this.measureBox(child);
+      }
+      return result;
+    }
+  }
+};
+_helper = /* @__PURE__ */ new WeakMap();
+_helperView = /* @__PURE__ */ new WeakMap();
+var _target;
+var _buffer;
+var _bytes;
+var _maxPos;
+var _ensureSize;
+var ensureSize_fn;
+var ArrayBufferTargetWriter = class extends Writer {
+  constructor(target) {
+    super();
+    __privateAdd(this, _ensureSize);
+    __privateAdd(this, _target, void 0);
+    __privateAdd(this, _buffer, new ArrayBuffer(2 ** 16));
+    __privateAdd(this, _bytes, new Uint8Array(__privateGet(this, _buffer)));
+    __privateAdd(this, _maxPos, 0);
+    __privateSet(this, _target, target);
+  }
+  write(data) {
+    __privateMethod(this, _ensureSize, ensureSize_fn).call(this, this.pos + data.byteLength);
+    __privateGet(this, _bytes).set(data, this.pos);
+    this.pos += data.byteLength;
+    __privateSet(this, _maxPos, Math.max(__privateGet(this, _maxPos), this.pos));
+  }
+  finalize() {
+    __privateMethod(this, _ensureSize, ensureSize_fn).call(this, this.pos);
+    __privateGet(this, _target).buffer = __privateGet(this, _buffer).slice(0, Math.max(__privateGet(this, _maxPos), this.pos));
+  }
+};
+_target = /* @__PURE__ */ new WeakMap();
+_buffer = /* @__PURE__ */ new WeakMap();
+_bytes = /* @__PURE__ */ new WeakMap();
+_maxPos = /* @__PURE__ */ new WeakMap();
+_ensureSize = /* @__PURE__ */ new WeakSet();
+ensureSize_fn = function(size) {
+  let newLength = __privateGet(this, _buffer).byteLength;
+  while (newLength < size)
+    newLength *= 2;
+  if (newLength === __privateGet(this, _buffer).byteLength)
+    return;
+  let newBuffer = new ArrayBuffer(newLength);
+  let newBytes = new Uint8Array(newBuffer);
+  newBytes.set(__privateGet(this, _bytes), 0);
+  __privateSet(this, _buffer, newBuffer);
+  __privateSet(this, _bytes, newBytes);
+};
+var DEFAULT_CHUNK_SIZE = 2 ** 24;
+var MAX_CHUNKS_AT_ONCE = 2;
+var _target2;
+var _sections;
+var _chunked;
+var _chunkSize;
+var _chunks;
+var _writeDataIntoChunks;
+var writeDataIntoChunks_fn;
+var _insertSectionIntoChunk;
+var insertSectionIntoChunk_fn;
+var _createChunk;
+var createChunk_fn;
+var _flushChunks;
+var flushChunks_fn;
+var StreamTargetWriter = class extends Writer {
+  constructor(target) {
+    super();
+    __privateAdd(this, _writeDataIntoChunks);
+    __privateAdd(this, _insertSectionIntoChunk);
+    __privateAdd(this, _createChunk);
+    __privateAdd(this, _flushChunks);
+    __privateAdd(this, _target2, void 0);
+    __privateAdd(this, _sections, []);
+    __privateAdd(this, _chunked, void 0);
+    __privateAdd(this, _chunkSize, void 0);
+    __privateAdd(this, _chunks, []);
+    __privateSet(this, _target2, target);
+    __privateSet(this, _chunked, target.options?.chunked ?? false);
+    __privateSet(this, _chunkSize, target.options?.chunkSize ?? DEFAULT_CHUNK_SIZE);
+  }
+  write(data) {
+    __privateGet(this, _sections).push({
+      data: data.slice(),
+      start: this.pos
+    });
+    this.pos += data.byteLength;
+  }
+  flush() {
+    if (__privateGet(this, _sections).length === 0)
+      return;
+    let chunks = [];
+    let sorted = [...__privateGet(this, _sections)].sort((a, b) => a.start - b.start);
+    chunks.push({
+      start: sorted[0].start,
+      size: sorted[0].data.byteLength
+    });
+    for (let i = 1; i < sorted.length; i++) {
+      let lastChunk = chunks[chunks.length - 1];
+      let section = sorted[i];
+      if (section.start <= lastChunk.start + lastChunk.size) {
+        lastChunk.size = Math.max(lastChunk.size, section.start + section.data.byteLength - lastChunk.start);
+      } else {
+        chunks.push({
+          start: section.start,
+          size: section.data.byteLength
+        });
+      }
+    }
+    for (let chunk of chunks) {
+      chunk.data = new Uint8Array(chunk.size);
+      for (let section of __privateGet(this, _sections)) {
+        if (chunk.start <= section.start && section.start < chunk.start + chunk.size) {
+          chunk.data.set(section.data, section.start - chunk.start);
+        }
+      }
+      if (__privateGet(this, _chunked)) {
+        __privateMethod(this, _writeDataIntoChunks, writeDataIntoChunks_fn).call(this, chunk.data, chunk.start);
+        __privateMethod(this, _flushChunks, flushChunks_fn).call(this);
+      } else {
+        __privateGet(this, _target2).options.onData?.(chunk.data, chunk.start);
+      }
+    }
+    __privateGet(this, _sections).length = 0;
+  }
+  finalize() {
+    if (__privateGet(this, _chunked)) {
+      __privateMethod(this, _flushChunks, flushChunks_fn).call(this, true);
+    }
+  }
+};
+_target2 = /* @__PURE__ */ new WeakMap();
+_sections = /* @__PURE__ */ new WeakMap();
+_chunked = /* @__PURE__ */ new WeakMap();
+_chunkSize = /* @__PURE__ */ new WeakMap();
+_chunks = /* @__PURE__ */ new WeakMap();
+_writeDataIntoChunks = /* @__PURE__ */ new WeakSet();
+writeDataIntoChunks_fn = function(data, position) {
+  let chunkIndex = __privateGet(this, _chunks).findIndex((x) => x.start <= position && position < x.start + __privateGet(this, _chunkSize));
+  if (chunkIndex === -1)
+    chunkIndex = __privateMethod(this, _createChunk, createChunk_fn).call(this, position);
+  let chunk = __privateGet(this, _chunks)[chunkIndex];
+  let relativePosition = position - chunk.start;
+  let toWrite = data.subarray(0, Math.min(__privateGet(this, _chunkSize) - relativePosition, data.byteLength));
+  chunk.data.set(toWrite, relativePosition);
+  let section = {
+    start: relativePosition,
+    end: relativePosition + toWrite.byteLength
+  };
+  __privateMethod(this, _insertSectionIntoChunk, insertSectionIntoChunk_fn).call(this, chunk, section);
+  if (chunk.written[0].start === 0 && chunk.written[0].end === __privateGet(this, _chunkSize)) {
+    chunk.shouldFlush = true;
+  }
+  if (__privateGet(this, _chunks).length > MAX_CHUNKS_AT_ONCE) {
+    for (let i = 0; i < __privateGet(this, _chunks).length - 1; i++) {
+      __privateGet(this, _chunks)[i].shouldFlush = true;
+    }
+    __privateMethod(this, _flushChunks, flushChunks_fn).call(this);
+  }
+  if (toWrite.byteLength < data.byteLength) {
+    __privateMethod(this, _writeDataIntoChunks, writeDataIntoChunks_fn).call(this, data.subarray(toWrite.byteLength), position + toWrite.byteLength);
+  }
+};
+_insertSectionIntoChunk = /* @__PURE__ */ new WeakSet();
+insertSectionIntoChunk_fn = function(chunk, section) {
+  let low = 0;
+  let high = chunk.written.length - 1;
+  let index = -1;
+  while (low <= high) {
+    let mid = Math.floor(low + (high - low + 1) / 2);
+    if (chunk.written[mid].start <= section.start) {
+      low = mid + 1;
+      index = mid;
+    } else {
+      high = mid - 1;
+    }
+  }
+  chunk.written.splice(index + 1, 0, section);
+  if (index === -1 || chunk.written[index].end < section.start)
+    index++;
+  while (index < chunk.written.length - 1 && chunk.written[index].end >= chunk.written[index + 1].start) {
+    chunk.written[index].end = Math.max(chunk.written[index].end, chunk.written[index + 1].end);
+    chunk.written.splice(index + 1, 1);
+  }
+};
+_createChunk = /* @__PURE__ */ new WeakSet();
+createChunk_fn = function(includesPosition) {
+  let start = Math.floor(includesPosition / __privateGet(this, _chunkSize)) * __privateGet(this, _chunkSize);
+  let chunk = {
+    start,
+    data: new Uint8Array(__privateGet(this, _chunkSize)),
+    written: [],
+    shouldFlush: false
+  };
+  __privateGet(this, _chunks).push(chunk);
+  __privateGet(this, _chunks).sort((a, b) => a.start - b.start);
+  return __privateGet(this, _chunks).indexOf(chunk);
+};
+_flushChunks = /* @__PURE__ */ new WeakSet();
+flushChunks_fn = function(force = false) {
+  for (let i = 0; i < __privateGet(this, _chunks).length; i++) {
+    let chunk = __privateGet(this, _chunks)[i];
+    if (!chunk.shouldFlush && !force)
+      continue;
+    for (let section of chunk.written) {
+      __privateGet(this, _target2).options.onData?.(
+        chunk.data.subarray(section.start, section.end),
+        chunk.start + section.start
+      );
+    }
+    __privateGet(this, _chunks).splice(i--, 1);
+  }
+};
+var FileSystemWritableFileStreamTargetWriter = class extends StreamTargetWriter {
+  constructor(target) {
+    super(new StreamTarget({
+      onData: (data, position) => target.stream.write({
+        type: "write",
+        data,
+        position
+      }),
+      chunked: true,
+      chunkSize: target.options?.chunkSize
+    }));
+  }
+};
+var GLOBAL_TIMESCALE = 1e3;
+var SUPPORTED_VIDEO_CODECS = ["avc", "hevc", "vp9", "av1"];
+var SUPPORTED_AUDIO_CODECS = ["aac", "opus"];
+var TIMESTAMP_OFFSET = 2082844800;
+var FIRST_TIMESTAMP_BEHAVIORS = ["strict", "offset", "cross-track-offset"];
+var _options;
+var _writer;
+var _ftypSize;
+var _mdat;
+var _videoTrack;
+var _audioTrack;
+var _creationTime;
+var _finalizedChunks;
+var _nextFragmentNumber;
+var _videoSampleQueue;
+var _audioSampleQueue;
+var _finalized;
+var _validateOptions;
+var validateOptions_fn;
+var _writeHeader;
+var writeHeader_fn;
+var _computeMoovSizeUpperBound;
+var computeMoovSizeUpperBound_fn;
+var _prepareTracks;
+var prepareTracks_fn;
+var _generateMpeg4AudioSpecificConfig;
+var generateMpeg4AudioSpecificConfig_fn;
+var _createSampleForTrack;
+var createSampleForTrack_fn;
+var _addSampleToTrack;
+var addSampleToTrack_fn;
+var _validateTimestamp;
+var validateTimestamp_fn;
+var _finalizeCurrentChunk;
+var finalizeCurrentChunk_fn;
+var _finalizeFragment;
+var finalizeFragment_fn;
+var _maybeFlushStreamingTargetWriter;
+var maybeFlushStreamingTargetWriter_fn;
+var _ensureNotFinalized;
+var ensureNotFinalized_fn;
+var Muxer = class {
+  constructor(options) {
+    __privateAdd(this, _validateOptions);
+    __privateAdd(this, _writeHeader);
+    __privateAdd(this, _computeMoovSizeUpperBound);
+    __privateAdd(this, _prepareTracks);
+    __privateAdd(this, _generateMpeg4AudioSpecificConfig);
+    __privateAdd(this, _createSampleForTrack);
+    __privateAdd(this, _addSampleToTrack);
+    __privateAdd(this, _validateTimestamp);
+    __privateAdd(this, _finalizeCurrentChunk);
+    __privateAdd(this, _finalizeFragment);
+    __privateAdd(this, _maybeFlushStreamingTargetWriter);
+    __privateAdd(this, _ensureNotFinalized);
+    __privateAdd(this, _options, void 0);
+    __privateAdd(this, _writer, void 0);
+    __privateAdd(this, _ftypSize, void 0);
+    __privateAdd(this, _mdat, void 0);
+    __privateAdd(this, _videoTrack, null);
+    __privateAdd(this, _audioTrack, null);
+    __privateAdd(this, _creationTime, Math.floor(Date.now() / 1e3) + TIMESTAMP_OFFSET);
+    __privateAdd(this, _finalizedChunks, []);
+    __privateAdd(this, _nextFragmentNumber, 1);
+    __privateAdd(this, _videoSampleQueue, []);
+    __privateAdd(this, _audioSampleQueue, []);
+    __privateAdd(this, _finalized, false);
+    __privateMethod(this, _validateOptions, validateOptions_fn).call(this, options);
+    options.video = deepClone(options.video);
+    options.audio = deepClone(options.audio);
+    options.fastStart = deepClone(options.fastStart);
+    this.target = options.target;
+    __privateSet(this, _options, {
+      firstTimestampBehavior: "strict",
+      ...options
+    });
+    if (options.target instanceof ArrayBufferTarget) {
+      __privateSet(this, _writer, new ArrayBufferTargetWriter(options.target));
+    } else if (options.target instanceof StreamTarget) {
+      __privateSet(this, _writer, new StreamTargetWriter(options.target));
+    } else if (options.target instanceof FileSystemWritableFileStreamTarget) {
+      __privateSet(this, _writer, new FileSystemWritableFileStreamTargetWriter(options.target));
+    } else {
+      throw new Error(`Invalid target: ${options.target}`);
+    }
+    __privateMethod(this, _prepareTracks, prepareTracks_fn).call(this);
+    __privateMethod(this, _writeHeader, writeHeader_fn).call(this);
+  }
+  addVideoChunk(sample, meta, timestamp, compositionTimeOffset) {
+    if (!(sample instanceof EncodedVideoChunk)) {
+      throw new TypeError("addVideoChunk's first argument (sample) must be of type EncodedVideoChunk.");
+    }
+    if (meta && typeof meta !== "object") {
+      throw new TypeError("addVideoChunk's second argument (meta), when provided, must be an object.");
+    }
+    if (timestamp !== void 0 && (!Number.isFinite(timestamp) || timestamp < 0)) {
+      throw new TypeError(
+        "addVideoChunk's third argument (timestamp), when provided, must be a non-negative real number."
+      );
+    }
+    if (compositionTimeOffset !== void 0 && !Number.isFinite(compositionTimeOffset)) {
+      throw new TypeError(
+        "addVideoChunk's fourth argument (compositionTimeOffset), when provided, must be a real number."
+      );
+    }
+    let data = new Uint8Array(sample.byteLength);
+    sample.copyTo(data);
+    this.addVideoChunkRaw(
+      data,
+      sample.type,
+      timestamp ?? sample.timestamp,
+      sample.duration,
+      meta,
+      compositionTimeOffset
+    );
+  }
+  addVideoChunkRaw(data, type, timestamp, duration, meta, compositionTimeOffset) {
+    if (!(data instanceof Uint8Array)) {
+      throw new TypeError("addVideoChunkRaw's first argument (data) must be an instance of Uint8Array.");
+    }
+    if (type !== "key" && type !== "delta") {
+      throw new TypeError("addVideoChunkRaw's second argument (type) must be either 'key' or 'delta'.");
+    }
+    if (!Number.isFinite(timestamp) || timestamp < 0) {
+      throw new TypeError("addVideoChunkRaw's third argument (timestamp) must be a non-negative real number.");
+    }
+    if (!Number.isFinite(duration) || duration < 0) {
+      throw new TypeError("addVideoChunkRaw's fourth argument (duration) must be a non-negative real number.");
+    }
+    if (meta && typeof meta !== "object") {
+      throw new TypeError("addVideoChunkRaw's fifth argument (meta), when provided, must be an object.");
+    }
+    if (compositionTimeOffset !== void 0 && !Number.isFinite(compositionTimeOffset)) {
+      throw new TypeError(
+        "addVideoChunkRaw's sixth argument (compositionTimeOffset), when provided, must be a real number."
+      );
+    }
+    __privateMethod(this, _ensureNotFinalized, ensureNotFinalized_fn).call(this);
+    if (!__privateGet(this, _options).video)
+      throw new Error("No video track declared.");
+    if (typeof __privateGet(this, _options).fastStart === "object" && __privateGet(this, _videoTrack).samples.length === __privateGet(this, _options).fastStart.expectedVideoChunks) {
+      throw new Error(`Cannot add more video chunks than specified in 'fastStart' (${__privateGet(this, _options).fastStart.expectedVideoChunks}).`);
+    }
+    let videoSample = __privateMethod(this, _createSampleForTrack, createSampleForTrack_fn).call(this, __privateGet(this, _videoTrack), data, type, timestamp, duration, meta, compositionTimeOffset);
+    if (__privateGet(this, _options).fastStart === "fragmented" && __privateGet(this, _audioTrack)) {
+      while (__privateGet(this, _audioSampleQueue).length > 0 && __privateGet(this, _audioSampleQueue)[0].decodeTimestamp <= videoSample.decodeTimestamp) {
+        let audioSample = __privateGet(this, _audioSampleQueue).shift();
+        __privateMethod(this, _addSampleToTrack, addSampleToTrack_fn).call(this, __privateGet(this, _audioTrack), audioSample);
+      }
+      if (videoSample.decodeTimestamp <= __privateGet(this, _audioTrack).lastDecodeTimestamp) {
+        __privateMethod(this, _addSampleToTrack, addSampleToTrack_fn).call(this, __privateGet(this, _videoTrack), videoSample);
+      } else {
+        __privateGet(this, _videoSampleQueue).push(videoSample);
+      }
+    } else {
+      __privateMethod(this, _addSampleToTrack, addSampleToTrack_fn).call(this, __privateGet(this, _videoTrack), videoSample);
+    }
+  }
+  addAudioChunk(sample, meta, timestamp) {
+    if (!(sample instanceof EncodedAudioChunk)) {
+      throw new TypeError("addAudioChunk's first argument (sample) must be of type EncodedAudioChunk.");
+    }
+    if (meta && typeof meta !== "object") {
+      throw new TypeError("addAudioChunk's second argument (meta), when provided, must be an object.");
+    }
+    if (timestamp !== void 0 && (!Number.isFinite(timestamp) || timestamp < 0)) {
+      throw new TypeError(
+        "addAudioChunk's third argument (timestamp), when provided, must be a non-negative real number."
+      );
+    }
+    let data = new Uint8Array(sample.byteLength);
+    sample.copyTo(data);
+    this.addAudioChunkRaw(data, sample.type, timestamp ?? sample.timestamp, sample.duration, meta);
+  }
+  addAudioChunkRaw(data, type, timestamp, duration, meta) {
+    if (!(data instanceof Uint8Array)) {
+      throw new TypeError("addAudioChunkRaw's first argument (data) must be an instance of Uint8Array.");
+    }
+    if (type !== "key" && type !== "delta") {
+      throw new TypeError("addAudioChunkRaw's second argument (type) must be either 'key' or 'delta'.");
+    }
+    if (!Number.isFinite(timestamp) || timestamp < 0) {
+      throw new TypeError("addAudioChunkRaw's third argument (timestamp) must be a non-negative real number.");
+    }
+    if (!Number.isFinite(duration) || duration < 0) {
+      throw new TypeError("addAudioChunkRaw's fourth argument (duration) must be a non-negative real number.");
+    }
+    if (meta && typeof meta !== "object") {
+      throw new TypeError("addAudioChunkRaw's fifth argument (meta), when provided, must be an object.");
+    }
+    __privateMethod(this, _ensureNotFinalized, ensureNotFinalized_fn).call(this);
+    if (!__privateGet(this, _options).audio)
+      throw new Error("No audio track declared.");
+    if (typeof __privateGet(this, _options).fastStart === "object" && __privateGet(this, _audioTrack).samples.length === __privateGet(this, _options).fastStart.expectedAudioChunks) {
+      throw new Error(`Cannot add more audio chunks than specified in 'fastStart' (${__privateGet(this, _options).fastStart.expectedAudioChunks}).`);
+    }
+    let audioSample = __privateMethod(this, _createSampleForTrack, createSampleForTrack_fn).call(this, __privateGet(this, _audioTrack), data, type, timestamp, duration, meta);
+    if (__privateGet(this, _options).fastStart === "fragmented" && __privateGet(this, _videoTrack)) {
+      while (__privateGet(this, _videoSampleQueue).length > 0 && __privateGet(this, _videoSampleQueue)[0].decodeTimestamp <= audioSample.decodeTimestamp) {
+        let videoSample = __privateGet(this, _videoSampleQueue).shift();
+        __privateMethod(this, _addSampleToTrack, addSampleToTrack_fn).call(this, __privateGet(this, _videoTrack), videoSample);
+      }
+      if (audioSample.decodeTimestamp <= __privateGet(this, _videoTrack).lastDecodeTimestamp) {
+        __privateMethod(this, _addSampleToTrack, addSampleToTrack_fn).call(this, __privateGet(this, _audioTrack), audioSample);
+      } else {
+        __privateGet(this, _audioSampleQueue).push(audioSample);
+      }
+    } else {
+      __privateMethod(this, _addSampleToTrack, addSampleToTrack_fn).call(this, __privateGet(this, _audioTrack), audioSample);
+    }
+  }
+  /** Finalizes the file, making it ready for use. Must be called after all video and audio chunks have been added. */
+  finalize() {
+    if (__privateGet(this, _finalized)) {
+      throw new Error("Cannot finalize a muxer more than once.");
+    }
+    if (__privateGet(this, _options).fastStart === "fragmented") {
+      for (let videoSample of __privateGet(this, _videoSampleQueue))
+        __privateMethod(this, _addSampleToTrack, addSampleToTrack_fn).call(this, __privateGet(this, _videoTrack), videoSample);
+      for (let audioSample of __privateGet(this, _audioSampleQueue))
+        __privateMethod(this, _addSampleToTrack, addSampleToTrack_fn).call(this, __privateGet(this, _audioTrack), audioSample);
+      __privateMethod(this, _finalizeFragment, finalizeFragment_fn).call(this, false);
+    } else {
+      if (__privateGet(this, _videoTrack))
+        __privateMethod(this, _finalizeCurrentChunk, finalizeCurrentChunk_fn).call(this, __privateGet(this, _videoTrack));
+      if (__privateGet(this, _audioTrack))
+        __privateMethod(this, _finalizeCurrentChunk, finalizeCurrentChunk_fn).call(this, __privateGet(this, _audioTrack));
+    }
+    let tracks = [__privateGet(this, _videoTrack), __privateGet(this, _audioTrack)].filter(Boolean);
+    if (__privateGet(this, _options).fastStart === "in-memory") {
+      let mdatSize;
+      for (let i = 0; i < 2; i++) {
+        let movieBox2 = moov(tracks, __privateGet(this, _creationTime));
+        let movieBoxSize = __privateGet(this, _writer).measureBox(movieBox2);
+        mdatSize = __privateGet(this, _writer).measureBox(__privateGet(this, _mdat));
+        let currentChunkPos = __privateGet(this, _writer).pos + movieBoxSize + mdatSize;
+        for (let chunk of __privateGet(this, _finalizedChunks)) {
+          chunk.offset = currentChunkPos;
+          for (let { data } of chunk.samples) {
+            currentChunkPos += data.byteLength;
+            mdatSize += data.byteLength;
+          }
+        }
+        if (currentChunkPos < 2 ** 32)
+          break;
+        if (mdatSize >= 2 ** 32)
+          __privateGet(this, _mdat).largeSize = true;
+      }
+      let movieBox = moov(tracks, __privateGet(this, _creationTime));
+      __privateGet(this, _writer).writeBox(movieBox);
+      __privateGet(this, _mdat).size = mdatSize;
+      __privateGet(this, _writer).writeBox(__privateGet(this, _mdat));
+      for (let chunk of __privateGet(this, _finalizedChunks)) {
+        for (let sample of chunk.samples) {
+          __privateGet(this, _writer).write(sample.data);
+          sample.data = null;
+        }
+      }
+    } else if (__privateGet(this, _options).fastStart === "fragmented") {
+      let startPos = __privateGet(this, _writer).pos;
+      let mfraBox = mfra(tracks);
+      __privateGet(this, _writer).writeBox(mfraBox);
+      let mfraBoxSize = __privateGet(this, _writer).pos - startPos;
+      __privateGet(this, _writer).seek(__privateGet(this, _writer).pos - 4);
+      __privateGet(this, _writer).writeU32(mfraBoxSize);
+    } else {
+      let mdatPos = __privateGet(this, _writer).offsets.get(__privateGet(this, _mdat));
+      let mdatSize = __privateGet(this, _writer).pos - mdatPos;
+      __privateGet(this, _mdat).size = mdatSize;
+      __privateGet(this, _mdat).largeSize = mdatSize >= 2 ** 32;
+      __privateGet(this, _writer).patchBox(__privateGet(this, _mdat));
+      let movieBox = moov(tracks, __privateGet(this, _creationTime));
+      if (typeof __privateGet(this, _options).fastStart === "object") {
+        __privateGet(this, _writer).seek(__privateGet(this, _ftypSize));
+        __privateGet(this, _writer).writeBox(movieBox);
+        let remainingBytes = mdatPos - __privateGet(this, _writer).pos;
+        __privateGet(this, _writer).writeBox(free(remainingBytes));
+      } else {
+        __privateGet(this, _writer).writeBox(movieBox);
+      }
+    }
+    __privateMethod(this, _maybeFlushStreamingTargetWriter, maybeFlushStreamingTargetWriter_fn).call(this);
+    __privateGet(this, _writer).finalize();
+    __privateSet(this, _finalized, true);
+  }
+};
+_options = /* @__PURE__ */ new WeakMap();
+_writer = /* @__PURE__ */ new WeakMap();
+_ftypSize = /* @__PURE__ */ new WeakMap();
+_mdat = /* @__PURE__ */ new WeakMap();
+_videoTrack = /* @__PURE__ */ new WeakMap();
+_audioTrack = /* @__PURE__ */ new WeakMap();
+_creationTime = /* @__PURE__ */ new WeakMap();
+_finalizedChunks = /* @__PURE__ */ new WeakMap();
+_nextFragmentNumber = /* @__PURE__ */ new WeakMap();
+_videoSampleQueue = /* @__PURE__ */ new WeakMap();
+_audioSampleQueue = /* @__PURE__ */ new WeakMap();
+_finalized = /* @__PURE__ */ new WeakMap();
+_validateOptions = /* @__PURE__ */ new WeakSet();
+validateOptions_fn = function(options) {
+  if (typeof options !== "object") {
+    throw new TypeError("The muxer requires an options object to be passed to its constructor.");
+  }
+  if (!(options.target instanceof Target)) {
+    throw new TypeError("The target must be provided and an instance of Target.");
+  }
+  if (options.video) {
+    if (!SUPPORTED_VIDEO_CODECS.includes(options.video.codec)) {
+      throw new TypeError(`Unsupported video codec: ${options.video.codec}`);
+    }
+    if (!Number.isInteger(options.video.width) || options.video.width <= 0) {
+      throw new TypeError(`Invalid video width: ${options.video.width}. Must be a positive integer.`);
+    }
+    if (!Number.isInteger(options.video.height) || options.video.height <= 0) {
+      throw new TypeError(`Invalid video height: ${options.video.height}. Must be a positive integer.`);
+    }
+    const videoRotation = options.video.rotation;
+    if (typeof videoRotation === "number" && ![0, 90, 180, 270].includes(videoRotation)) {
+      throw new TypeError(`Invalid video rotation: ${videoRotation}. Has to be 0, 90, 180 or 270.`);
+    } else if (Array.isArray(videoRotation) && (videoRotation.length !== 9 || videoRotation.some((value) => typeof value !== "number"))) {
+      throw new TypeError(`Invalid video transformation matrix: ${videoRotation.join()}`);
+    }
+    if (options.video.frameRate !== void 0 && (!Number.isInteger(options.video.frameRate) || options.video.frameRate <= 0)) {
+      throw new TypeError(
+        `Invalid video frame rate: ${options.video.frameRate}. Must be a positive integer.`
+      );
+    }
+  }
+  if (options.audio) {
+    if (!SUPPORTED_AUDIO_CODECS.includes(options.audio.codec)) {
+      throw new TypeError(`Unsupported audio codec: ${options.audio.codec}`);
+    }
+    if (!Number.isInteger(options.audio.numberOfChannels) || options.audio.numberOfChannels <= 0) {
+      throw new TypeError(
+        `Invalid number of audio channels: ${options.audio.numberOfChannels}. Must be a positive integer.`
+      );
+    }
+    if (!Number.isInteger(options.audio.sampleRate) || options.audio.sampleRate <= 0) {
+      throw new TypeError(
+        `Invalid audio sample rate: ${options.audio.sampleRate}. Must be a positive integer.`
+      );
+    }
+  }
+  if (options.firstTimestampBehavior && !FIRST_TIMESTAMP_BEHAVIORS.includes(options.firstTimestampBehavior)) {
+    throw new TypeError(`Invalid first timestamp behavior: ${options.firstTimestampBehavior}`);
+  }
+  if (typeof options.fastStart === "object") {
+    if (options.video) {
+      if (options.fastStart.expectedVideoChunks === void 0) {
+        throw new TypeError(`'fastStart' is an object but is missing property 'expectedVideoChunks'.`);
+      } else if (!Number.isInteger(options.fastStart.expectedVideoChunks) || options.fastStart.expectedVideoChunks < 0) {
+        throw new TypeError(`'expectedVideoChunks' must be a non-negative integer.`);
+      }
+    }
+    if (options.audio) {
+      if (options.fastStart.expectedAudioChunks === void 0) {
+        throw new TypeError(`'fastStart' is an object but is missing property 'expectedAudioChunks'.`);
+      } else if (!Number.isInteger(options.fastStart.expectedAudioChunks) || options.fastStart.expectedAudioChunks < 0) {
+        throw new TypeError(`'expectedAudioChunks' must be a non-negative integer.`);
+      }
+    }
+  } else if (![false, "in-memory", "fragmented"].includes(options.fastStart)) {
+    throw new TypeError(`'fastStart' option must be false, 'in-memory', 'fragmented' or an object.`);
+  }
+  if (options.minFragmentDuration !== void 0 && (!Number.isFinite(options.minFragmentDuration) || options.minFragmentDuration < 0)) {
+    throw new TypeError(`'minFragmentDuration' must be a non-negative number.`);
+  }
+};
+_writeHeader = /* @__PURE__ */ new WeakSet();
+writeHeader_fn = function() {
+  __privateGet(this, _writer).writeBox(ftyp({
+    holdsAvc: __privateGet(this, _options).video?.codec === "avc",
+    fragmented: __privateGet(this, _options).fastStart === "fragmented"
+  }));
+  __privateSet(this, _ftypSize, __privateGet(this, _writer).pos);
+  if (__privateGet(this, _options).fastStart === "in-memory") {
+    __privateSet(this, _mdat, mdat(false));
+  } else if (__privateGet(this, _options).fastStart === "fragmented") {
+  } else {
+    if (typeof __privateGet(this, _options).fastStart === "object") {
+      let moovSizeUpperBound = __privateMethod(this, _computeMoovSizeUpperBound, computeMoovSizeUpperBound_fn).call(this);
+      __privateGet(this, _writer).seek(__privateGet(this, _writer).pos + moovSizeUpperBound);
+    }
+    __privateSet(this, _mdat, mdat(true));
+    __privateGet(this, _writer).writeBox(__privateGet(this, _mdat));
+  }
+  __privateMethod(this, _maybeFlushStreamingTargetWriter, maybeFlushStreamingTargetWriter_fn).call(this);
+};
+_computeMoovSizeUpperBound = /* @__PURE__ */ new WeakSet();
+computeMoovSizeUpperBound_fn = function() {
+  if (typeof __privateGet(this, _options).fastStart !== "object")
+    return;
+  let upperBound = 0;
+  let sampleCounts = [
+    __privateGet(this, _options).fastStart.expectedVideoChunks,
+    __privateGet(this, _options).fastStart.expectedAudioChunks
+  ];
+  for (let n of sampleCounts) {
+    if (!n)
+      continue;
+    upperBound += (4 + 4) * Math.ceil(2 / 3 * n);
+    upperBound += 4 * n;
+    upperBound += (4 + 4 + 4) * Math.ceil(2 / 3 * n);
+    upperBound += 4 * n;
+    upperBound += 8 * n;
+  }
+  upperBound += 4096;
+  return upperBound;
+};
+_prepareTracks = /* @__PURE__ */ new WeakSet();
+prepareTracks_fn = function() {
+  if (__privateGet(this, _options).video) {
+    __privateSet(this, _videoTrack, {
+      id: 1,
+      info: {
+        type: "video",
+        codec: __privateGet(this, _options).video.codec,
+        width: __privateGet(this, _options).video.width,
+        height: __privateGet(this, _options).video.height,
+        rotation: __privateGet(this, _options).video.rotation ?? 0,
+        decoderConfig: null
+      },
+      // The fallback contains many common frame rates as factors
+      timescale: __privateGet(this, _options).video.frameRate ?? 57600,
+      samples: [],
+      finalizedChunks: [],
+      currentChunk: null,
+      firstDecodeTimestamp: void 0,
+      lastDecodeTimestamp: -1,
+      timeToSampleTable: [],
+      compositionTimeOffsetTable: [],
+      lastTimescaleUnits: null,
+      lastSample: null,
+      compactlyCodedChunkTable: []
+    });
+  }
+  if (__privateGet(this, _options).audio) {
+    __privateSet(this, _audioTrack, {
+      id: __privateGet(this, _options).video ? 2 : 1,
+      info: {
+        type: "audio",
+        codec: __privateGet(this, _options).audio.codec,
+        numberOfChannels: __privateGet(this, _options).audio.numberOfChannels,
+        sampleRate: __privateGet(this, _options).audio.sampleRate,
+        decoderConfig: null
+      },
+      timescale: __privateGet(this, _options).audio.sampleRate,
+      samples: [],
+      finalizedChunks: [],
+      currentChunk: null,
+      firstDecodeTimestamp: void 0,
+      lastDecodeTimestamp: -1,
+      timeToSampleTable: [],
+      compositionTimeOffsetTable: [],
+      lastTimescaleUnits: null,
+      lastSample: null,
+      compactlyCodedChunkTable: []
+    });
+    if (__privateGet(this, _options).audio.codec === "aac") {
+      let guessedCodecPrivate = __privateMethod(this, _generateMpeg4AudioSpecificConfig, generateMpeg4AudioSpecificConfig_fn).call(
+        this,
+        2,
+        // Object type for AAC-LC, since it's the most common
+        __privateGet(this, _options).audio.sampleRate,
+        __privateGet(this, _options).audio.numberOfChannels
+      );
+      __privateGet(this, _audioTrack).info.decoderConfig = {
+        codec: __privateGet(this, _options).audio.codec,
+        description: guessedCodecPrivate,
+        numberOfChannels: __privateGet(this, _options).audio.numberOfChannels,
+        sampleRate: __privateGet(this, _options).audio.sampleRate
+      };
+    }
+  }
+};
+_generateMpeg4AudioSpecificConfig = /* @__PURE__ */ new WeakSet();
+generateMpeg4AudioSpecificConfig_fn = function(objectType, sampleRate, numberOfChannels) {
+  let frequencyIndices = [96e3, 88200, 64e3, 48e3, 44100, 32e3, 24e3, 22050, 16e3, 12e3, 11025, 8e3, 7350];
+  let frequencyIndex = frequencyIndices.indexOf(sampleRate);
+  let channelConfig = numberOfChannels;
+  let configBits = "";
+  configBits += objectType.toString(2).padStart(5, "0");
+  configBits += frequencyIndex.toString(2).padStart(4, "0");
+  if (frequencyIndex === 15)
+    configBits += sampleRate.toString(2).padStart(24, "0");
+  configBits += channelConfig.toString(2).padStart(4, "0");
+  let paddingLength = Math.ceil(configBits.length / 8) * 8;
+  configBits = configBits.padEnd(paddingLength, "0");
+  let configBytes = new Uint8Array(configBits.length / 8);
+  for (let i = 0; i < configBits.length; i += 8) {
+    configBytes[i / 8] = parseInt(configBits.slice(i, i + 8), 2);
+  }
+  return configBytes;
+};
+_createSampleForTrack = /* @__PURE__ */ new WeakSet();
+createSampleForTrack_fn = function(track, data, type, timestamp, duration, meta, compositionTimeOffset) {
+  let presentationTimestampInSeconds = timestamp / 1e6;
+  let decodeTimestampInSeconds = (timestamp - (compositionTimeOffset ?? 0)) / 1e6;
+  let durationInSeconds = duration / 1e6;
+  let adjusted = __privateMethod(this, _validateTimestamp, validateTimestamp_fn).call(this, presentationTimestampInSeconds, decodeTimestampInSeconds, track);
+  presentationTimestampInSeconds = adjusted.presentationTimestamp;
+  decodeTimestampInSeconds = adjusted.decodeTimestamp;
+  if (meta?.decoderConfig) {
+    if (track.info.decoderConfig === null) {
+      track.info.decoderConfig = meta.decoderConfig;
+    } else {
+      Object.assign(track.info.decoderConfig, meta.decoderConfig);
+    }
+  }
+  let sample = {
+    presentationTimestamp: presentationTimestampInSeconds,
+    decodeTimestamp: decodeTimestampInSeconds,
+    duration: durationInSeconds,
+    data,
+    size: data.byteLength,
+    type,
+    // Will be refined once the next sample comes in
+    timescaleUnitsToNextSample: intoTimescale(durationInSeconds, track.timescale)
+  };
+  return sample;
+};
+_addSampleToTrack = /* @__PURE__ */ new WeakSet();
+addSampleToTrack_fn = function(track, sample) {
+  if (__privateGet(this, _options).fastStart !== "fragmented") {
+    track.samples.push(sample);
+  }
+  const sampleCompositionTimeOffset = intoTimescale(sample.presentationTimestamp - sample.decodeTimestamp, track.timescale);
+  if (track.lastTimescaleUnits !== null) {
+    let timescaleUnits = intoTimescale(sample.decodeTimestamp, track.timescale, false);
+    let delta = Math.round(timescaleUnits - track.lastTimescaleUnits);
+    track.lastTimescaleUnits += delta;
+    track.lastSample.timescaleUnitsToNextSample = delta;
+    if (__privateGet(this, _options).fastStart !== "fragmented") {
+      let lastTableEntry = last(track.timeToSampleTable);
+      if (lastTableEntry.sampleCount === 1) {
+        lastTableEntry.sampleDelta = delta;
+        lastTableEntry.sampleCount++;
+      } else if (lastTableEntry.sampleDelta === delta) {
+        lastTableEntry.sampleCount++;
+      } else {
+        lastTableEntry.sampleCount--;
+        track.timeToSampleTable.push({
+          sampleCount: 2,
+          sampleDelta: delta
+        });
+      }
+      const lastCompositionTimeOffsetTableEntry = last(track.compositionTimeOffsetTable);
+      if (lastCompositionTimeOffsetTableEntry.sampleCompositionTimeOffset === sampleCompositionTimeOffset) {
+        lastCompositionTimeOffsetTableEntry.sampleCount++;
+      } else {
+        track.compositionTimeOffsetTable.push({
+          sampleCount: 1,
+          sampleCompositionTimeOffset
+        });
+      }
+    }
+  } else {
+    track.lastTimescaleUnits = 0;
+    if (__privateGet(this, _options).fastStart !== "fragmented") {
+      track.timeToSampleTable.push({
+        sampleCount: 1,
+        sampleDelta: intoTimescale(sample.duration, track.timescale)
+      });
+      track.compositionTimeOffsetTable.push({
+        sampleCount: 1,
+        sampleCompositionTimeOffset
+      });
+    }
+  }
+  track.lastSample = sample;
+  let beginNewChunk = false;
+  if (!track.currentChunk) {
+    beginNewChunk = true;
+  } else {
+    let currentChunkDuration = sample.presentationTimestamp - track.currentChunk.startTimestamp;
+    if (__privateGet(this, _options).fastStart === "fragmented") {
+      let mostImportantTrack = __privateGet(this, _videoTrack) ?? __privateGet(this, _audioTrack);
+      const chunkDuration = __privateGet(this, _options).minFragmentDuration ?? 1;
+      if (track === mostImportantTrack && sample.type === "key" && currentChunkDuration >= chunkDuration) {
+        beginNewChunk = true;
+        __privateMethod(this, _finalizeFragment, finalizeFragment_fn).call(this);
+      }
+    } else {
+      beginNewChunk = currentChunkDuration >= 0.5;
+    }
+  }
+  if (beginNewChunk) {
+    if (track.currentChunk) {
+      __privateMethod(this, _finalizeCurrentChunk, finalizeCurrentChunk_fn).call(this, track);
+    }
+    track.currentChunk = {
+      startTimestamp: sample.presentationTimestamp,
+      samples: []
+    };
+  }
+  track.currentChunk.samples.push(sample);
+};
+_validateTimestamp = /* @__PURE__ */ new WeakSet();
+validateTimestamp_fn = function(presentationTimestamp, decodeTimestamp, track) {
+  const strictTimestampBehavior = __privateGet(this, _options).firstTimestampBehavior === "strict";
+  const noLastDecodeTimestamp = track.lastDecodeTimestamp === -1;
+  const timestampNonZero = decodeTimestamp !== 0;
+  if (strictTimestampBehavior && noLastDecodeTimestamp && timestampNonZero) {
+    throw new Error(
+      `The first chunk for your media track must have a timestamp of 0 (received DTS=${decodeTimestamp}).Non-zero first timestamps are often caused by directly piping frames or audio data from a MediaStreamTrack into the encoder. Their timestamps are typically relative to the age of thedocument, which is probably what you want.
+
+If you want to offset all timestamps of a track such that the first one is zero, set firstTimestampBehavior: 'offset' in the options.
+`
+    );
+  } else if (__privateGet(this, _options).firstTimestampBehavior === "offset" || __privateGet(this, _options).firstTimestampBehavior === "cross-track-offset") {
+    if (track.firstDecodeTimestamp === void 0) {
+      track.firstDecodeTimestamp = decodeTimestamp;
+    }
+    let baseDecodeTimestamp;
+    if (__privateGet(this, _options).firstTimestampBehavior === "offset") {
+      baseDecodeTimestamp = track.firstDecodeTimestamp;
+    } else {
+      baseDecodeTimestamp = Math.min(
+        __privateGet(this, _videoTrack)?.firstDecodeTimestamp ?? Infinity,
+        __privateGet(this, _audioTrack)?.firstDecodeTimestamp ?? Infinity
+      );
+    }
+    decodeTimestamp -= baseDecodeTimestamp;
+    presentationTimestamp -= baseDecodeTimestamp;
+  }
+  if (decodeTimestamp < track.lastDecodeTimestamp) {
+    throw new Error(
+      `Timestamps must be monotonically increasing (DTS went from ${track.lastDecodeTimestamp * 1e6} to ${decodeTimestamp * 1e6}).`
+    );
+  }
+  track.lastDecodeTimestamp = decodeTimestamp;
+  return { presentationTimestamp, decodeTimestamp };
+};
+_finalizeCurrentChunk = /* @__PURE__ */ new WeakSet();
+finalizeCurrentChunk_fn = function(track) {
+  if (__privateGet(this, _options).fastStart === "fragmented") {
+    throw new Error("Can't finalize individual chunks if 'fastStart' is set to 'fragmented'.");
+  }
+  if (!track.currentChunk)
+    return;
+  track.finalizedChunks.push(track.currentChunk);
+  __privateGet(this, _finalizedChunks).push(track.currentChunk);
+  if (track.compactlyCodedChunkTable.length === 0 || last(track.compactlyCodedChunkTable).samplesPerChunk !== track.currentChunk.samples.length) {
+    track.compactlyCodedChunkTable.push({
+      firstChunk: track.finalizedChunks.length,
+      // 1-indexed
+      samplesPerChunk: track.currentChunk.samples.length
+    });
+  }
+  if (__privateGet(this, _options).fastStart === "in-memory") {
+    track.currentChunk.offset = 0;
+    return;
+  }
+  track.currentChunk.offset = __privateGet(this, _writer).pos;
+  for (let sample of track.currentChunk.samples) {
+    __privateGet(this, _writer).write(sample.data);
+    sample.data = null;
+  }
+  __privateMethod(this, _maybeFlushStreamingTargetWriter, maybeFlushStreamingTargetWriter_fn).call(this);
+};
+_finalizeFragment = /* @__PURE__ */ new WeakSet();
+finalizeFragment_fn = function(flushStreamingWriter = true) {
+  if (__privateGet(this, _options).fastStart !== "fragmented") {
+    throw new Error("Can't finalize a fragment unless 'fastStart' is set to 'fragmented'.");
+  }
+  let tracks = [__privateGet(this, _videoTrack), __privateGet(this, _audioTrack)].filter((track) => track && track.currentChunk);
+  if (tracks.length === 0)
+    return;
+  let fragmentNumber = __privateWrapper(this, _nextFragmentNumber)._++;
+  if (fragmentNumber === 1) {
+    let movieBox = moov(tracks, __privateGet(this, _creationTime), true);
+    __privateGet(this, _writer).writeBox(movieBox);
+  }
+  let moofOffset = __privateGet(this, _writer).pos;
+  let moofBox = moof(fragmentNumber, tracks);
+  __privateGet(this, _writer).writeBox(moofBox);
+  {
+    let mdatBox = mdat(false);
+    let totalTrackSampleSize = 0;
+    for (let track of tracks) {
+      for (let sample of track.currentChunk.samples) {
+        totalTrackSampleSize += sample.size;
+      }
+    }
+    let mdatSize = __privateGet(this, _writer).measureBox(mdatBox) + totalTrackSampleSize;
+    if (mdatSize >= 2 ** 32) {
+      mdatBox.largeSize = true;
+      mdatSize = __privateGet(this, _writer).measureBox(mdatBox) + totalTrackSampleSize;
+    }
+    mdatBox.size = mdatSize;
+    __privateGet(this, _writer).writeBox(mdatBox);
+  }
+  for (let track of tracks) {
+    track.currentChunk.offset = __privateGet(this, _writer).pos;
+    track.currentChunk.moofOffset = moofOffset;
+    for (let sample of track.currentChunk.samples) {
+      __privateGet(this, _writer).write(sample.data);
+      sample.data = null;
+    }
+  }
+  let endPos = __privateGet(this, _writer).pos;
+  __privateGet(this, _writer).seek(__privateGet(this, _writer).offsets.get(moofBox));
+  let newMoofBox = moof(fragmentNumber, tracks);
+  __privateGet(this, _writer).writeBox(newMoofBox);
+  __privateGet(this, _writer).seek(endPos);
+  for (let track of tracks) {
+    track.finalizedChunks.push(track.currentChunk);
+    __privateGet(this, _finalizedChunks).push(track.currentChunk);
+    track.currentChunk = null;
+  }
+  if (flushStreamingWriter) {
+    __privateMethod(this, _maybeFlushStreamingTargetWriter, maybeFlushStreamingTargetWriter_fn).call(this);
+  }
+};
+_maybeFlushStreamingTargetWriter = /* @__PURE__ */ new WeakSet();
+maybeFlushStreamingTargetWriter_fn = function() {
+  if (__privateGet(this, _writer) instanceof StreamTargetWriter) {
+    __privateGet(this, _writer).flush();
+  }
+};
+_ensureNotFinalized = /* @__PURE__ */ new WeakSet();
+ensureNotFinalized_fn = function() {
+  if (__privateGet(this, _finalized)) {
+    throw new Error("Cannot add new video or audio chunks after the file has been finalized.");
+  }
+};
+
+var KEYFRAME_INTERVAL_SECONDS = 2;
+var VIDEO_ENCODE_QUEUE_LIMIT = 30;
+var WebCodecsMp4Strategy = class {
+  kind = "webcodecs-mp4";
+  muxer = null;
+  videoEncoder = null;
+  audioEncoder = null;
+  videoReader = null;
+  audioReader = null;
+  videoPump = null;
+  audioPump = null;
+  framesEncoded = 0;
+  framesDropped = 0;
+  keyframeInterval = 60;
+  running = false;
+  started = false;
+  firstError = null;
+  errorHandler = null;
+  codecLabels = {
+    video: "avc1.42E01E",
+    audio: "mp4a.40.2"
+  };
+  onError(handler) {
+    this.errorHandler = handler;
+  }
+  reportError(cause) {
+    const err = cause instanceof Error ? cause : new Error(String(cause));
+    if (!this.firstError)
+      this.firstError = err;
+    this.running = false;
+    if (!this.started)
+      return;
+    const handler = this.errorHandler;
+    this.errorHandler = null;
+    if (!handler)
+      return;
+    try {
+      handler(err);
+    } catch {
+    }
+  }
+  async start(stream, sink, opts) {
+    if (this.muxer) {
+      throw RecordingEngineError.state("start", "recording");
+    }
+    if (typeof MediaStreamTrackProcessor === "undefined") {
+      throw RecordingEngineError.capability("MediaStreamTrackProcessor");
+    }
+    const videoTrack = stream.getVideoTracks()[0];
+    const audioTrack = stream.getAudioTracks()[0];
+    if (!videoTrack || !audioTrack) {
+      throw RecordingEngineError.invalidArg("stream", "WebCodecsMp4Strategy requires both video and audio tracks");
+    }
+    const videoSettings = videoTrack.getSettings();
+    const audioSettings = audioTrack.getSettings();
+    const width = videoSettings.width ?? opts.videoConstraints?.width ?? 1920;
+    const height = videoSettings.height ?? opts.videoConstraints?.height ?? 1080;
+    const frameRate = videoSettings.frameRate ?? opts.videoConstraints?.frameRate ?? 30;
+    this.keyframeInterval = Math.max(1, Math.round(frameRate * KEYFRAME_INTERVAL_SECONDS));
+    const sampleRate = opts.audioConstraints?.sampleRate ?? audioSettings.sampleRate ?? 48e3;
+    const numberOfChannels = audioSettings.channelCount ?? 2;
+    const muxer = new Muxer({
+      target: new StreamTarget({
+        onData: (data, position) => {
+          if (position !== this.bytesWritten) {
+            this.reportError(RecordingEngineError.muxWrite(position, this.bytesWritten));
+            return;
+          }
+          this.bytesWritten += data.byteLength;
+          this.writeTail = this.writeTail.then(() => sink.write(data)).catch((err) => this.reportError(err));
+        },
+        chunked: true
+      }),
+      video: { codec: "avc", width, height, frameRate },
+      audio: { codec: "aac", numberOfChannels, sampleRate },
+      fastStart: "fragmented",
+      // Both tracks share the capture clock; per-track 'offset' would zero
+      // each independently and bake in permanent lip-sync error.
+      firstTimestampBehavior: "cross-track-offset"
+    });
+    this.muxer = muxer;
+    this.codecLabels.video = pickAvcCodecString(width, height, frameRate);
+    const videoEncoder = new VideoEncoder({
+      output: (chunk, meta) => muxer.addVideoChunk(chunk, meta),
+      error: (err) => this.reportError(err)
+    });
+    videoEncoder.configure({
+      codec: this.codecLabels.video,
+      width,
+      height,
+      bitrate: opts.videoBitsPerSecond ?? bitrateForResolution(height, frameRate),
+      framerate: frameRate
+    });
+    this.videoEncoder = videoEncoder;
+    const audioEncoder = new AudioEncoder({
+      output: (chunk, meta) => muxer.addAudioChunk(chunk, meta),
+      error: (err) => this.reportError(err)
+    });
+    audioEncoder.configure({
+      codec: this.codecLabels.audio,
+      sampleRate,
+      numberOfChannels,
+      bitrate: opts.audioBitsPerSecond ?? 192e3
+    });
+    this.audioEncoder = audioEncoder;
+    this.running = true;
+    const videoProcessor = new MediaStreamTrackProcessor({ track: videoTrack });
+    const audioProcessor = new MediaStreamTrackProcessor({ track: audioTrack });
+    this.videoReader = videoProcessor.readable.getReader();
+    this.audioReader = audioProcessor.readable.getReader();
+    this.videoPump = this.pumpVideo();
+    this.audioPump = this.pumpAudio();
+    this.started = true;
+  }
+  async stop() {
+    if (!this.muxer || !this.videoEncoder || !this.audioEncoder) {
+      throw RecordingEngineError.state("stop", "idle");
+    }
+    this.running = false;
+    try {
+      await this.videoReader?.cancel();
+    } catch {
+    }
+    try {
+      await this.audioReader?.cancel();
+    } catch {
+    }
+    await Promise.allSettled([this.videoPump, this.audioPump]);
+    if (this.firstError) {
+      throw this.firstError;
+    }
+    await this.videoEncoder.flush();
+    await this.audioEncoder.flush();
+    this.videoEncoder.close();
+    this.audioEncoder.close();
+    this.muxer.finalize();
+    await this.writeTail.catch(() => void 0);
+    if (this.firstError) {
+      throw this.firstError;
+    }
+    return {
+      videoCodec: this.codecLabels.video,
+      audioCodec: this.codecLabels.audio,
+      containerMime: "video/mp4",
+      framesDropped: this.framesDropped
+    };
+  }
+  async cancel() {
+    this.running = false;
+    try {
+      await this.videoReader?.cancel();
+    } catch {
+    }
+    try {
+      await this.audioReader?.cancel();
+    } catch {
+    }
+    await Promise.allSettled([this.videoPump, this.audioPump]);
+    try {
+      this.videoEncoder?.close();
+    } catch {
+    }
+    try {
+      this.audioEncoder?.close();
+    } catch {
+    }
+    await this.writeTail.catch(() => void 0);
+    this.muxer = null;
+    this.videoEncoder = null;
+    this.audioEncoder = null;
+    this.videoReader = null;
+    this.audioReader = null;
+  }
+  bytesWritten = 0;
+  // Rolling tail of serialized sink writes — bounds memory vs. an array that
+  // grows per muxer chunk. Awaiting it awaits the whole chain.
+  writeTail = Promise.resolve();
+  async pumpVideo() {
+    const reader = this.videoReader;
+    const encoder = this.videoEncoder;
+    if (!reader || !encoder)
+      return;
+    try {
+      while (this.running) {
+        const { done, value } = await reader.read();
+        if (done || !value)
+          break;
+        if (encoder.encodeQueueSize > VIDEO_ENCODE_QUEUE_LIMIT) {
+          this.framesDropped++;
+          value.close();
+          continue;
+        }
+        try {
+          const isKeyframe = this.framesEncoded % this.keyframeInterval === 0;
+          encoder.encode(value, { keyFrame: isKeyframe });
+          this.framesEncoded++;
+        } finally {
+          value.close();
+        }
+      }
+    } catch (err) {
+      this.reportError(err);
+    }
+  }
+  async pumpAudio() {
+    const reader = this.audioReader;
+    const encoder = this.audioEncoder;
+    if (!reader || !encoder)
+      return;
+    try {
+      while (this.running) {
+        const { done, value } = await reader.read();
+        if (done || !value)
+          break;
+        try {
+          encoder.encode(value);
+        } finally {
+          value.close();
+        }
+      }
+    } catch (err) {
+      this.reportError(err);
+    }
+  }
+};
+
+function createMuxStrategy(kind) {
+  switch (kind) {
+    case "mediarecorder-mp4":
+      return new MediaRecorderMp4Strategy();
+    case "webcodecs-mp4":
+      return new WebCodecsMp4Strategy();
+  }
+}
+
+var EngineIdValidationError = class extends Error {
+  constructor(brand, value) {
+    super(`Invalid ${brand}: ${JSON.stringify(value)}`);
+    this.name = "EngineIdValidationError";
+  }
+};
+var ID_RE = /^[A-Za-z0-9_-]{1,64}$/;
+function asSessionId(value) {
+  if (typeof value !== "string" || !ID_RE.test(value)) {
+    throw new EngineIdValidationError("SessionId", value);
+  }
+  return value;
+}
+function asParticipantId(value) {
+  if (typeof value !== "string" || !ID_RE.test(value)) {
+    throw new EngineIdValidationError("ParticipantId", value);
+  }
+  return value;
+}
+
+var EMPTY_MARKER = { version: 1, inProgress: [] };
+async function readSafe(store) {
+  const current = await store.read();
+  return current ?? EMPTY_MARKER;
+}
+var MARKER_LOCK = "capturly-recording-marker";
+async function withMarkerLock(fn) {
+  const locks = globalThis.navigator?.locks;
+  if (!locks?.request)
+    return fn();
+  return await locks.request(MARKER_LOCK, () => fn());
+}
+async function appendInProgress(store, entry) {
+  await withMarkerLock(async () => {
+    const current = await readSafe(store);
+    const filtered = current.inProgress.filter((e) => e.videoPath !== entry.videoPath);
+    await store.write({ version: 1, inProgress: [...filtered, entry] });
+  });
+}
+async function removeInProgress(store, videoPath) {
+  await withMarkerLock(async () => {
+    const current = await readSafe(store);
+    const filtered = current.inProgress.filter((e) => e.videoPath !== videoPath);
+    if (filtered.length === current.inProgress.length)
+      return;
+    await store.write({ version: 1, inProgress: filtered });
+  });
+}
+
+var TeeFileSinkHandle = class {
+  primary;
+  secondary;
+  onSecondaryError;
+  path;
+  secondaryFailed = false;
+  secondaryFailedOp;
+  secondaryFailureReason;
+  constructor(primary, secondary, onSecondaryError) {
+    this.primary = primary;
+    this.secondary = secondary;
+    this.onSecondaryError = onSecondaryError;
+    this.path = primary.path;
+  }
+  /**
+   * Snapshot of the secondary sink's failure state. Lets a consumer that
+   * subscribed late (or polls at finalize time) tell whether the cloud copy
+   * is truncated without needing to have observed the live event stream.
+   */
+  getSecondaryStatus() {
+    if (!this.secondaryFailed)
+      return { failed: false };
+    return {
+      failed: true,
+      ...this.secondaryFailedOp ? { failedOp: this.secondaryFailedOp } : {},
+      ...this.secondaryFailureReason ? { reason: this.secondaryFailureReason } : {}
+    };
+  }
+  async write(chunk) {
+    const primaryWrite = this.primary.write(chunk);
+    if (!this.secondaryFailed) {
+      const secondaryWrite = this.secondary.write(chunk).catch((err) => {
+        this.handleSecondaryError("write", err);
+      });
+      await Promise.all([primaryWrite, secondaryWrite]);
+    } else {
+      await primaryWrite;
+    }
+  }
+  async close() {
+    const primaryClose = this.primary.close();
+    const secondaryClose = this.secondary.close().catch((err) => {
+      this.handleSecondaryError("close", err);
+    });
+    await Promise.all([primaryClose, secondaryClose]);
+  }
+  async abort() {
+    const primaryAbort = this.primary.abort();
+    const secondaryAbort = this.secondary.abort().catch((err) => {
+      this.handleSecondaryError("abort", err);
+    });
+    await Promise.all([primaryAbort, secondaryAbort]);
+  }
+  async discard() {
+    const primaryDiscard = this.primary.discard();
+    const secondaryDiscard = this.secondary.discard().catch((err) => {
+      this.handleSecondaryError("discard", err);
+    });
+    await Promise.all([primaryDiscard, secondaryDiscard]);
+  }
+  handleSecondaryError(op, err) {
+    if (!this.secondaryFailed) {
+      this.secondaryFailedOp = op;
+      this.secondaryFailureReason = err instanceof Error ? err.message : String(err);
+    }
+    this.secondaryFailed = true;
+    try {
+      this.onSecondaryError?.(op, err);
+    } catch {
+    }
+  }
+};
+
+function projectState(state) {
+  switch (state.status) {
+    case "idle":
+    case "preparing":
+      return { status: state.status };
+    case "recording":
+      return { status: "recording", startedAt: state.resources.startedAt };
+    case "stopping":
+      return { status: "stopping", startedAt: state.resources.startedAt };
+    case "error":
+      return { status: "error", message: state.message };
+  }
+}
+var DEFAULT_VIDEO_CONSTRAINTS = {
+  width: { ideal: 1920 },
+  height: { ideal: 1080 },
+  frameRate: { ideal: 30 }
+};
+var STALL_THRESHOLD_MS = 1e4;
+var STALL_CHECK_INTERVAL_MS = 2500;
+function newTakeId() {
+  return `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`;
+}
+function buildVideoFilePath(opts, takeId) {
+  return `sessions/${opts.sessionId}/${opts.participantId}_${takeId}_video.mp4`;
+}
+var CaptureSession = class {
+  deps;
+  state = { status: "idle" };
+  listeners = {
+    state: /* @__PURE__ */ new Set(),
+    error: /* @__PURE__ */ new Set(),
+    cloud: /* @__PURE__ */ new Set(),
+    stall: /* @__PURE__ */ new Set()
+  };
+  // In-flight start(); cancel() flips `requested` and awaits `finished`.
+  prepare = null;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  async start(options) {
+    if (this.state.status !== "idle" && this.state.status !== "error") {
+      throw RecordingEngineError.state("start", this.state.status);
+    }
+    if (this.state.status === "error") {
+      await this.state.cleanup;
+    }
+    this.setState({ status: "preparing" });
+    let finishPrepare;
+    const prepare = {
+      requested: false,
+      finished: new Promise((resolve) => {
+        finishPrepare = resolve;
+      })
+    };
+    this.prepare = prepare;
+    const cancelledSignal = RecordingEngineError.state("start", "cancelled");
+    const takeId = newTakeId();
+    let stream = null;
+    let streamOwned = false;
+    let strategy = null;
+    let sinkHandle = null;
+    let compositor = null;
+    let markerAppended = false;
+    try {
+      stream = options.streamOverride ?? await this.acquireStream(options);
+      streamOwned = !options.streamOverride;
+      if (prepare.requested)
+        throw cancelledSignal;
+      let recordStream = stream;
+      if (options.watermark) {
+        if (watermarkSupported()) {
+          try {
+            compositor = new WatermarkCompositor(stream, {
+              ...options.watermark,
+              ...this.deps.logError ? { logError: this.deps.logError } : {}
+            });
+            recordStream = await compositor.start();
+          } catch (err) {
+            compositor?.stop();
+            compositor = null;
+            recordStream = stream;
+            this.deps.logError?.("watermark", "compositor failed to start; recording without watermark", err);
+          }
+        } else {
+          this.deps.logError?.("watermark", "canvas captureStream unavailable in this environment; recording without watermark");
+        }
+      }
+      if (prepare.requested)
+        throw cancelledSignal;
+      const kind = options.muxStrategyOverride ?? pickMuxStrategy();
+      if (!kind) {
+        throw RecordingEngineError.capability("mp4-mux", "No supported MP4 mux strategy in this environment (need MediaRecorder MP4 or WebCodecs)");
+      }
+      strategy = createMuxStrategy(kind);
+      strategy.onError((err) => this.handleStrategyError(err));
+      const opfsHandle = await this.deps.sink.open(buildVideoFilePath(options, takeId));
+      const openedSink = options.cloudBackup ? this.wrapWithCloudBackup(opfsHandle, options.cloudBackup) : opfsHandle;
+      const stallThresholdMs = Math.max(1, this.deps.stallConfig?.thresholdMs ?? STALL_THRESHOLD_MS);
+      const stallCheckIntervalMs = Math.max(1, this.deps.stallConfig?.checkIntervalMs ?? STALL_CHECK_INTERVAL_MS);
+      let lastWriteAt = Date.now();
+      let stalled = false;
+      const monitoredSink = {
+        path: openedSink.path,
+        write: (chunk) => {
+          lastWriteAt = Date.now();
+          if (stalled) {
+            stalled = false;
+            this.emit("stall", { stalled: false });
+          }
+          return openedSink.write(chunk);
+        },
+        close: () => openedSink.close(),
+        abort: () => openedSink.abort(),
+        discard: () => openedSink.discard()
+      };
+      sinkHandle = monitoredSink;
+      if (prepare.requested)
+        throw cancelledSignal;
+      await strategy.start(recordStream, monitoredSink, options);
+      if (prepare.requested)
+        throw cancelledSignal;
+      const startedAt = Date.now();
+      if (this.deps.markerStore) {
+        await safeMarkerOp(this.deps.markerStore, (store) => appendInProgress(store, {
+          sessionId: options.sessionId,
+          participantId: options.participantId,
+          startedAtMs: startedAt,
+          videoPath: openedSink.path,
+          surface: this.deps.surface
+        }), "append-on-start", this.deps.logError);
+        markerAppended = true;
+      }
+      if (prepare.requested)
+        throw cancelledSignal;
+      const detachTrackEnded = watchTrackEnded(stream, (track) => {
+        this.handleStrategyError(new Error(`Recording input lost: ${track.kind} device disconnected`));
+      });
+      const stallTimer = setInterval(() => {
+        if (this.state.status !== "recording")
+          return;
+        const sinceMs = Date.now() - lastWriteAt;
+        if (!stalled && sinceMs >= stallThresholdMs) {
+          stalled = true;
+          this.deps.logError?.("capture", `no sink writes for ${sinceMs}ms while recording (throttled tab, sleep, or dead device)`);
+          this.emit("stall", { stalled: true, sinceMs });
+        }
+      }, stallCheckIntervalMs);
+      const detachStallWatchdog = () => clearInterval(stallTimer);
+      this.setState({
+        status: "recording",
+        resources: {
+          strategy,
+          sinkHandle,
+          stream,
+          streamOwned,
+          compositor,
+          options,
+          startedAt,
+          detachTrackEnded,
+          detachStallWatchdog
+        }
+      });
+    } catch (err) {
+      await teardownResources({ strategy, sinkHandle, stream, streamOwned, compositor });
+      if (markerAppended && this.deps.markerStore) {
+        await safeMarkerOp(this.deps.markerStore, (store) => removeInProgress(store, buildVideoFilePath(options, takeId)), "remove-on-cancelled-start", this.deps.logError);
+      }
+      if (err === cancelledSignal) {
+        this.setState({ status: "idle" });
+        throw err;
+      }
+      const message = err instanceof Error ? err.message : String(err);
+      this.setState({ status: "error", message, cleanup: Promise.resolve(), salvage: null });
+      this.emit("error", { message, cause: err });
+      throw err;
+    } finally {
+      this.prepare = null;
+      finishPrepare();
+    }
+  }
+  async stop() {
+    if (this.state.status !== "recording") {
+      throw RecordingEngineError.state("stop", this.state.status);
+    }
+    const resources = this.state.resources;
+    this.setState({ status: "stopping", resources });
+    resources.detachTrackEnded();
+    resources.detachStallWatchdog();
+    try {
+      const muxResult = await resources.strategy.stop();
+      await resources.sinkHandle.close();
+      const endedAt = Date.now();
+      const videoSettings = resources.stream.getVideoTracks()[0]?.getSettings();
+      const audioSettings = resources.stream.getAudioTracks()[0]?.getSettings();
+      const metadata = {
+        sessionId: resources.options.sessionId,
+        participantId: resources.options.participantId,
+        startedAt: resources.startedAt,
+        endedAt,
+        durationMs: endedAt - resources.startedAt,
+        videoCodec: muxResult.videoCodec,
+        audioCodec: muxResult.audioCodec,
+        videoWidth: videoSettings?.width ?? resources.options.videoConstraints?.width ?? 0,
+        videoHeight: videoSettings?.height ?? resources.options.videoConstraints?.height ?? 0,
+        videoFrameRate: videoSettings?.frameRate ?? resources.options.videoConstraints?.frameRate ?? 0,
+        audioSampleRate: audioSettings?.sampleRate ?? resources.options.audioConstraints?.sampleRate ?? 0,
+        surface: this.deps.surface,
+        // The compositor, not options.watermark: a requested mark that failed
+        // to start leaves this null, and the manifest must say so.
+        watermarked: resources.compositor !== null,
+        ...muxResult.framesDropped !== void 0 ? { framesDropped: muxResult.framesDropped } : {}
+      };
+      if (muxResult.framesDropped && muxResult.framesDropped > 0) {
+        this.deps.logError?.("capture", `encoder dropped ${muxResult.framesDropped} frames at ${metadata.videoWidth}x${metadata.videoHeight} (machine couldn't sustain the resolution)`);
+      }
+      const artifact = {
+        videoPath: resources.sinkHandle.path,
+        metadata
+      };
+      if (this.deps.markerStore) {
+        await safeMarkerOp(this.deps.markerStore, (store) => removeInProgress(store, resources.sinkHandle.path), "remove-on-stop", this.deps.logError);
+      }
+      resources.compositor?.stop();
+      stopOwnedStream(resources);
+      this.setState({ status: "idle" });
+      return artifact;
+    } catch (err) {
+      const cleanup = commitResources({
+        strategy: resources.strategy,
+        sinkHandle: resources.sinkHandle,
+        stream: resources.stream,
+        streamOwned: resources.streamOwned,
+        compositor: resources.compositor
+      }, this.deps.logError);
+      await cleanup;
+      const message = err instanceof Error ? err.message : String(err);
+      this.setState({
+        status: "error",
+        message,
+        cleanup,
+        salvage: { videoPath: resources.sinkHandle.path }
+      });
+      this.emit("error", { message, cause: err });
+      throw err;
+    }
+  }
+  async cancel() {
+    if (this.state.status === "idle")
+      return;
+    if (this.state.status === "preparing") {
+      const prepare = this.prepare;
+      if (prepare) {
+        prepare.requested = true;
+        await prepare.finished;
+      }
+      if (this.state.status !== "preparing") {
+        await this.cancel();
+      } else {
+        this.setState({ status: "idle" });
+      }
+      return;
+    }
+    if (this.state.status === "error") {
+      const { cleanup, salvage } = this.state;
+      await cleanup;
+      if (salvage) {
+        try {
+          await this.deps.sink.remove(salvage.videoPath);
+        } catch {
+        }
+        if (this.deps.markerStore) {
+          await safeMarkerOp(this.deps.markerStore, (store) => removeInProgress(store, salvage.videoPath), "remove-on-cancel", this.deps.logError);
+        }
+      }
+      this.setState({ status: "idle" });
+      return;
+    }
+    if (this.state.status === "recording" || this.state.status === "stopping") {
+      const r = this.state.resources;
+      r.detachTrackEnded();
+      r.detachStallWatchdog();
+      await teardownResources({
+        strategy: r.strategy,
+        sinkHandle: r.sinkHandle,
+        stream: r.stream,
+        streamOwned: r.streamOwned,
+        compositor: r.compositor
+      });
+      if (this.deps.markerStore) {
+        await safeMarkerOp(this.deps.markerStore, (store) => removeInProgress(store, r.sinkHandle.path), "remove-on-cancel", this.deps.logError);
+      }
+    }
+    this.setState({ status: "idle" });
+  }
+  getPreviewStream() {
+    if (this.state.status !== "recording" && this.state.status !== "stopping") {
+      throw RecordingEngineError.state("getPreviewStream", this.state.status);
+    }
+    return this.state.resources.stream;
+  }
+  getState() {
+    return projectState(this.state);
+  }
+  on(event, handler) {
+    this.listeners[event].add(handler);
+    return () => {
+      this.listeners[event].delete(handler);
+    };
+  }
+  emit(event, payload) {
+    for (const handler of this.listeners[event]) {
+      try {
+        handler(payload);
+      } catch {
+      }
+    }
+  }
+  setState(state) {
+    this.state = state;
+    this.emit("state", projectState(state));
+  }
+  wrapWithCloudBackup(primary, config) {
+    let cloudHandle;
+    try {
+      cloudHandle = createCloudFileSinkHandle({
+        initUrl: config.initUrl,
+        contentType: config.contentType,
+        recordingId: config.recordingId,
+        fileId: config.fileId,
+        // The OPFS sync-worker handle can re-read committed bytes, which
+        // lets the cloud sink survive back-pressure and upload outages by
+        // tailing the durable file instead of failing terminally.
+        ...supportsRangeRead(primary) ? { readSource: (offset, length) => primary.readAt(offset, length) } : {},
+        callbacks: {
+          onLagging: (reason) => {
+            this.deps.logError?.("cloud-lag", `cloud backup fell behind; draining from local file (${reason})`);
+          },
+          onState: (state, info) => {
+            this.emit("cloud", {
+              state,
+              ...info?.reason ? { reason: info.reason } : {}
+            });
+          },
+          onProgress: (bytesUploaded) => {
+            this.emit("cloud", {
+              state: cloudHandle.getState(),
+              bytesUploaded
+            });
+          },
+          onSessionAcquired: (sessionUrl) => {
+            this.emit("cloud", {
+              state: cloudHandle.getState(),
+              sessionUrl
+            });
+          },
+          onCleanupError: (context, err) => {
+            this.deps.logError?.(`cloud-${context}`, `${context} failed`, err);
+          }
+        }
+      });
+    } catch (err) {
+      this.emit("cloud", {
+        state: "failed",
+        reason: err instanceof Error ? err.message : String(err)
+      });
+      return primary;
+    }
+    return new TeeFileSinkHandle(primary, cloudHandle, (op, err) => {
+      this.deps.logError?.("cloud-tee", `cloud sink ${op} failed`, err);
+    });
+  }
+  handleStrategyError(err) {
+    if (this.state.status !== "recording")
+      return;
+    const resources = this.state.resources;
+    resources.detachTrackEnded();
+    resources.detachStallWatchdog();
+    const cleanup = commitResources({
+      strategy: resources.strategy,
+      sinkHandle: resources.sinkHandle,
+      stream: resources.stream,
+      streamOwned: resources.streamOwned,
+      compositor: resources.compositor
+    }, this.deps.logError);
+    const message = err.message;
+    this.setState({
+      status: "error",
+      message,
+      cleanup,
+      salvage: { videoPath: resources.sinkHandle.path }
+    });
+    this.emit("error", { message, cause: err });
+  }
+  async acquireStream(options) {
+    if (typeof navigator === "undefined" || !navigator.mediaDevices) {
+      throw RecordingEngineError.capability("navigator.mediaDevices");
+    }
+    const videoConstraints = options.videoDeviceId ? { deviceId: { exact: options.videoDeviceId } } : { ...DEFAULT_VIDEO_CONSTRAINTS };
+    if (options.videoConstraints?.width !== void 0) {
+      videoConstraints.width = { ideal: options.videoConstraints.width };
+    }
+    if (options.videoConstraints?.height !== void 0) {
+      videoConstraints.height = { ideal: options.videoConstraints.height };
+    }
+    if (options.videoConstraints?.frameRate !== void 0) {
+      videoConstraints.frameRate = { ideal: options.videoConstraints.frameRate };
+    }
+    const audioConstraints = options.audioDeviceId ? { deviceId: { exact: options.audioDeviceId } } : {};
+    if (options.audioConstraints) {
+      if (options.audioConstraints.echoCancellation !== void 0) {
+        audioConstraints.echoCancellation = options.audioConstraints.echoCancellation;
+      }
+      if (options.audioConstraints.noiseSuppression !== void 0) {
+        audioConstraints.noiseSuppression = options.audioConstraints.noiseSuppression;
+      }
+      if (options.audioConstraints.autoGainControl !== void 0) {
+        audioConstraints.autoGainControl = options.audioConstraints.autoGainControl;
+      }
+      if (options.audioConstraints.sampleRate !== void 0) {
+        audioConstraints.sampleRate = options.audioConstraints.sampleRate;
+      }
+    }
+    return navigator.mediaDevices.getUserMedia({
+      video: videoConstraints,
+      audio: audioConstraints
+    });
+  }
+};
+function watchTrackEnded(stream, onEnded) {
+  const watched = [];
+  for (const track of stream.getTracks()) {
+    if (typeof track.addEventListener !== "function")
+      continue;
+    const handler = () => onEnded(track);
+    track.addEventListener("ended", handler);
+    watched.push({ track, handler });
+  }
+  return () => {
+    for (const { track, handler } of watched) {
+      try {
+        track.removeEventListener("ended", handler);
+      } catch {
+      }
+    }
+  };
+}
+function stopOwnedStream(r) {
+  if (!r.streamOwned)
+    return;
+  for (const track of r.stream.getTracks()) {
+    try {
+      track.stop();
+    } catch {
+    }
+  }
+}
+async function safeMarkerOp(store, op, opName, logError) {
+  try {
+    await op(store);
+  } catch (err) {
+    logError?.("marker", `safeMarkerOp ${opName} failed`, err);
+  }
+}
+async function teardownResources(r) {
+  try {
+    if (r.strategy)
+      await r.strategy.cancel();
+  } catch {
+  }
+  try {
+    if (r.sinkHandle)
+      await r.sinkHandle.discard();
+  } catch {
+  }
+  r.compositor?.stop();
+  if (r.stream)
+    stopOwnedStream({ stream: r.stream, streamOwned: r.streamOwned });
+}
+function commitResources(r, logError) {
+  return (async () => {
+    try {
+      if (r.strategy)
+        await r.strategy.cancel();
+    } catch (err) {
+      logError?.("capture", "commitResources: strategy.cancel failed", err);
+    }
+    if (r.sinkHandle) {
+      try {
+        await r.sinkHandle.close();
+      } catch (err) {
+        logError?.("capture", "commitResources: sink close failed, aborting handle", err);
+        try {
+          await r.sinkHandle.abort();
+        } catch {
+        }
+      }
+    }
+    r.compositor?.stop();
+    if (r.stream)
+      stopOwnedStream({ stream: r.stream, streamOwned: r.streamOwned });
+  })();
+}
+
+// src/types.ts
+var CaptureError = class extends Error {
+  code;
+  cause;
+  constructor(code, message, cause) {
+    super(message);
+    this.name = "CaptureError";
+    this.code = code;
+    if (cause !== void 0) this.cause = cause;
+  }
+};
+
+// src/transport.ts
+var TERMINAL_ACCESS_ERRORS = /* @__PURE__ */ new Set([
+  "campaign_closed",
+  "deadline_passed",
+  "link_revoked",
+  "not_found",
+  "forbidden"
+]);
+function accessBody(access) {
+  return access.mode === "contact" ? { mode: "contact", contactId: access.contactId, key: access.key } : { mode: "open", campaignId: access.campaignId, key: access.key };
+}
+function codeForResponse(status, error) {
+  if (status === 413) return "quota_exceeded";
+  if (status === 429) return "quota_exceeded";
+  if (status === 410 || error !== null && TERMINAL_ACCESS_ERRORS.has(error)) {
+    return error === "campaign_closed" ? "request_closed" : "link_expired";
+  }
+  if (status === 401 || status === 403) return "link_expired";
+  return "upload_failed";
+}
+async function postJson(baseUrl, path, body) {
+  let res;
+  try {
+    res = await fetch(`${baseUrl}${path}`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(body)
+    });
+  } catch (err) {
+    throw new CaptureError("network", "Could not reach Capturly.", err);
+  }
+  const json = await res.json().catch(() => null);
+  if (!res.ok) {
+    const error = typeof json?.error === "string" ? json.error : null;
+    throw new CaptureError(
+      codeForResponse(res.status, error),
+      error ?? `Capturly returned ${res.status}.`
+    );
+  }
+  return json ?? {};
+}
+async function requestUpload(args) {
+  const json = await postJson(args.baseUrl, "/api/campaigns/respond/upload-url", {
+    ...accessBody(args.access),
+    contentType: "video/mp4",
+    sizeBytes: args.sizeBytes
+  });
+  const objectName = typeof json.objectName === "string" ? json.objectName : null;
+  const url2 = typeof json.url === "string" ? json.url : null;
+  if (!objectName || !url2) {
+    throw new CaptureError("upload_failed", "Capturly did not return an upload target.");
+  }
+  return {
+    objectName,
+    url: url2,
+    method: typeof json.method === "string" ? json.method : "PUT",
+    headers: json.headers !== null && typeof json.headers === "object" ? json.headers : {}
+  };
+}
+function uploadBlob(args) {
+  return new Promise((resolve, reject) => {
+    const xhr = new XMLHttpRequest();
+    xhr.open(args.target.method, args.target.url, true);
+    for (const [name, value] of Object.entries(args.target.headers)) {
+      xhr.setRequestHeader(name, value);
+    }
+    xhr.upload.onprogress = (event) => {
+      if (!event.lengthComputable || !args.onProgress) return;
+      args.onProgress(Math.min(1, event.loaded / event.total));
+    };
+    xhr.onload = () => {
+      if (xhr.status >= 200 && xhr.status < 300) {
+        args.onProgress?.(1);
+        resolve();
+        return;
+      }
+      reject(new CaptureError("upload_failed", `Storage rejected the upload (${xhr.status}).`));
+    };
+    xhr.onerror = () => reject(new CaptureError("network", "The upload could not reach storage."));
+    xhr.onabort = () => reject(new CaptureError("upload_failed", "The upload was aborted."));
+    xhr.send(args.blob);
+  });
+}
+async function finalizeSubmission(args) {
+  const json = await postJson(args.baseUrl, "/api/campaigns/respond/finalize", {
+    ...accessBody(args.access),
+    objectName: args.objectName,
+    durationSec: args.durationSec,
+    ...args.displayName ? { displayName: args.displayName } : {},
+    releaseAccepted: args.releaseAccepted
+  });
+  const submissionId = typeof json.submissionId === "string" ? json.submissionId : null;
+  if (!submissionId) {
+    throw new CaptureError(
+      "unknown",
+      "The recording was submitted but Capturly did not return its id."
+    );
+  }
+  return {
+    submissionId,
+    submittedAt: typeof json.submittedAt === "string" ? json.submittedAt : (/* @__PURE__ */ new Date()).toISOString(),
+    replaced: json.replaced === true
+  };
+}
+
+// src/CaptureClient.ts
+var DEFAULT_BASE_URL = "https://capturly.app";
+var CaptureClient = class _CaptureClient {
+  #options;
+  #sink = null;
+  #session = null;
+  #stream = null;
+  #pending = null;
+  #state = "idle";
+  #startedAt = 0;
+  #takeCounter = 0;
+  #destroyed = false;
+  #stateListeners = /* @__PURE__ */ new Set();
+  constructor(options) {
+    const baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.#options = {
+      access: options.access,
+      baseUrl,
+      onWarning: options.onWarning ?? (() => {
+      })
+    };
+  }
+  /** What the recorder is doing right now. */
+  get state() {
+    return this.#state;
+  }
+  /** Subscribe to state changes. Returns an unsubscribe function. */
+  onStateChange(listener) {
+    this.#stateListeners.add(listener);
+    return () => this.#stateListeners.delete(listener);
+  }
+  /**
+   * Whether this browser can record. Check before showing a record button; a
+   * browser that fails cannot be retried into working, so offer another one.
+   */
+  static isSupported() {
+    try {
+      const caps = detectCapabilities();
+      return caps.mux !== null && caps.opfs && caps.mediaDevices;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Cameras and microphones. Labels are blank until permission has been
+   * granted once, so call this again after `preview()` to fill a picker.
+   */
+  async listDevices() {
+    this.#assertAlive();
+    const devices = await navigator.mediaDevices.enumerateDevices();
+    return devices.filter((d) => d.kind === "audioinput" || d.kind === "videoinput").map((d) => ({
+      deviceId: d.deviceId,
+      label: d.label,
+      kind: d.kind
+    }));
+  }
+  /**
+   * Request the camera and microphone and return the stream to render.
+   * Separate from `start()` so people can see themselves before recording.
+   */
+  async preview(options = {}) {
+    this.#assertAlive();
+    if (!_CaptureClient.isSupported()) {
+      throw new CaptureError(
+        "unsupported_browser",
+        "This browser cannot record. Chrome, Edge, Firefox or Safari 16.4+ can."
+      );
+    }
+    const constraints = {
+      audio: options.audioDeviceId ? { deviceId: { exact: options.audioDeviceId } } : true,
+      video: options.audioOnly ? false : options.videoDeviceId ? { deviceId: { exact: options.videoDeviceId } } : true
+    };
+    let stream;
+    try {
+      stream = await navigator.mediaDevices.getUserMedia(constraints);
+    } catch (err) {
+      throw new CaptureError(this.#gumCode(err), this.#gumMessage(err), err);
+    }
+    this.#stopStream();
+    this.#stream = stream;
+    return stream;
+  }
+  /** Begin recording the current preview stream. */
+  async start() {
+    this.#assertAlive();
+    const stream = this.#stream;
+    if (!stream) {
+      throw new CaptureError("not_recording", "Call preview() before start().");
+    }
+    if (this.#session) {
+      throw new CaptureError("not_recording", "Already recording.");
+    }
+    this.#setState("starting");
+    this.#sink ??= new OpfsFileSink({ logError: (m, e) => this.#options.onWarning(m, e) });
+    const session = new CaptureSession({
+      sink: this.#sink,
+      surface: "web",
+      logError: (m, e) => this.#options.onWarning(m, e)
+    });
+    this.#takeCounter += 1;
+    try {
+      await session.start({
+        // Local grouping only; the server derives the real object path.
+        sessionId: asSessionId(`sdk-${Date.now()}`),
+        participantId: asParticipantId(`sdk-t${this.#takeCounter}`),
+        streamOverride: stream
+      });
+    } catch (err) {
+      this.#setState("idle");
+      throw new CaptureError("unknown", "Recording could not start.", err);
+    }
+    this.#session = session;
+    this.#startedAt = Date.now();
+    this.#setState("recording");
+  }
+  /**
+   * Stop and return the take. Nothing has left the browser yet — the file sits
+   * in OPFS until `submit()`, so it can be reviewed or re-recorded first.
+   */
+  async stop() {
+    this.#assertAlive();
+    const session = this.#session;
+    if (!session) {
+      throw new CaptureError("not_recording", "Not recording.");
+    }
+    this.#session = null;
+    this.#setState("stopping");
+    let artifact;
+    try {
+      artifact = await session.stop();
+    } catch (err) {
+      this.#setState("idle");
+      throw new CaptureError("unknown", "Recording could not be finished.", err);
+    }
+    const durationSec = Math.max(1, Math.round((Date.now() - this.#startedAt) / 1e3));
+    let previewUrl = null;
+    let sizeBytes = 0;
+    try {
+      const blob = await this.#sink?.read(artifact.videoPath);
+      if (blob) {
+        previewUrl = URL.createObjectURL(blob);
+        sizeBytes = blob.size;
+      }
+    } catch (err) {
+      this.#options.onWarning("take preview could not be read", err);
+    }
+    this.#discardPending();
+    this.#pending = { path: artifact.videoPath, durationSec, previewUrl, sizeBytes };
+    this.#setState("stopped");
+    return { durationSec, previewUrl, sizeBytes };
+  }
+  /**
+   * Upload the take and record the submission: request a signed target, PUT
+   * the bytes straight to storage, then confirm. The API never sees the bytes.
+   * Confirming is keyed on the object name, so a retry after a lost response
+   * resolves to the same submission.
+   */
+  async submit(options) {
+    this.#assertAlive();
+    const pending = this.#pending;
+    if (!pending) {
+      throw new CaptureError("nothing_to_submit", "Record something before submitting.");
+    }
+    if (this.#options.access.mode === "open" && !options.displayName) {
+      throw new CaptureError(
+        "nothing_to_submit",
+        "An open link has no roster name \u2014 pass displayName."
+      );
+    }
+    const blob = await this.#sink?.read(pending.path);
+    if (!blob) {
+      throw new CaptureError("nothing_to_submit", "The recording is no longer in local storage.");
+    }
+    const target = await requestUpload({
+      baseUrl: this.#options.baseUrl,
+      access: this.#options.access,
+      sizeBytes: blob.size
+    });
+    await uploadBlob({
+      target,
+      blob,
+      ...options.onProgress ? { onProgress: options.onProgress } : {}
+    });
+    const result = await finalizeSubmission({
+      baseUrl: this.#options.baseUrl,
+      access: this.#options.access,
+      objectName: target.objectName,
+      durationSec: pending.durationSec,
+      displayName: options.displayName,
+      releaseAccepted: options.releaseAccepted
+    });
+    this.#discardPending();
+    return result;
+  }
+  /** Throw the take away without submitting, so someone can record again. */
+  discard() {
+    this.#discardPending();
+    this.#setState("idle");
+  }
+  /**
+   * Release the camera, microphone and recorder. Call it on unmount, or the
+   * camera light stays on after the person has navigated away.
+   */
+  destroy() {
+    this.#destroyed = true;
+    void this.#session?.stop().catch(() => {
+    });
+    this.#session = null;
+    this.#stopStream();
+    this.#discardPending();
+    this.#stateListeners.clear();
+  }
+  // -------------------------------------------------------------------------
+  #assertAlive() {
+    if (this.#destroyed) {
+      throw new CaptureError("not_recording", "This client has been destroyed.");
+    }
+  }
+  #setState(state) {
+    this.#state = state;
+    for (const listener of this.#stateListeners) listener(state);
+  }
+  #stopStream() {
+    this.#stream?.getTracks().forEach((t) => t.stop());
+    this.#stream = null;
+  }
+  #discardPending() {
+    if (this.#pending?.previewUrl) URL.revokeObjectURL(this.#pending.previewUrl);
+    this.#pending = null;
+  }
+  /** getUserMedia DOMException names, mapped to codes. */
+  #gumCode(err) {
+    const name = err?.name;
+    if (name === "NotAllowedError" || name === "SecurityError") return "permission_denied";
+    if (name === "NotFoundError" || name === "OverconstrainedError") return "no_devices";
+    return "unknown";
+  }
+  #gumMessage(err) {
+    switch (this.#gumCode(err)) {
+      case "permission_denied":
+        return "Camera and microphone access was denied.";
+      case "no_devices":
+        return "No camera or microphone was available.";
+      default:
+        return "The camera and microphone could not be opened.";
+    }
+  }
+};
+export {
+  CaptureClient,
+  CaptureError
+};