@bendyline/squisq-video-react 2.2.11 → 2.3.1

package/dist/{chunk-F2XUI32B.js → chunk-YTEDBL6F.js}

@@ -1,17 +1,3 @@
-import {
-  EXPORT_AUDIO_CHANNELS,
-  EXPORT_AUDIO_SAMPLE_RATE,
-  audioBufferToWav,
-  createEncoder,
-  encodeAacTrack,
-  muxAudioWithFfmpegWasm,
-  renderAudioTimeline,
-  selectAudioTier,
-  supportsWebCodecs,
-  supportsWebCodecsAac,
-  supportsWebCodecsH264
-} from "./chunk-KJ5RKG67.js";
-
 // src/hooks/useFrameCapture.ts
 import { createElement } from "react";
 import { createRoot } from "react-dom/client";
@@ -131,16 +117,21 @@ function waitForCaptureVideoState(video, description, isReady, update) {
     }
   });
 }
+function captureVideoNeedsPriming(video, primedVideos) {
+  if (video.readyState >= HTMLMediaElement.HAVE_METADATA && video.videoWidth <= 0 && video.videoHeight <= 0) {
+    return false;
+  }
+  return !primedVideos.has(video) || !Number.isFinite(video.duration);
+}
 async function primeIndeterminateCaptureVideos(captureRoot, primedVideos = /* @__PURE__ */ new WeakSet()) {
   const videos = Array.from(captureRoot.querySelectorAll("video")).filter(
-    (video) => !primedVideos.has(video)
+    (video) => captureVideoNeedsPriming(video, primedVideos)
   );
   let primedCount = 0;
   await Promise.all(
     videos.map(async (video) => {
       const source = video.currentSrc || video.src;
       if (!source) {
-        primedVideos.add(video);
         return;
       }
       await waitForCaptureVideoState(
@@ -590,11 +581,31 @@ function scheduledVideoIsVisual(video) {
 function scheduledVideoPresentation(video) {
   return video.closest(SCHEDULED_MEDIA_SELECTOR)?.dataset.presentation;
 }
-function canCompositeScheduledPipVideos(captureRoot) {
-  const activeVisualVideos = Array.from(
+function planScheduledVideoComposite(captureRoot) {
+  const activeVideos = Array.from(
     captureRoot.querySelectorAll(SCHEDULED_VIDEO_SELECTOR)
   ).filter(scheduledVideoIsVisual);
-  return activeVisualVideos.length > 0 && activeVisualVideos.every((video) => scheduledVideoPresentation(video) === "picture-in-picture");
+  if (activeVideos.length === 0) return null;
+  const underlays = [];
+  const overlays = [];
+  for (const video of activeVideos) {
+    const presentation = scheduledVideoPresentation(video);
+    if (presentation === "background") underlays.push(video);
+    else if (presentation === "picture-in-picture") overlays.push(video);
+    else return null;
+  }
+  return { underlays, overlays };
+}
+function clearScheduledUnderlayBackdrops(clonedRoot) {
+  const groups = clonedRoot.querySelectorAll(
+    `${SCHEDULED_MEDIA_SELECTOR}[data-presentation="background"]`
+  );
+  for (const group of Array.from(groups)) {
+    for (let element = group.parentElement; element; element = element === clonedRoot ? null : element.parentElement) {
+      element.style.backgroundColor = "transparent";
+      element.style.backgroundImage = "none";
+    }
+  }
 }
 function cssPixelValue(value) {
   const parsed = Number.parseFloat(value);
@@ -627,18 +638,13 @@ function addRoundedRect(context, x, y, width, height, radius) {
     context.rect(x, y, width, height);
   }
 }
-function compositeScheduledPipVideos(captureRoot, destination) {
+function drawScheduledVideosOnto(destination, captureRoot, videos) {
   const context = destination.getContext("2d");
-  if (!context) throw new Error("Could not create the PiP compositor canvas context");
+  if (!context) throw new Error("Could not create the scheduled-video compositor canvas context");
   const rootRect = captureRoot.getBoundingClientRect();
   if (rootRect.width <= 0 || rootRect.height <= 0) return 0;
   const scaleX = destination.width / rootRect.width;
   const scaleY = destination.height / rootRect.height;
-  const videos = Array.from(
-    captureRoot.querySelectorAll(SCHEDULED_VIDEO_SELECTOR)
-  ).filter(
-    (video) => scheduledVideoIsVisual(video) && scheduledVideoPresentation(video) === "picture-in-picture"
-  );
   for (const video of videos) {
     const rect = video.getBoundingClientRect();
     if (rect.width <= 0 || rect.height <= 0) continue;
@@ -757,6 +763,7 @@ function useFrameCapture() {
   const rootRef = useRef(null);
   const renderAPIRef = useRef(null);
   const mediaProviderRef = useRef(null);
+  const ownsMediaProviderRef = useRef(false);
   const captureCanvasRef = useRef(null);
   const captureBaseCanvasRef = useRef(null);
   const lastVisualStateKeyRef = useRef(null);
@@ -772,12 +779,14 @@ function useFrameCapture() {
         const oldRoot = rootRef.current;
         const oldContainer = containerRef.current;
         const oldMediaProvider = mediaProviderRef.current;
+        const oldOwnsMediaProvider = ownsMediaProviderRef.current;
         const oldCaptureCanvas = captureCanvasRef.current;
         const oldCaptureBaseCanvas = captureBaseCanvasRef.current;
         rootRef.current = null;
         containerRef.current = null;
         renderAPIRef.current = null;
         mediaProviderRef.current = null;
+        ownsMediaProviderRef.current = false;
         captureCanvasRef.current = null;
         captureBaseCanvasRef.current = null;
         lastVisualStateKeyRef.current = null;
@@ -791,7 +800,7 @@ function useFrameCapture() {
           setTimeout(() => {
             if (oldRoot) oldRoot.unmount();
             if (oldContainer) oldContainer.remove();
-            oldMediaProvider?.dispose();
+            if (oldOwnsMediaProvider) oldMediaProvider?.dispose();
             if (oldCaptureCanvas) {
               oldCaptureCanvas.width = 0;
               oldCaptureCanvas.height = 0;
@@ -835,8 +844,9 @@ function useFrameCapture() {
       renderRoot.id = "squisq-capture-root";
       renderRoot.style.cssText = `width:${width}px;height:${height}px;`;
       container.appendChild(renderRoot);
-      const mediaProvider = renderOptions.images ? createInlineProvider(renderOptions.images) : null;
+      const mediaProvider = renderOptions.images ? createInlineProvider(renderOptions.images) : renderOptions.mediaProvider ?? null;
       mediaProviderRef.current = mediaProvider;
+      ownsMediaProviderRef.current = !!renderOptions.images;
       const root = createRoot(renderRoot);
       rootRef.current = root;
       const captionsEnabled = captionMode !== void 0 && captionMode !== "off";
@@ -859,6 +869,7 @@ function useFrameCapture() {
         pipShape: renderOptions.pipShape,
         pipPosition: renderOptions.pipPosition,
         showCoverSlide: renderOptions.showCoverSlide,
+        coverSlideTemplate: renderOptions.coverSlideTemplate,
         captionsEnabled,
         captionStyle,
         onRenderAPIReady: (api) => {
@@ -922,11 +933,19 @@ function useFrameCapture() {
         throw new Error("Frame capture not initialized \u2014 call init() first");
       }
       const { width, height } = dimensionsRef.current;
-      await api.seekTo(time);
       const root = container.querySelector("#squisq-capture-root");
       if (!root) {
         throw new Error("Capture root element not found");
       }
+      await primeIndeterminateCaptureVideos(root, primedCaptureVideosRef.current);
+      try {
+        await api.seekTo(time);
+      } catch (seekError) {
+        if (!await primeIndeterminateCaptureVideos(root, primedCaptureVideosRef.current)) {
+          throw seekError;
+        }
+        await api.seekTo(time);
+      }
       if (await primeIndeterminateCaptureVideos(root, primedCaptureVideosRef.current)) {
         await api.seekTo(time);
       }
@@ -937,13 +956,15 @@ function useFrameCapture() {
         );
       }
       await waitForCaptureAssets(root, decodedImagesRef.current);
-      const compositePip = canCompositeScheduledPipVideos(root);
-      const visualStateKey = options.reuseIfUnchanged ? `${compositePip ? "base" : "full"}:${getFrameVisualStateKey(root, time, {
-        ignoreScheduledVideoFrames: compositePip
+      const compositePlan = planScheduledVideoComposite(root);
+      const hasUnderlays = compositePlan !== null && compositePlan.underlays.length > 0;
+      const rasterMode = compositePlan ? hasUnderlays ? "base-underlay" : "base" : "full";
+      const visualStateKey = options.reuseIfUnchanged ? `${rasterMode}:${getFrameVisualStateKey(root, time, {
+        ignoreScheduledVideoFrames: compositePlan !== null
       })}` : null;
       const shouldRasterize = visualStateKey === null || !hasCapturedFrameRef.current || lastVisualStateKeyRef.current !== visualStateKey;
-      if (!shouldRasterize && !compositePip) return captureCanvas;
-      const rasterCanvas = compositePip ? captureBaseCanvas : captureCanvas;
+      if (!shouldRasterize && !compositePlan) return captureCanvas;
+      const rasterCanvas = compositePlan ? captureBaseCanvas : captureCanvas;
       const captureContext = rasterCanvas.getContext("2d");
       if (!captureContext) throw new Error("Could not create the frame capture canvas context");
       if (shouldRasterize) {
@@ -960,10 +981,14 @@ function useFrameCapture() {
             scale: 1,
             useCORS: true,
             allowTaint: true,
-            backgroundColor: "#000000",
+            // An underlay base must stay transparent so the background video
+            // composited beneath it shows through everything the player does
+            // not paint. The compositor restores the opaque black backdrop.
+            backgroundColor: hasUnderlays ? null : "#000000",
             logging: false,
             onclone: async (_clonedDocument, clonedRoot) => {
-              if (compositePip) {
+              if (compositePlan) {
+                if (hasUnderlays) clearScheduledUnderlayBackdrops(clonedRoot);
                 clonedRoot.querySelectorAll(SCHEDULED_MEDIA_SELECTOR).forEach((element) => element.remove());
               }
               transientCloneCanvases.push(...prepareScheduledVideoClones(root, clonedRoot));
@@ -986,13 +1011,16 @@ function useFrameCapture() {
         hasCapturedFrameRef.current = true;
         lastVisualStateKeyRef.current = visualStateKey;
       }
-      if (compositePip) {
+      if (compositePlan) {
         const outputContext = captureCanvas.getContext("2d");
         if (!outputContext) throw new Error("Could not create the frame output canvas context");
         outputContext.setTransform(1, 0, 0, 1, 0, 0);
         outputContext.clearRect(0, 0, width, height);
+        outputContext.fillStyle = "#000000";
+        outputContext.fillRect(0, 0, width, height);
+        drawScheduledVideosOnto(captureCanvas, root, compositePlan.underlays);
         outputContext.drawImage(captureBaseCanvas, 0, 0);
-        compositeScheduledPipVideos(root, captureCanvas);
+        drawScheduledVideosOnto(captureCanvas, root, compositePlan.overlays);
       }
       return captureCanvas;
     },
@@ -1014,8 +1042,9 @@ function useFrameCapture() {
       containerRef.current.remove();
       containerRef.current = null;
     }
-    mediaProviderRef.current?.dispose();
+    if (ownsMediaProviderRef.current) mediaProviderRef.current?.dispose();
     mediaProviderRef.current = null;
+    ownsMediaProviderRef.current = false;
     if (captureCanvasRef.current) {
       captureCanvasRef.current.width = 0;
       captureCanvasRef.current.height = 0;
@@ -1041,911 +1070,6 @@ function useFrameCapture() {
   );
 }
 
-// src/hooks/useVideoExport.ts
-import { useState, useRef as useRef2, useCallback as useCallback2, useEffect } from "react";
-import {
-  DEFAULT_INTERACTIVE_RESOURCE_POLICY,
-  fetchResourceBytes
-} from "@bendyline/squisq/markdown";
-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_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 = 2;
-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);
-      }
-    );
-  });
-}
-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 resolveFrontmatterBoolean(value) {
-  if (typeof value === "boolean") return value;
-  if (typeof value !== "string") return void 0;
-  const normalized = value.trim().toLowerCase();
-  if (normalized === "true" || normalized === "yes" || normalized === "on" || normalized === "show" || normalized === "visible") {
-    return true;
-  }
-  if (normalized === "false" || normalized === "no" || normalized === "off" || normalized === "hide" || normalized === "hidden") {
-    return false;
-  }
-  return void 0;
-}
-function resolveVideoExportCover(doc, config = {}) {
-  const frontmatter = doc.frontmatter;
-  const frontmatterValue = frontmatter ? Object.prototype.hasOwnProperty.call(frontmatter, "squisq-cover-slide") ? frontmatter["squisq-cover-slide"] : frontmatter["cover-slide"] : void 0;
-  const showCoverSlide = config.showCoverSlide ?? resolveFrontmatterBoolean(frontmatterValue) ?? true;
-  const requestedPreRoll = config.coverPreRoll ?? DEFAULT_VIDEO_COVER_PRE_ROLL_SECONDS;
-  if (!Number.isFinite(requestedPreRoll) || requestedPreRoll < 0) {
-    throw new Error("Cover pre-roll must be a finite number of seconds greater than or equal to 0");
-  }
-  return {
-    showCoverSlide,
-    coverPreRoll: showCoverSlide && !!doc.startBlock ? requestedPreRoll : 0
-  };
-}
-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 = useRef2(null);
-  const gifAbortRef = useRef2(null);
-  const cancelledRef = useRef2(false);
-  const downloadUrlRef = useRef2(null);
-  const startTimeRef = useRef2(0);
-  const elapsedTimerRef = useRef2(null);
-  const previewOptionsRef = useRef2(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 = useCallback2(() => {
-    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 = useCallback2(() => {
-    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 = useCallback2(
-    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 coverFrameCount = Math.ceil(cover.coverPreRoll * fps);
-        const storyFrameCount = Math.ceil(docDuration * fps);
-        const totalFrames = coverFrameCount + storyFrameCount;
-        const exportDuration = totalFrames / fps;
-        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, coverFrameCount / fps) : [];
-        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
-              }
-            } : {}
-          });
-          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 = i < coverFrameCount ? 0 : (i - coverFrameCount) / fps;
-          const captureOperation = canUseWebCodecs ? frameCapture.captureCanvasFrame(captureTime, { reuseIfUnchanged: true }) : frameCapture.captureFrame(captureTime, { reuseIfUnchanged: true });
-          const frame = await settleWithin(
-            captureOperation,
-            FRAME_CAPTURE_TIMEOUT_MS,
-            `Frame capture stopped responding at frame ${i + 1}/${totalFrames}.`,
-            releaseEncoderFrame,
-            document
-          );
-          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 {
-  useFrameCapture,
-  DEFAULT_VIDEO_COVER_PRE_ROLL_SECONDS,
-  resolveVideoExportCover,
-  useVideoExport
+  useFrameCapture
 };