@bendyline/squisq-video-react 2.2.9 → 2.2.11

package/dist/{chunk-MEPETH5V.js → chunk-I4SXMCDF.js}

@@ -1905,8 +1905,73 @@ ensureNotFinalized_fn = function() {
 };
 
 // src/mp4Mux.ts
+var ChunkedMp4Output = class {
+  constructor() {
+    this.writes = [];
+    this.length = 0;
+  }
+  write(data, position) {
+    const owned = new Uint8Array(data);
+    const end = position + owned.byteLength;
+    if (position >= this.length) {
+      this.writes.push({ position, data: owned });
+      this.length = end;
+      return;
+    }
+    const updated = [];
+    for (const existing of this.writes) {
+      const existingEnd = existing.position + existing.data.byteLength;
+      if (existingEnd <= position || existing.position >= end) {
+        updated.push(existing);
+        continue;
+      }
+      if (existing.position < position) {
+        updated.push({
+          position: existing.position,
+          data: existing.data.subarray(0, position - existing.position)
+        });
+      }
+      if (existingEnd > end) {
+        updated.push({
+          position: end,
+          data: existing.data.subarray(end - existing.position)
+        });
+      }
+    }
+    updated.push({ position, data: owned });
+    updated.sort((left, right) => left.position - right.position);
+    this.writes = updated;
+    this.length = Math.max(this.length, end);
+  }
+  toArrayBuffer() {
+    const output = new Uint8Array(this.length);
+    for (const write of this.writes) output.set(write.data, write.position);
+    this.release();
+    return output.buffer;
+  }
+  toBlob() {
+    const parts = [];
+    let position = 0;
+    for (const write of this.writes) {
+      if (write.position > position) parts.push(new Uint8Array(write.position - position));
+      parts.push(write.data);
+      position = write.position + write.data.byteLength;
+    }
+    if (position < this.length) parts.push(new Uint8Array(this.length - position));
+    const blob = new Blob(parts, { type: "video/mp4" });
+    this.release();
+    return blob;
+  }
+  release() {
+    this.writes = [];
+    this.length = 0;
+  }
+};
 function createMp4Muxer(options) {
-  const target = new ArrayBufferTarget();
+  const output = new ChunkedMp4Output();
+  const target = new StreamTarget({
+    onData: (data, position) => output.write(data, position)
+  });
   const muxer = new Muxer({
     target,
     video: {
@@ -1930,6 +1995,12 @@ function createMp4Muxer(options) {
     // releases the sample payload immediately.
     fastStart: false
   });
+  let finalized = false;
+  const finalizeMuxer = () => {
+    if (finalized) throw new Error("MP4 muxer already finalized");
+    muxer.finalize();
+    finalized = true;
+  };
   return {
     hasAudioTrack: options.audio !== void 0,
     addVideoChunk(chunk, meta) {
@@ -1945,8 +2016,12 @@ function createMp4Muxer(options) {
       muxer.addAudioChunkRaw(data, type, timestampMicros, durationMicros, meta);
     },
     finalize() {
-      muxer.finalize();
-      return target.buffer;
+      finalizeMuxer();
+      return output.toArrayBuffer();
+    },
+    finalizeBlob() {
+      finalizeMuxer();
+      return output.toBlob();
     }
   };
 }

package/dist/{chunk-2XACUF6E.js → chunk-KJ5RKG67.js}

@@ -2,7 +2,7 @@ import {
   applyWebCodecsBackpressure,
   createMp4Muxer,
   resolveWebCodecsQueueLimit
-} from "./chunk-MEPETH5V.js";
+} from "./chunk-I4SXMCDF.js";
 
 // src/mainThreadEncoder.ts
 import { bitrateForQuality, validateVideoExportOptions } from "@bendyline/squisq-video";
@@ -24,6 +24,14 @@ async function supportsWebCodecsH264(config) {
     return false;
   }
 }
+var RECLAIMED_CODEC_ERROR = /codec reclaimed due to inactivity/i;
+var MAX_CODEC_RECOVERY_ATTEMPTS = 2;
+function toError(caught) {
+  return caught instanceof Error ? caught : new Error(String(caught));
+}
+function isReclaimedCodecError(error) {
+  return RECLAIMED_CODEC_ERROR.test(error.message);
+}
 function createEncoder(config) {
   validateVideoExportOptions(config);
   if (!supportsWebCodecs()) {
@@ -39,60 +47,136 @@ function createEncoder(config) {
   });
   let closed = false;
   let fatalError = null;
+  let recoverableError = null;
   const frameDuration = 1e6 / config.fps;
   const queueLimit = resolveWebCodecsQueueLimit(config);
   let framesSinceFlush = 0;
+  let forceNextKeyFrame = false;
+  let encoderGeneration = 0;
+  let encoder;
   function fail(err) {
     closed = true;
     if (encoder.state !== "closed") encoder.close();
     return fatalError ?? err;
   }
-  const encoder = new VideoEncoder({
-    output(chunk, meta) {
-      if (closed) return;
-      muxer.addVideoChunk(chunk, meta ?? void 0);
-    },
-    error(err) {
-      fatalError ?? (fatalError = new Error(`WebCodecs encoder error: ${err.message}`));
-    }
-  });
-  encoder.configure({
-    // Deliberate profile split from the fallback worker (avc1.42001f, Baseline):
-    // this primary WebCodecs path targets H.264 High@4.0 for better quality up
-    // to 1080p; the wasm-fallback worker uses Baseline for max decoder compat.
+  const videoEncoderConfig = {
+    // Deliberate profile split from the fallback worker (avc1.42001f,
+    // Baseline): this primary WebCodecs path targets H.264 High@4.0 for
+    // better quality up to 1080p; the wasm-fallback worker uses Baseline for
+    // maximum decoder compatibility.
     codec: "avc1.640028",
-    // H.264 High profile, level 4.0 (supports up to 1080p)
     width: config.width,
     height: config.height,
     bitrate: bitrateForQuality(config.quality, config.width, config.height),
     framerate: config.fps
-  });
-  return {
-    async encodeFrame(source, frameIndex) {
-      if (fatalError) {
-        if ("close" in source) source.close();
-        throw fail(fatalError);
+  };
+  function createConfiguredVideoEncoder() {
+    const generation = ++encoderGeneration;
+    const nextEncoder = new VideoEncoder({
+      output(chunk, meta) {
+        if (closed || generation !== encoderGeneration) return;
+        muxer.addVideoChunk(chunk, meta ?? void 0);
+      },
+      error(err) {
+        if (closed || generation !== encoderGeneration || fatalError || recoverableError) return;
+        const wrapped = new Error(`WebCodecs encoder error: ${err.message}`);
+        if (isReclaimedCodecError(wrapped)) {
+          recoverableError = wrapped;
+        } else {
+          fatalError = wrapped;
+        }
       }
-      if (closed) {
-        if ("close" in source) source.close();
-        throw new Error("Encoder already closed");
+    });
+    nextEncoder.configure(videoEncoderConfig);
+    return nextEncoder;
+  }
+  function recoverCodec() {
+    const previousEncoder = encoder;
+    recoverableError = null;
+    if (previousEncoder.state !== "closed") previousEncoder.close();
+    encoder = createConfiguredVideoEncoder();
+    framesSinceFlush = 0;
+    forceNextKeyFrame = true;
+  }
+  encoder = createConfiguredVideoEncoder();
+  async function finishVideoEncoding() {
+    if (closed) throw new Error("Encoder already closed");
+    let recoveryAttempts = 0;
+    while (true) {
+      if (fatalError) throw fail(fatalError);
+      if (recoverableError) {
+        if (recoveryAttempts >= MAX_CODEC_RECOVERY_ATTEMPTS) {
+          throw fail(recoverableError);
+        }
+        recoverCodec();
+        recoveryAttempts++;
       }
       try {
-        const drained = await applyWebCodecsBackpressure(encoder, queueLimit, framesSinceFlush);
-        if (drained) framesSinceFlush = 0;
-        if (fatalError) throw fail(fatalError);
-        if (closed) throw new Error("Encoder already closed");
-        const timestamp = Math.round(frameIndex * frameDuration);
-        const frame = new VideoFrame(source, { timestamp });
+        await encoder.flush();
+      } catch (caught) {
+        const error = toError(caught);
+        if (!recoverableError && isReclaimedCodecError(error)) {
+          recoverableError = error;
+        }
+        if (recoverableError && recoveryAttempts < MAX_CODEC_RECOVERY_ATTEMPTS) continue;
+        throw fail(fatalError ?? recoverableError ?? error);
+      }
+      if (fatalError) throw fail(fatalError);
+      if (recoverableError) continue;
+      break;
+    }
+    encoder.close();
+    closed = true;
+  }
+  return {
+    async encodeFrame(source, frameIndex) {
+      try {
         try {
-          const keyFrame = frameIndex % 30 === 0;
-          encoder.encode(frame, { keyFrame });
-          framesSinceFlush++;
-        } finally {
-          frame.close();
+          let recoveryAttempts = 0;
+          while (true) {
+            if (fatalError) throw fail(fatalError);
+            if (closed) throw new Error("Encoder already closed");
+            if (recoverableError) {
+              if (recoveryAttempts >= MAX_CODEC_RECOVERY_ATTEMPTS) {
+                throw fail(recoverableError);
+              }
+              recoverCodec();
+              recoveryAttempts++;
+            }
+            try {
+              const drained = await applyWebCodecsBackpressure(
+                encoder,
+                queueLimit,
+                framesSinceFlush
+              );
+              if (drained) framesSinceFlush = 0;
+              if (fatalError) throw fail(fatalError);
+              if (recoverableError) continue;
+              if (closed) throw new Error("Encoder already closed");
+              const timestamp = Math.round(frameIndex * frameDuration);
+              const frame = new VideoFrame(source, { timestamp });
+              try {
+                const keyFrame = forceNextKeyFrame || frameIndex % 30 === 0;
+                encoder.encode(frame, { keyFrame });
+                framesSinceFlush++;
+                forceNextKeyFrame = false;
+              } finally {
+                frame.close();
+              }
+              if (recoverableError) continue;
+              return;
+            } catch (caught) {
+              const error = toError(caught);
+              if (!recoverableError && isReclaimedCodecError(error)) {
+                recoverableError = error;
+              }
+              if (recoverableError && recoveryAttempts < MAX_CODEC_RECOVERY_ATTEMPTS) continue;
+              throw fail(fatalError ?? recoverableError ?? error);
+            }
+          }
+        } catch (caught) {
+          throw fail(toError(caught));
         }
-      } catch (err) {
-        throw fail(err instanceof Error ? err : new Error(String(err)));
       } finally {
         if ("close" in source) source.close();
       }
@@ -102,18 +186,13 @@ function createEncoder(config) {
       muxer.addAudioChunk(chunk, meta);
     },
     async finalize() {
-      if (closed) throw new Error("Encoder already closed");
-      if (fatalError) throw fail(fatalError);
-      try {
-        await encoder.flush();
-      } catch (err) {
-        throw fail(err instanceof Error ? err : new Error(String(err)));
-      }
-      if (fatalError) throw fail(fatalError);
-      encoder.close();
-      closed = true;
+      await finishVideoEncoding();
       return muxer.finalize();
     },
+    async finalizeBlob() {
+      await finishVideoEncoding();
+      return muxer.finalizeBlob();
+    },
     close() {
       if (closed) return;
       closed = true;
@@ -186,25 +265,35 @@ async function renderAudioTimeline(clips, buffers, totalDurationSec, sampleRate
   if (requiredFailures.length > 0) {
     throw new Error(`No decodable audio track was found in: ${requiredFailures.join(", ")}`);
   }
-  let scheduledNodes = 0;
-  for (const clip of clips) {
-    const buffer = decoded.get(clip.src);
-    if (!buffer) {
-      if (clip.sourceKind === "video") continue;
-      throw new Error(`Audio source was not decoded: ${clip.src}`);
+  const scheduledNodes = [];
+  try {
+    for (const clip of clips) {
+      const buffer = decoded.get(clip.src);
+      if (!buffer) {
+        if (clip.sourceKind === "video") continue;
+        throw new Error(`Audio source was not decoded: ${clip.src}`);
+      }
+      const node = ctx.createBufferSource();
+      node.buffer = buffer;
+      node.connect(ctx.destination);
+      const when = Math.max(0, clip.startSec);
+      const offset = Math.max(0, clip.sourceInSec);
+      const duration = Math.max(0, clip.durationSec);
+      node.start(when, offset, duration);
+      scheduledNodes.push(node);
     }
-    const node = ctx.createBufferSource();
-    node.buffer = buffer;
-    node.connect(ctx.destination);
-    const when = Math.max(0, clip.startSec);
-    const offset = Math.max(0, clip.sourceInSec);
-    const duration = Math.max(0, clip.durationSec);
-    node.start(when, offset, duration);
-    scheduledNodes++;
+    if (scheduledNodes.length === 0) return null;
+    return await ctx.startRendering();
+  } finally {
+    for (const node of scheduledNodes) {
+      node.disconnect();
+      node.buffer = null;
+    }
+    decoded.clear();
   }
-  if (scheduledNodes === 0) return null;
-  return ctx.startRendering();
 }
+var AAC_FRAME_SAMPLES = 1024;
+var MAX_AAC_QUEUE_SECONDS = 2;
 async function encodeAacTrack(audioBuffer, sink, bitrate) {
   if (typeof AudioEncoder === "undefined" || typeof AudioData === "undefined") {
     throw new Error("WebCodecs AudioEncoder is not available.");
@@ -219,34 +308,47 @@ async function encodeAacTrack(audioBuffer, sink, bitrate) {
     }
   });
   encoder.configure({ codec: "mp4a.40.2", sampleRate, numberOfChannels: channels, bitrate });
-  const FRAME = 1024;
   const total = audioBuffer.length;
+  const queueLimit = Math.max(
+    1,
+    Math.ceil(sampleRate * MAX_AAC_QUEUE_SECONDS / AAC_FRAME_SAMPLES)
+  );
   const channelData = [];
   for (let ch = 0; ch < channels; ch++) {
     channelData.push(audioBuffer.getChannelData(ch));
   }
-  for (let offset = 0; offset < total; offset += FRAME) {
-    if (encodeError) break;
-    const count = Math.min(FRAME, total - offset);
-    const planar = new Float32Array(count * channels);
-    for (let ch = 0; ch < channels; ch++) {
-      planar.set(channelData[ch].subarray(offset, offset + count), ch * count);
+  try {
+    for (let offset = 0; offset < total; offset += AAC_FRAME_SAMPLES) {
+      if (encodeError) throw encodeError;
+      if (encoder.encodeQueueSize >= queueLimit) {
+        await encoder.flush();
+        if (encodeError) throw encodeError;
+      }
+      const count = Math.min(AAC_FRAME_SAMPLES, total - offset);
+      const planar = new Float32Array(count * channels);
+      for (let ch = 0; ch < channels; ch++) {
+        planar.set(channelData[ch].subarray(offset, offset + count), ch * count);
+      }
+      const timestamp = Math.round(offset / sampleRate * 1e6);
+      const audioData = new AudioData({
+        format: "f32-planar",
+        sampleRate,
+        numberOfFrames: count,
+        numberOfChannels: channels,
+        timestamp,
+        data: planar
+      });
+      try {
+        encoder.encode(audioData);
+      } finally {
+        audioData.close();
+      }
     }
-    const timestamp = Math.round(offset / sampleRate * 1e6);
-    const audioData = new AudioData({
-      format: "f32-planar",
-      sampleRate,
-      numberOfFrames: count,
-      numberOfChannels: channels,
-      timestamp,
-      data: planar
-    });
-    encoder.encode(audioData);
-    audioData.close();
+    await encoder.flush();
+    if (encodeError) throw encodeError;
+  } finally {
+    if (encoder.state !== "closed") encoder.close();
   }
-  await encoder.flush();
-  encoder.close();
-  if (encodeError) throw encodeError;
 }
 function audioBufferToWav(buffer) {
   const channels = buffer.numberOfChannels;

package/dist/{chunk-SO656KT7.js → chunk-KW5BBYKP.js}

@@ -1,6 +1,6 @@
 import {
   useVideoExport
-} from "./chunk-NX34XGLL.js";
+} from "./chunk-F2XUI32B.js";
 
 // src/VideoExportModal.tsx
 import { useState, useCallback, useId, useRef } from "react";
@@ -18,6 +18,9 @@ function formatProcessingFps(framesPerSecond) {
 function formatRealtimeMultiplier(processingFps, outputFps) {
   return `${(processingFps / outputFps).toFixed(2)}\xD7 realtime`;
 }
+function resolveVideoSaveActionLabel(format, formatter) {
+  return formatter?.(format) ?? `Save ${format.toUpperCase()} to Downloads`;
+}
 var FRAME_PREVIEW_INTERVAL = 15;
 var FRAME_PREVIEW_WIDTH = 480;
 var FRAME_PREVIEW_HEIGHT = 270;
@@ -160,6 +163,8 @@ function VideoExportModal({
   defaultConfig,
   colorScheme = "light",
   uiPalette,
+  saveOutput,
+  saveActionLabel,
   onClose
 }) {
   const overlayRef = useRef(null);
@@ -169,7 +174,7 @@ function VideoExportModal({
   const initialOutputFormat = defaultConfig?.outputFormat ?? "mp4";
   const [outputFormat, setOutputFormat] = useState(initialOutputFormat);
   const [quality, setQuality] = useState(defaultConfig?.quality ?? "normal");
-  const [fps, setFps] = useState(defaultConfig?.fps ?? (initialOutputFormat === "gif" ? 10 : 24));
+  const [fps, setFps] = useState(defaultConfig?.fps ?? (initialOutputFormat === "gif" ? 10 : 30));
   const [orientation, setOrientation] = useState(
     defaultConfig?.orientation ?? "landscape"
   );
@@ -228,6 +233,7 @@ function VideoExportModal({
     processingFps,
     outputFormat: completedOutputFormat,
     downloadUrl,
+    outputBlob,
     fileSize,
     audioIncluded,
     audioSkippedReason,
@@ -245,7 +251,7 @@ function VideoExportModal({
       setAnimationsEnabled(false);
       setCaptionMode("standard");
     } else {
-      setFps(24);
+      setFps(30);
       setAnimationsEnabled(true);
       setCaptionMode("off");
     }
@@ -290,16 +296,31 @@ function VideoExportModal({
     defaultConfig,
     startExport
   ]);
-  const handleDownload = useCallback(() => {
-    if (!downloadUrl) return;
-    const a = document.createElement("a");
-    a.href = downloadUrl;
+  const [saving, setSaving] = useState(false);
+  const [saveError, setSaveError] = useState(null);
+  const handleSave = useCallback(async () => {
+    if (!downloadUrl || !outputBlob) return;
     const ts = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-    a.download = `document-${ts}.${completedOutputFormat}`;
-    document.body.appendChild(a);
-    a.click();
-    document.body.removeChild(a);
-  }, [downloadUrl, completedOutputFormat]);
+    const filename = `document-${ts}.${completedOutputFormat}`;
+    setSaveError(null);
+    if (!saveOutput) {
+      const a = document.createElement("a");
+      a.href = downloadUrl;
+      a.download = filename;
+      document.body.appendChild(a);
+      a.click();
+      document.body.removeChild(a);
+      return;
+    }
+    setSaving(true);
+    try {
+      await saveOutput(outputBlob, filename);
+    } catch (caught) {
+      setSaveError(caught instanceof Error ? caught.message : "The export could not be saved.");
+    } finally {
+      setSaving(false);
+    }
+  }, [completedOutputFormat, downloadUrl, outputBlob, saveOutput]);
   const handleClose = useCallback(() => {
     if (state === "capturing" || state === "encoding" || state === "preparing") {
       cancelExport();
@@ -591,11 +612,17 @@ function VideoExportModal({
               ] }),
               /* @__PURE__ */ jsxs("div", { style: footerStyle, children: [
                 /* @__PURE__ */ jsx("button", { style: themedSecondaryButtonStyle, onClick: handleClose, children: "Close" }),
-                /* @__PURE__ */ jsxs("button", { style: themedPrimaryButtonStyle, onClick: handleDownload, children: [
-                  "Download ",
-                  completedOutputFormat.toUpperCase()
-                ] })
-              ] })
+                /* @__PURE__ */ jsx(
+                  "button",
+                  {
+                    style: themedPrimaryButtonStyle,
+                    onClick: () => void handleSave(),
+                    disabled: saving,
+                    children: saving ? "Saving..." : resolveVideoSaveActionLabel(completedOutputFormat, saveActionLabel)
+                  }
+                )
+              ] }),
+              saveError && /* @__PURE__ */ jsx("p", { role: "alert", style: { fontSize: 12, color: palette.danger, margin: "8px 0 0 0" }, children: saveError })
             ] }),
             state === "error" && /* @__PURE__ */ jsxs(Fragment, { children: [
               /* @__PURE__ */ jsx("p", { style: { fontSize: 14, margin: "0 0 8px 0", color: palette.danger }, children: "Export failed" }),
@@ -639,6 +666,8 @@ function VideoExportButton({
   defaultConfig,
   colorScheme,
   uiPalette,
+  saveOutput,
+  saveActionLabel,
   label,
   style,
   disabled
@@ -661,6 +690,8 @@ function VideoExportButton({
           defaultConfig,
           colorScheme,
           uiPalette,
+          saveOutput,
+          saveActionLabel,
           onClose: handleClose
         }
       ),

package/dist/components/index.d.ts

@@ -1,10 +1,10 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { Doc, MediaProvider } from '@bendyline/squisq/schemas';
-import { a as VideoExportConfig } from '../useVideoExport-DKpdXZ0o.js';
+import { a as VideoExportConfig, e as VideoOutputFormat } from '../useVideoExport-CM5XiM6Z.js';
 import '@bendyline/squisq/markdown';
 import '@bendyline/squisq-video';
 import '@bendyline/squisq-react';
-import '../mainThreadEncoder-BgcFyYvO.js';
+import '../mainThreadEncoder-CiVsL1Bf.js';
 
 interface VideoExportModalProps {
     /** The document to export */
@@ -33,6 +33,10 @@ interface VideoExportModalProps {
     colorScheme?: 'light' | 'dark';
     /** Optional host overrides for dialog surfaces, controls, status, and accent colors. */
     uiPalette?: Partial<VideoExportPalette>;
+    /** Optional host save flow. Return false when the user cancels a picker. */
+    saveOutput?: (blob: Blob, filename: string) => boolean | void | Promise<boolean | void>;
+    /** Host-aware label for the completed export action. */
+    saveActionLabel?: (format: VideoOutputFormat) => string;
     /** Called when the modal should close */
     onClose: () => void;
 }
@@ -52,7 +56,7 @@ interface VideoExportPalette {
     success: string;
     danger: string;
 }
-declare function VideoExportModal({ doc, playerScript, mediaProvider, images, audio, defaultConfig, colorScheme, uiPalette, onClose, }: VideoExportModalProps): react_jsx_runtime.JSX.Element;
+declare function VideoExportModal({ doc, playerScript, mediaProvider, images, audio, defaultConfig, colorScheme, uiPalette, saveOutput, saveActionLabel, onClose, }: VideoExportModalProps): react_jsx_runtime.JSX.Element;
 
 interface VideoExportButtonProps {
     /** The document to export */
@@ -79,6 +83,10 @@ interface VideoExportButtonProps {
     colorScheme?: 'light' | 'dark';
     /** Optional host palette overrides forwarded to the portaled modal. */
     uiPalette?: Partial<VideoExportPalette>;
+    /** Optional host save flow forwarded to the portaled modal. */
+    saveOutput?: VideoExportModalProps['saveOutput'];
+    /** Host-aware completed-export action label forwarded to the modal. */
+    saveActionLabel?: VideoExportModalProps['saveActionLabel'];
     /** Button label (defaults to "Export Video", or "Export GIF" for a GIF default config) */
     label?: string;
     /** Additional inline styles for the button */
@@ -86,6 +94,6 @@ interface VideoExportButtonProps {
     /** Whether the button is disabled */
     disabled?: boolean;
 }
-declare function VideoExportButton({ doc, playerScript, mediaProvider, images, audio, defaultConfig, colorScheme, uiPalette, label, style, disabled, }: VideoExportButtonProps): react_jsx_runtime.JSX.Element;
+declare function VideoExportButton({ doc, playerScript, mediaProvider, images, audio, defaultConfig, colorScheme, uiPalette, saveOutput, saveActionLabel, label, style, disabled, }: VideoExportButtonProps): react_jsx_runtime.JSX.Element;
 
 export { VideoExportButton, type VideoExportButtonProps, VideoExportModal, type VideoExportModalProps, type VideoExportPalette };

package/dist/components/index.js

@@ -1,10 +1,10 @@
 import {
   VideoExportButton,
   VideoExportModal
-} from "../chunk-SO656KT7.js";
-import "../chunk-NX34XGLL.js";
-import "../chunk-2XACUF6E.js";
-import "../chunk-MEPETH5V.js";
+} from "../chunk-KW5BBYKP.js";
+import "../chunk-F2XUI32B.js";
+import "../chunk-KJ5RKG67.js";
+import "../chunk-I4SXMCDF.js";
 export {
   VideoExportButton,
   VideoExportModal

package/dist/encoder/index.d.ts

@@ -1,4 +1,4 @@
-export { E as EncoderConfig, a as EncoderFrameSource, M as MainThreadEncoder, c as createEncoder, s as supportsWebCodecs, b as supportsWebCodecsH264 } from '../mainThreadEncoder-BgcFyYvO.js';
+export { E as EncoderConfig, a as EncoderFrameSource, M as MainThreadEncoder, c as createEncoder, s as supportsWebCodecs, b as supportsWebCodecsH264 } from '../mainThreadEncoder-CiVsL1Bf.js';
 export { FfmpegWasmLoadConfig } from '@bendyline/squisq-video';
 
 /**

package/dist/encoder/index.js

@@ -3,8 +3,8 @@ import {
   supportsWebCodecs,
   supportsWebCodecsAac,
   supportsWebCodecsH264
-} from "../chunk-2XACUF6E.js";
-import "../chunk-MEPETH5V.js";
+} from "../chunk-KJ5RKG67.js";
+import "../chunk-I4SXMCDF.js";
 export {
   createEncoder,
   supportsWebCodecs,

package/dist/hooks/index.d.ts

@@ -1,9 +1,9 @@
-export { D as DEFAULT_VIDEO_COVER_PRE_ROLL_SECONDS, R as ResolvedVideoExportCover, U as UseVideoExportOptions, V as VideoAudioPolicy, a as VideoExportConfig, b as VideoExportFramePreview, c as VideoExportResult, d as VideoExportState, e as VideoOutputFormat, r as resolveVideoExportCover, u as useVideoExport } from '../useVideoExport-DKpdXZ0o.js';
+export { D as DEFAULT_VIDEO_COVER_PRE_ROLL_SECONDS, R as ResolvedVideoExportCover, U as UseVideoExportOptions, V as VideoAudioPolicy, a as VideoExportConfig, b as VideoExportFramePreview, c as VideoExportResult, d as VideoExportState, e as VideoOutputFormat, r as resolveVideoExportCover, u as useVideoExport } from '../useVideoExport-CM5XiM6Z.js';
 import { Doc } from '@bendyline/squisq/schemas';
 import { RenderHtmlOptions } from '@bendyline/squisq-video';
 import { CaptionMode } from '@bendyline/squisq-react';
 import '@bendyline/squisq/markdown';
-import '../mainThreadEncoder-BgcFyYvO.js';
+import '../mainThreadEncoder-CiVsL1Bf.js';
 
 /**
  * useFrameCapture — Hidden div + html2canvas frame capture.