@bendyline/squisq-video-react 2.2.11 → 2.3.1

package/dist/chunk-U3RSDWQL.js

@@ -0,0 +1,978 @@
+import {
+  useFrameCapture
+} from "./chunk-YTEDBL6F.js";
+import {
+  EXPORT_AUDIO_CHANNELS,
+  EXPORT_AUDIO_SAMPLE_RATE,
+  audioBufferToWav,
+  createEncoder,
+  encodeAacTrack,
+  muxAudioWithFfmpegWasm,
+  renderAudioTimeline,
+  selectAudioTier,
+  supportsWebCodecs,
+  supportsWebCodecsAac,
+  supportsWebCodecsH264
+} from "./chunk-32QCPFXE.js";
+
+// src/hooks/useVideoExport.ts
+import { useState, useRef, useCallback, useEffect } from "react";
+import {
+  DEFAULT_INTERACTIVE_RESOURCE_POLICY,
+  fetchResourceBytes
+} from "@bendyline/squisq/markdown";
+import {
+  DEFAULT_COVER_SLIDE_SETTINGS,
+  MAX_COVER_SLIDE_DURATION_SECONDS,
+  resolveCoverSlideSettings
+} from "@bendyline/squisq/doc";
+import {
+  resolveDimensions,
+  computeAudioTimeline,
+  resolveFfmpegWasmLoad as resolveFfmpegWasmLoad2,
+  QUALITY_PRESETS
+} from "@bendyline/squisq-video";
+
+// src/workerEncoder.ts
+import { validateVideoExportOptions } from "@bendyline/squisq-video";
+function createWorkerEncoder(config) {
+  validateVideoExportOptions(config);
+  const worker = new Worker(new URL("./workers/encode.worker.js", import.meta.url), {
+    type: "module"
+  });
+  let state = "open";
+  let fatalError = null;
+  let finalizeResolve = null;
+  let finalizeReject = null;
+  let readyResolve = null;
+  let readyReject = null;
+  let readySettled = false;
+  const frameWaiters = /* @__PURE__ */ new Map();
+  const ready = new Promise((resolve, reject) => {
+    readyResolve = resolve;
+    readyReject = reject;
+  });
+  const frameDuration = 1e6 / config.fps;
+  function post(msg, transfer) {
+    worker.postMessage(msg, transfer ?? []);
+  }
+  const currentState = () => state;
+  worker.onmessage = (event) => {
+    const msg = event.data;
+    switch (msg.type) {
+      case "capabilities":
+        readySettled = true;
+        readyResolve?.(msg.backend);
+        readyResolve = readyReject = null;
+        break;
+      case "frame-complete": {
+        const waiter = frameWaiters.get(msg.frameIndex);
+        waiter?.resolve();
+        frameWaiters.delete(msg.frameIndex);
+        break;
+      }
+      case "complete":
+        state = "closed";
+        finalizeResolve?.(msg.data);
+        finalizeResolve = finalizeReject = null;
+        worker.terminate();
+        break;
+      case "error": {
+        const err = new Error(msg.message);
+        fatalError = err;
+        state = "closed";
+        readySettled = true;
+        readyReject?.(err);
+        finalizeReject?.(err);
+        for (const waiter of frameWaiters.values()) waiter.reject(err);
+        frameWaiters.clear();
+        readyResolve = readyReject = null;
+        finalizeResolve = finalizeReject = null;
+        worker.terminate();
+        break;
+      }
+    }
+  };
+  worker.onerror = (event) => {
+    const err = new Error(event.message || "Worker error");
+    fatalError = err;
+    state = "closed";
+    readySettled = true;
+    readyReject?.(err);
+    finalizeReject?.(err);
+    for (const waiter of frameWaiters.values()) waiter.reject(err);
+    frameWaiters.clear();
+    readyResolve = readyReject = null;
+    finalizeResolve = finalizeReject = null;
+    worker.terminate();
+  };
+  post({
+    type: "init",
+    width: config.width,
+    height: config.height,
+    fps: config.fps,
+    quality: config.quality,
+    ...config.totalFrames !== void 0 ? { totalFrames: config.totalFrames } : {},
+    ...config.ffmpegWasm ? { ffmpegWasm: config.ffmpegWasm } : {}
+  });
+  return {
+    ready,
+    encodeFrame(frame, frameIndex) {
+      if (typeof HTMLCanvasElement !== "undefined" && frame instanceof HTMLCanvasElement) {
+        return Promise.reject(new Error("Worker encoding requires a transferable ImageBitmap"));
+      }
+      const bitmap = frame;
+      if (state !== "open" || fatalError) {
+        bitmap.close();
+        return Promise.reject(fatalError ?? new Error("Encoder is not accepting frames"));
+      }
+      if (frameWaiters.has(frameIndex)) {
+        bitmap.close();
+        return Promise.reject(new Error(`Frame ${frameIndex} was submitted more than once`));
+      }
+      let resolveFrame;
+      let rejectFrame;
+      const promise = new Promise((resolve, reject) => {
+        resolveFrame = resolve;
+        rejectFrame = reject;
+      });
+      frameWaiters.set(frameIndex, { promise, resolve: resolveFrame, reject: rejectFrame });
+      const timestamp = Math.round(frameIndex * frameDuration);
+      post({ type: "frame", bitmap, frameIndex, timestamp }, [bitmap]);
+      return promise;
+    },
+    async finalize() {
+      if (state !== "open") throw new Error("Encoder already closed or finalizing");
+      if (fatalError) throw fatalError;
+      state = "finalizing";
+      await Promise.all(Array.from(frameWaiters.values(), (waiter) => waiter.promise));
+      if (currentState() === "closed") {
+        throw fatalError ?? new Error("Encoder closed during finalization");
+      }
+      return new Promise((resolve, reject) => {
+        finalizeResolve = resolve;
+        finalizeReject = reject;
+        post({ type: "finalize" });
+      });
+    },
+    close() {
+      if (state === "closed") return;
+      state = "closed";
+      const err = new Error("Encoder closed");
+      if (!readySettled) {
+        readySettled = true;
+        readyReject?.(err);
+      }
+      finalizeReject?.(err);
+      for (const waiter of frameWaiters.values()) waiter.reject(err);
+      frameWaiters.clear();
+      readyResolve = readyReject = null;
+      finalizeResolve = finalizeReject = null;
+      post({ type: "cancel" });
+      worker.terminate();
+    }
+  };
+}
+
+// src/gifTranscode.ts
+import {
+  ffmpegGifPaletteApplicationArgs,
+  ffmpegGifPaletteGenerationFilter,
+  resolveFfmpegWasmLoad
+} from "@bendyline/squisq-video";
+function buildGifPaletteFfmpegArgs(options) {
+  return [
+    "-y",
+    "-i",
+    "video.mp4",
+    "-vf",
+    ffmpegGifPaletteGenerationFilter(options),
+    "-frames:v",
+    "1",
+    "palette.png"
+  ];
+}
+function buildGifFfmpegArgs(options) {
+  return [
+    "-y",
+    "-i",
+    "video.mp4",
+    "-i",
+    "palette.png",
+    ...ffmpegGifPaletteApplicationArgs(options),
+    "out.gif"
+  ];
+}
+var FFMPEG_ERRORISH = /error|invalid|failed|out of memory|memory access|abort|unable to/i;
+function ffmpegFailureDetail(logs) {
+  const lines = logs.map((line) => line.trim()).filter(Boolean);
+  return lines.find((line) => FFMPEG_ERRORISH.test(line)) ?? lines.at(-1) ?? null;
+}
+async function transcodeMp4ToGifWithFfmpegWasm(videoMp4, options, loadConfig, signal) {
+  if (videoMp4.byteLength === 0) {
+    throw new Error("Cannot create an animated GIF from an empty MP4.");
+  }
+  if (signal?.aborted) {
+    throw new DOMException("Animated GIF export was cancelled.", "AbortError");
+  }
+  const load = resolveFfmpegWasmLoad(loadConfig, "Animated GIF export", {
+    classWorkerURL: new URL("./workers/ffmpeg.class-worker.js", import.meta.url).href
+  });
+  const paletteArgs = buildGifPaletteFfmpegArgs(options);
+  const gifArgs = buildGifFfmpegArgs(options);
+  const { FFmpeg } = await import("@ffmpeg/ffmpeg");
+  const ffmpeg = new FFmpeg();
+  const recentLogs = [];
+  const handleLog = ({ message }) => {
+    recentLogs.push(message);
+    if (recentLogs.length > 40) recentLogs.shift();
+  };
+  ffmpeg.on("log", handleLog);
+  let terminated = false;
+  const terminate = () => {
+    if (terminated) return;
+    terminated = true;
+    ffmpeg.terminate();
+  };
+  const handleAbort = () => terminate();
+  signal?.addEventListener("abort", handleAbort, { once: true });
+  try {
+    await ffmpeg.load(load);
+    if (signal?.aborted) {
+      throw new DOMException("Animated GIF export was cancelled.", "AbortError");
+    }
+    await ffmpeg.writeFile("video.mp4", videoMp4);
+    if (signal?.aborted) {
+      throw new DOMException("Animated GIF export was cancelled.", "AbortError");
+    }
+    const execPhase = async (args, phase) => {
+      recentLogs.length = 0;
+      let exitCode;
+      try {
+        exitCode = await ffmpeg.exec(args);
+      } catch (caught) {
+        if (signal?.aborted) {
+          throw new DOMException("Animated GIF export was cancelled.", "AbortError");
+        }
+        const detail = ffmpegFailureDetail(recentLogs);
+        const fallback = caught instanceof Error ? caught.message : String(caught);
+        throw new Error(`ffmpeg.wasm GIF transcode failed during ${phase}: ${detail ?? fallback}`);
+      }
+      if (signal?.aborted) {
+        throw new DOMException("Animated GIF export was cancelled.", "AbortError");
+      }
+      if (exitCode !== 0) {
+        const detail = ffmpegFailureDetail(recentLogs);
+        throw new Error(
+          `ffmpeg.wasm GIF transcode failed during ${phase} with exit code ${exitCode}` + (detail ? `: ${detail}` : "")
+        );
+      }
+    };
+    await execPhase(paletteArgs, "palette generation");
+    await execPhase(gifArgs, "palette application");
+    await ffmpeg.deleteFile("video.mp4").catch(() => false);
+    await ffmpeg.deleteFile("palette.png").catch(() => false);
+    const data = await ffmpeg.readFile("out.gif");
+    return data instanceof Uint8Array ? data : new TextEncoder().encode(data);
+  } finally {
+    signal?.removeEventListener("abort", handleAbort);
+    ffmpeg.off("log", handleLog);
+    terminate();
+  }
+}
+
+// src/hooks/useVideoExport.ts
+var MAX_EXPORT_MEDIA_FILES = 256;
+var ENCODER_PROBE_TIMEOUT_MS = 5e3;
+var ENCODER_START_TIMEOUT_MS = 6e4;
+var FRAME_CAPTURE_TIMEOUT_MS = 6e4;
+var FRAME_CAPTURE_RECOVERY_TIMEOUT_MS = 12e4;
+var FRAME_ENCODE_TIMEOUT_MS = 6e4;
+var CAPTURE_PROGRESS_START = 7;
+var CAPTURE_PROGRESS_END = 95;
+var FRAME_RATE_WINDOW_SIZE = 30;
+var DEFAULT_VIDEO_COVER_PRE_ROLL_SECONDS = DEFAULT_COVER_SLIDE_SETTINGS.duration;
+function calculateRollingFramesPerSecond(frameBoundaryTimes) {
+  if (frameBoundaryTimes.length < 2) return null;
+  const firstIndex = Math.max(0, frameBoundaryTimes.length - (FRAME_RATE_WINDOW_SIZE + 1));
+  const elapsedMs = frameBoundaryTimes[frameBoundaryTimes.length - 1] - frameBoundaryTimes[firstIndex];
+  const completedFrames = frameBoundaryTimes.length - 1 - firstIndex;
+  if (elapsedMs <= 0 || completedFrames <= 0) return null;
+  return completedFrames * 1e3 / elapsedMs;
+}
+function releaseEncoderFrame(frame) {
+  if ("close" in frame) frame.close();
+}
+function settleWithin(operation, timeoutMs, timeoutMessage, onLateResult, activityDocument) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let timeout = null;
+    const isInactive = () => activityDocument !== void 0 && activityDocument.visibilityState !== "visible";
+    const clearDeadline = () => {
+      if (timeout === null) return;
+      globalThis.clearTimeout(timeout);
+      timeout = null;
+    };
+    const cleanup = () => {
+      clearDeadline();
+      activityDocument?.removeEventListener("visibilitychange", handleVisibilityChange);
+    };
+    const fail = () => {
+      timeout = null;
+      if (settled || isInactive()) return;
+      settled = true;
+      cleanup();
+      reject(new Error(timeoutMessage));
+    };
+    const armDeadline = () => {
+      clearDeadline();
+      if (settled || isInactive()) return;
+      timeout = globalThis.setTimeout(fail, timeoutMs);
+    };
+    function handleVisibilityChange() {
+      if (activityDocument?.visibilityState !== "visible") {
+        clearDeadline();
+        return;
+      }
+      armDeadline();
+    }
+    activityDocument?.addEventListener("visibilitychange", handleVisibilityChange);
+    armDeadline();
+    void operation.then(
+      (value) => {
+        if (settled) {
+          onLateResult?.(value);
+          return;
+        }
+        settled = true;
+        cleanup();
+        resolve(value);
+      },
+      (caught) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        reject(caught);
+      }
+    );
+  });
+}
+async function settleFrameCaptureWithRecovery({
+  operation,
+  frameNumber,
+  totalFrames,
+  onLateResult,
+  activityDocument,
+  onRecoveryWait,
+  primaryTimeoutMs = FRAME_CAPTURE_TIMEOUT_MS,
+  graceTimeoutMs = FRAME_CAPTURE_RECOVERY_TIMEOUT_MS
+}) {
+  const primaryMessage = `Frame capture stopped responding at frame ${frameNumber}/${totalFrames}.`;
+  try {
+    return await settleWithin(
+      operation,
+      primaryTimeoutMs,
+      primaryMessage,
+      void 0,
+      activityDocument
+    );
+  } catch (error) {
+    if (!(error instanceof Error) || error.message !== primaryMessage) throw error;
+    onRecoveryWait?.();
+    const totalSeconds = Math.round((primaryTimeoutMs + graceTimeoutMs) / 1e3);
+    return await settleWithin(
+      operation,
+      graceTimeoutMs,
+      `Frame capture stopped responding at frame ${frameNumber}/${totalFrames} (no frame after ${totalSeconds}s). The browser is likely under memory pressure \u2014 try a lower export quality, close the preview panes, and keep this tab visible.`,
+      onLateResult,
+      activityDocument
+    );
+  }
+}
+function toArrayBuffer(bytes) {
+  return bytes.slice().buffer;
+}
+function resolveExportMediaResourcePolicy(declaredSize, policy) {
+  const knownSize = Number.isFinite(declaredSize) ? Math.max(0, declaredSize) : 0;
+  return {
+    ...DEFAULT_INTERACTIVE_RESOURCE_POLICY,
+    ...policy,
+    maxBytes: policy?.maxBytes ?? Math.max(DEFAULT_INTERACTIVE_RESOURCE_POLICY.maxBytes, knownSize)
+  };
+}
+function collectDocumentMediaReferences(doc) {
+  const references = /* @__PURE__ */ new Set();
+  const seen = /* @__PURE__ */ new WeakSet();
+  const visit = (value) => {
+    if (typeof value === "string") {
+      references.add(value);
+      if (value.startsWith("./")) references.add(value.slice(2));
+      return;
+    }
+    if (!value || typeof value !== "object" || seen.has(value)) return;
+    seen.add(value);
+    if (Array.isArray(value)) {
+      value.forEach(visit);
+      return;
+    }
+    Object.values(value).forEach(visit);
+  };
+  visit(doc);
+  return references;
+}
+async function resolveAudioBuffers(clips, sources) {
+  const srcs = new Set(clips.map((c) => c.src));
+  const out = /* @__PURE__ */ new Map();
+  for (const src of srcs) {
+    let data = sources.audio?.get(src) ?? sources.images?.get(src);
+    if (!data && sources.mediaProvider) {
+      try {
+        const url = await sources.mediaProvider.resolveUrl(src);
+        const resource = await fetchResourceBytes(url, {
+          policy: sources.resourcePolicy
+        });
+        data = toArrayBuffer(resource.bytes);
+      } catch {
+      }
+    }
+    if (data) out.set(src, data);
+  }
+  return out;
+}
+function resolveVideoExportCover(doc, config = {}) {
+  const legacyPreRollOverride = config.coverPreRoll;
+  const requestedDuration = config.coverDuration ?? legacyPreRollOverride;
+  if (requestedDuration !== void 0 && (!Number.isFinite(requestedDuration) || requestedDuration < 0 || requestedDuration > MAX_COVER_SLIDE_DURATION_SECONDS)) {
+    throw new Error(
+      `Cover duration must be a finite number of seconds between 0 and ${MAX_COVER_SLIDE_DURATION_SECONDS}`
+    );
+  }
+  const settings = resolveCoverSlideSettings(doc.frontmatter, {
+    ...config.showCoverSlide !== void 0 ? { enabled: config.showCoverSlide } : {},
+    ...requestedDuration !== void 0 ? { duration: requestedDuration } : {},
+    ...config.coverPlayback !== void 0 ? { playback: config.coverPlayback } : legacyPreRollOverride !== void 0 ? { playback: "preroll" } : {}
+  });
+  const showCoverSlide = settings.enabled && !!doc.startBlock;
+  const coverDuration = showCoverSlide ? settings.duration : 0;
+  return {
+    showCoverSlide,
+    coverDuration,
+    coverPlayback: settings.playback,
+    coverPreRoll: settings.playback === "preroll" ? coverDuration : 0
+  };
+}
+function resolveVideoCoverFramePlan(docDuration, fps, cover) {
+  const coverFrameCount = Math.ceil(cover.coverDuration * fps);
+  const storyFrameCount = Math.ceil(docDuration * fps);
+  const prerollFrameCount = cover.coverPlayback === "preroll" ? coverFrameCount : 0;
+  const totalFrames = prerollFrameCount + storyFrameCount;
+  return {
+    coverFrameCount,
+    storyFrameCount,
+    totalFrames,
+    totalDuration: totalFrames / fps,
+    audioOffset: prerollFrameCount / fps,
+    captureTimeForFrame: (frameIndex) => cover.coverPlayback === "preroll" && frameIndex < coverFrameCount ? 0 : (frameIndex - prerollFrameCount) / fps
+  };
+}
+function useVideoExport(options = {}) {
+  const [state, setState] = useState("idle");
+  const [progress, setProgress] = useState(0);
+  const [phase, setPhase] = useState("");
+  const [currentFrameTime, setCurrentFrameTime] = useState(null);
+  const [processingFps, setProcessingFps] = useState(null);
+  const [duration, setDuration] = useState(0);
+  const [outputFormat, setOutputFormat] = useState("mp4");
+  const [backend, setBackend] = useState(null);
+  const [downloadUrl, setDownloadUrl] = useState(null);
+  const [outputBlob, setOutputBlob] = useState(null);
+  const [fileSize, setFileSize] = useState(0);
+  const [audioIncluded, setAudioIncluded] = useState(false);
+  const [audioSkippedReason, setAudioSkippedReason] = useState(null);
+  const [error, setError] = useState(null);
+  const [elapsed, setElapsed] = useState(0);
+  const [estimatedRemaining, setEstimatedRemaining] = useState(0);
+  const encoderRef = useRef(null);
+  const gifAbortRef = useRef(null);
+  const cancelledRef = useRef(false);
+  const downloadUrlRef = useRef(null);
+  const startTimeRef = useRef(0);
+  const elapsedTimerRef = useRef(null);
+  const previewOptionsRef = useRef(options);
+  previewOptionsRef.current = options;
+  const frameCapture = useFrameCapture();
+  useEffect(() => {
+    return () => {
+      if (elapsedTimerRef.current) clearInterval(elapsedTimerRef.current);
+      if (downloadUrlRef.current) {
+        URL.revokeObjectURL(downloadUrlRef.current);
+      }
+      if (encoderRef.current) {
+        encoderRef.current.close();
+      }
+      gifAbortRef.current?.abort();
+      frameCapture.destroy();
+    };
+  }, [frameCapture]);
+  const reset = useCallback(() => {
+    if (downloadUrlRef.current) {
+      URL.revokeObjectURL(downloadUrlRef.current);
+      downloadUrlRef.current = null;
+    }
+    if (encoderRef.current) {
+      encoderRef.current.close();
+      encoderRef.current = null;
+    }
+    gifAbortRef.current?.abort();
+    gifAbortRef.current = null;
+    frameCapture.destroy();
+    setState("idle");
+    setProgress(0);
+    setPhase("");
+    setCurrentFrameTime(null);
+    setProcessingFps(null);
+    setDuration(0);
+    setOutputFormat("mp4");
+    setBackend(null);
+    setDownloadUrl(null);
+    setOutputBlob(null);
+    setFileSize(0);
+    setAudioIncluded(false);
+    setAudioSkippedReason(null);
+    setError(null);
+    setElapsed(0);
+    setEstimatedRemaining(0);
+    if (elapsedTimerRef.current) clearInterval(elapsedTimerRef.current);
+    cancelledRef.current = false;
+  }, [frameCapture]);
+  const cancel = useCallback(() => {
+    cancelledRef.current = true;
+    if (elapsedTimerRef.current) clearInterval(elapsedTimerRef.current);
+    if (encoderRef.current) {
+      encoderRef.current.close();
+      encoderRef.current = null;
+    }
+    gifAbortRef.current?.abort();
+    gifAbortRef.current = null;
+    frameCapture.destroy();
+    setState("idle");
+    setProgress(0);
+    setPhase("Cancelled");
+  }, [frameCapture]);
+  const startExport = useCallback(
+    async (doc, config) => {
+      cancelledRef.current = false;
+      if (downloadUrlRef.current) {
+        URL.revokeObjectURL(downloadUrlRef.current);
+        downloadUrlRef.current = null;
+      }
+      setDownloadUrl(null);
+      setOutputBlob(null);
+      setFileSize(0);
+      setAudioIncluded(false);
+      setAudioSkippedReason(null);
+      setError(null);
+      setCurrentFrameTime(null);
+      setProcessingFps(null);
+      const quality = config.quality ?? "normal";
+      const effectiveOutputFormat = config.outputFormat ?? "mp4";
+      const fps = config.fps ?? (effectiveOutputFormat === "gif" ? 10 : 30);
+      const orientation = config.orientation ?? "landscape";
+      const animationsEnabled = config.animationsEnabled ?? effectiveOutputFormat === "mp4";
+      const captionMode = config.captionMode ?? (effectiveOutputFormat === "gif" ? "standard" : "off");
+      const audioPolicy = config.audioPolicy ?? "require";
+      setOutputFormat(effectiveOutputFormat);
+      try {
+        const cover = resolveVideoExportCover(doc, config);
+        const gifDefaults = orientation === "portrait" ? { width: 540, height: 960 } : { width: 960, height: 540 };
+        const { width, height } = resolveDimensions({
+          orientation,
+          fps,
+          quality,
+          ...config.width !== void 0 ? { width: config.width } : effectiveOutputFormat === "gif" ? { width: gifDefaults.width } : {},
+          ...config.height !== void 0 ? { height: config.height } : effectiveOutputFormat === "gif" ? { height: gifDefaults.height } : {}
+        });
+        const webCodecsAvailable = supportsWebCodecs();
+        const sharedArrayBufferAvailable = typeof SharedArrayBuffer !== "undefined";
+        if (effectiveOutputFormat === "gif" && !sharedArrayBufferAvailable) {
+          throw new Error(
+            "Animated GIF export requires ffmpeg.wasm and SharedArrayBuffer (Cross-Origin-Isolation headers)."
+          );
+        }
+        if (effectiveOutputFormat === "gif") {
+          resolveFfmpegWasmLoad2(config.ffmpegWasm, "Animated GIF export");
+        }
+        if (!webCodecsAvailable && !sharedArrayBufferAvailable) {
+          throw new Error(
+            "No video encoder available. WebCodecs requires Chrome 94+ / Edge 94+, and the ffmpeg.wasm fallback requires SharedArrayBuffer (Cross-Origin-Isolation headers)."
+          );
+        }
+        setState("preparing");
+        setPhase("Loading document\u2026");
+        setProgress(0);
+        setElapsed(0);
+        setEstimatedRemaining(0);
+        startTimeRef.current = performance.now();
+        if (elapsedTimerRef.current) clearInterval(elapsedTimerRef.current);
+        elapsedTimerRef.current = setInterval(() => {
+          setElapsed(Math.floor((performance.now() - startTimeRef.current) / 1e3));
+        }, 1e3);
+        let images = config.images;
+        let ownsLoadedImages = false;
+        if (!images && config.mediaProvider) {
+          images = /* @__PURE__ */ new Map();
+          ownsLoadedImages = true;
+          const entries = await config.mediaProvider.listMedia();
+          const references = collectDocumentMediaReferences(doc);
+          const neededEntries = entries.filter(
+            (entry) => references.has(entry.name) || references.has(`./${entry.name}`)
+          );
+          if (neededEntries.length > MAX_EXPORT_MEDIA_FILES) {
+            throw new Error(
+              `Document references ${neededEntries.length} media files; browser export supports at most ${MAX_EXPORT_MEDIA_FILES}.`
+            );
+          }
+          for (const entry of neededEntries) {
+            if (cancelledRef.current) return;
+            const url2 = await config.mediaProvider.resolveUrl(entry.name);
+            const resource = await fetchResourceBytes(url2, {
+              policy: resolveExportMediaResourcePolicy(entry.size, config.resourcePolicy)
+            });
+            const data = toArrayBuffer(resource.bytes);
+            images.set(entry.name, data);
+          }
+        }
+        const docDuration = await frameCapture.init(
+          doc,
+          {
+            images,
+            audio: config.audio,
+            width,
+            height,
+            animationsEnabled,
+            theme: config.theme,
+            videoPresentation: config.videoPresentation,
+            pipSize: config.pipSize,
+            pipShape: config.pipShape,
+            pipPosition: config.pipPosition,
+            showCoverSlide: cover.showCoverSlide
+          },
+          captionMode
+        );
+        if (cancelledRef.current) return;
+        if (docDuration <= 0) {
+          throw new Error("Document has zero duration \u2014 nothing to export");
+        }
+        const coverPlan = resolveVideoCoverFramePlan(docDuration, fps, cover);
+        const { coverFrameCount, totalFrames } = coverPlan;
+        const exportDuration = coverPlan.totalDuration;
+        setDuration(exportDuration);
+        setPhase("Checking video encoder\u2026");
+        setProgress(5);
+        const canUseWebCodecs = webCodecsAvailable && await settleWithin(
+          supportsWebCodecsH264({ width, height, fps, quality }),
+          ENCODER_PROBE_TIMEOUT_MS,
+          "The browser did not finish checking WebCodecs support.",
+          void 0,
+          document
+        ).catch(() => false);
+        const audioBitrate = (QUALITY_PRESETS[quality] ?? QUALITY_PRESETS.normal).audioBitrate;
+        const timeline = effectiveOutputFormat === "mp4" && audioPolicy !== "omit" ? computeAudioTimeline(doc, coverPlan.audioOffset) : [];
+        const aacSupported = timeline.length > 0 ? await supportsWebCodecsAac(EXPORT_AUDIO_SAMPLE_RATE, EXPORT_AUDIO_CHANNELS) : false;
+        const tierDecision = selectAudioTier({
+          hasClips: timeline.length > 0,
+          aacSupported,
+          sharedArrayBufferAvailable,
+          canUseMainThreadWebCodecs: canUseWebCodecs
+        });
+        let renderedAudio = null;
+        let audioIncludedLocal = false;
+        let audioReasonLocal = tierDecision.reason;
+        if (timeline.length > 0 && tierDecision.tier === 3 && audioPolicy === "require") {
+          throw new Error(tierDecision.reason ?? "This browser cannot include the document audio.");
+        }
+        if (tierDecision.tier === 1 || tierDecision.tier === 2) {
+          setPhase("Preparing audio\u2026");
+          try {
+            const buffers = await resolveAudioBuffers(timeline, {
+              audio: config.audio,
+              images,
+              mediaProvider: config.mediaProvider,
+              resourcePolicy: config.resourcePolicy
+            });
+            try {
+              const missingSources = [...new Set(timeline.map((clip) => clip.src))].filter(
+                (src) => !buffers.has(src)
+              );
+              if (missingSources.length > 0) {
+                audioReasonLocal = `Audio files could not be loaded: ${missingSources.join(", ")}`;
+                if (audioPolicy === "require") throw new Error(audioReasonLocal);
+              }
+              if (buffers.size === 0) {
+                audioReasonLocal ?? (audioReasonLocal = "Audio files for this document could not be loaded.");
+              } else {
+                const totalAudioDur = timeline.reduce(
+                  (max, c) => Math.max(max, c.startSec + c.durationSec),
+                  exportDuration
+                );
+                renderedAudio = await renderAudioTimeline(
+                  timeline,
+                  buffers,
+                  totalAudioDur,
+                  EXPORT_AUDIO_SAMPLE_RATE
+                );
+                if (!renderedAudio) {
+                  audioReasonLocal = "No included video source contained a decodable audio track.";
+                }
+              }
+            } finally {
+              buffers.clear();
+            }
+          } catch (audioErr) {
+            renderedAudio = null;
+            audioReasonLocal = `Audio could not be prepared: ${audioErr instanceof Error ? audioErr.message : String(audioErr)}`;
+            if (audioPolicy === "require") throw new Error(audioReasonLocal);
+          }
+        }
+        const useInlineAudio = renderedAudio !== null && tierDecision.tier === 1;
+        const useFfmpegAudio = renderedAudio !== null && tierDecision.tier === 2;
+        if (cancelledRef.current) return;
+        let encoder;
+        if (canUseWebCodecs) {
+          encoder = createEncoder({
+            width,
+            height,
+            fps,
+            quality,
+            ...useInlineAudio && renderedAudio ? {
+              audio: {
+                numberOfChannels: renderedAudio.numberOfChannels,
+                sampleRate: renderedAudio.sampleRate
+              }
+            } : {},
+            // Plain MP4 downloads finalize to a Blob, so the muxer may spill
+            // settled bytes out of JS memory as it goes. GIF transcode and
+            // ffmpeg audio muxing need contiguous bytes — keep those in memory.
+            spillOutputToBlob: effectiveOutputFormat === "mp4" && !useFfmpegAudio
+          });
+          encoderRef.current = encoder;
+          setBackend("webcodecs");
+        } else if (sharedArrayBufferAvailable) {
+          setProgress(6);
+          setPhase("Loading export engine\u2026");
+          const workerEncoder = createWorkerEncoder({
+            width,
+            height,
+            fps,
+            quality,
+            totalFrames,
+            ffmpegWasm: config.ffmpegWasm
+          });
+          encoder = workerEncoder;
+          encoderRef.current = workerEncoder;
+          const selectedBackend = await settleWithin(
+            workerEncoder.ready,
+            ENCODER_START_TIMEOUT_MS,
+            "The browser export engine did not start within 60 seconds.",
+            void 0,
+            document
+          );
+          setBackend(selectedBackend);
+        } else {
+          throw new Error(
+            "WebCodecs H.264 is unavailable in this browser and the ffmpeg.wasm fallback requires SharedArrayBuffer (Cross-Origin-Isolation headers)."
+          );
+        }
+        if (useInlineAudio && renderedAudio && encoder.addAudioChunk) {
+          setPhase("Encoding audio\u2026");
+          try {
+            await encodeAacTrack(
+              renderedAudio,
+              { addAudioChunk: encoder.addAudioChunk.bind(encoder) },
+              audioBitrate
+            );
+            audioIncludedLocal = true;
+          } catch (audioErr) {
+            audioIncludedLocal = false;
+            audioReasonLocal = `Audio encoding failed: ${audioErr instanceof Error ? audioErr.message : String(audioErr)}`;
+            if (audioPolicy === "require") throw new Error(audioReasonLocal);
+          } finally {
+            renderedAudio = null;
+          }
+        }
+        if (ownsLoadedImages) images?.clear();
+        images = void 0;
+        if (cancelledRef.current) return;
+        setProgress(CAPTURE_PROGRESS_START);
+        setPhase(`Capturing frame 1/${totalFrames}`);
+        setCurrentFrameTime(0);
+        setState("capturing");
+        const captureStartTime = performance.now();
+        const frameBoundaryTimes = [captureStartTime];
+        if (coverFrameCount > 0) await frameCapture.setCoverVisible(true);
+        for (let i = 0; i < totalFrames; i++) {
+          if (cancelledRef.current) return;
+          if (coverFrameCount > 0 && i === coverFrameCount) {
+            await frameCapture.setCoverVisible(false);
+          }
+          const time = i / fps;
+          const captureTime = coverPlan.captureTimeForFrame(i);
+          const captureOperation = canUseWebCodecs ? frameCapture.captureCanvasFrame(captureTime, { reuseIfUnchanged: true }) : frameCapture.captureFrame(captureTime, { reuseIfUnchanged: true });
+          const frame = await settleFrameCaptureWithRecovery({
+            operation: captureOperation,
+            frameNumber: i + 1,
+            totalFrames,
+            onLateResult: releaseEncoderFrame,
+            activityDocument: document,
+            onRecoveryWait: () => setPhase(`Frame ${i + 1}/${totalFrames} is taking unusually long \u2014 still waiting\u2026`)
+          });
+          if (cancelledRef.current) {
+            releaseEncoderFrame(frame);
+            return;
+          }
+          const previewOptions = previewOptionsRef.current;
+          const previewInterval = Math.max(1, Math.floor(previewOptions.previewEveryNFrames ?? 1));
+          if (previewOptions.onFramePreview && (i === 0 || i === totalFrames - 1 || i % previewInterval === 0)) {
+            try {
+              previewOptions.onFramePreview({ source: frame, frameIndex: i, totalFrames, time });
+            } catch {
+            }
+          }
+          setPhase(`Encoding frame ${i + 1}/${totalFrames}`);
+          setCurrentFrameTime(time);
+          await settleWithin(
+            encoder.encodeFrame(frame, i),
+            FRAME_ENCODE_TIMEOUT_MS,
+            `Video encoding stopped responding at frame ${i + 1}/${totalFrames}.`,
+            void 0,
+            document
+          );
+          const completedFrames = i + 1;
+          const completedAt = performance.now();
+          frameBoundaryTimes.push(completedAt);
+          if (frameBoundaryTimes.length > FRAME_RATE_WINDOW_SIZE + 1) {
+            frameBoundaryTimes.shift();
+          }
+          setProcessingFps(calculateRollingFramesPerSecond(frameBoundaryTimes));
+          setCurrentFrameTime(Math.min(completedFrames / fps, exportDuration));
+          setPhase(
+            completedFrames < totalFrames ? `Capturing frame ${completedFrames + 1}/${totalFrames}` : `Captured ${totalFrames.toLocaleString()} frames\u2026`
+          );
+          const captureRatio = completedFrames / totalFrames;
+          const captureProgress = CAPTURE_PROGRESS_START + captureRatio * (CAPTURE_PROGRESS_END - CAPTURE_PROGRESS_START);
+          setProgress(Math.round(captureProgress * 10) / 10);
+          const elapsedCapture = (performance.now() - captureStartTime) / 1e3;
+          const avgPerFrame = elapsedCapture / completedFrames;
+          setEstimatedRemaining(Math.round(avgPerFrame * (totalFrames - completedFrames)));
+          setElapsed(Math.floor((performance.now() - startTimeRef.current) / 1e3));
+        }
+        if (cancelledRef.current) return;
+        setState("encoding");
+        setPhase(effectiveOutputFormat === "gif" ? "Finalizing GIF frames\u2026" : "Finalizing video\u2026");
+        setProgress(95);
+        let outputBytes = effectiveOutputFormat === "mp4" && !useFfmpegAudio && encoder.finalizeBlob ? await encoder.finalizeBlob() : await encoder.finalize();
+        encoderRef.current = null;
+        if (cancelledRef.current) return;
+        if (effectiveOutputFormat === "gif") {
+          setPhase("Generating GIF palette\u2026");
+          const videoOnly = outputBytes instanceof Blob ? new Uint8Array(await outputBytes.arrayBuffer()) : outputBytes instanceof Uint8Array ? outputBytes : new Uint8Array(outputBytes);
+          const gifAbort = new AbortController();
+          gifAbortRef.current = gifAbort;
+          try {
+            outputBytes = await transcodeMp4ToGifWithFfmpegWasm(
+              videoOnly,
+              { width, height, loop: 0 },
+              config.ffmpegWasm,
+              gifAbort.signal
+            );
+          } finally {
+            if (gifAbortRef.current === gifAbort) gifAbortRef.current = null;
+          }
+        } else if (useFfmpegAudio && renderedAudio) {
+          setPhase("Muxing audio\u2026");
+          try {
+            const wav = audioBufferToWav(renderedAudio);
+            const videoOnly = outputBytes instanceof Blob ? new Uint8Array(await outputBytes.arrayBuffer()) : outputBytes instanceof Uint8Array ? outputBytes : new Uint8Array(outputBytes);
+            outputBytes = await muxAudioWithFfmpegWasm(
+              videoOnly,
+              wav,
+              audioBitrate,
+              config.ffmpegWasm
+            );
+            audioIncludedLocal = true;
+          } catch (audioErr) {
+            audioIncludedLocal = false;
+            audioReasonLocal = `Audio muxing failed: ${audioErr instanceof Error ? audioErr.message : String(audioErr)}`;
+            if (audioPolicy === "require") throw new Error(audioReasonLocal);
+          }
+        }
+        if (cancelledRef.current) return;
+        const mimeType = effectiveOutputFormat === "gif" ? "image/gif" : "video/mp4";
+        const blob = outputBytes instanceof Blob ? outputBytes : new Blob(
+          [
+            outputBytes instanceof Uint8Array ? outputBytes.slice() : new Uint8Array(outputBytes)
+          ],
+          { type: mimeType }
+        );
+        const url = URL.createObjectURL(blob);
+        downloadUrlRef.current = url;
+        setDownloadUrl(url);
+        setOutputBlob(blob);
+        setFileSize(blob.size);
+        setAudioIncluded(audioIncludedLocal);
+        setAudioSkippedReason(
+          effectiveOutputFormat === "gif" || audioIncludedLocal ? null : audioReasonLocal
+        );
+        setState("complete");
+        setProgress(100);
+        setPhase("Export complete");
+        setEstimatedRemaining(0);
+        if (elapsedTimerRef.current) clearInterval(elapsedTimerRef.current);
+        frameCapture.destroy();
+      } catch (err) {
+        if (elapsedTimerRef.current) clearInterval(elapsedTimerRef.current);
+        if (cancelledRef.current) return;
+        const message = err instanceof Error ? err.message : String(err);
+        setState("error");
+        setError(message);
+        setPhase("Export failed");
+        if (encoderRef.current) {
+          encoderRef.current.close();
+          encoderRef.current = null;
+        }
+        gifAbortRef.current?.abort();
+        gifAbortRef.current = null;
+        frameCapture.destroy();
+      }
+    },
+    [frameCapture]
+  );
+  return {
+    state,
+    progress,
+    phase,
+    currentFrameTime,
+    processingFps,
+    duration,
+    outputFormat,
+    backend,
+    downloadUrl,
+    outputBlob,
+    fileSize,
+    audioIncluded,
+    audioSkippedReason,
+    error,
+    elapsed,
+    estimatedRemaining,
+    startExport,
+    cancel,
+    reset
+  };
+}
+
+export {
+  DEFAULT_VIDEO_COVER_PRE_ROLL_SECONDS,
+  resolveVideoExportCover,
+  resolveVideoCoverFramePlan,
+  useVideoExport
+};