@bendyline/squisq-video-react 2.2.10 → 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-ERG6OLLO.js → chunk-KW5BBYKP.js}

@@ -1,6 +1,6 @@
 import {
   useVideoExport
-} from "./chunk-GLOLS2CQ.js";
+} from "./chunk-F2XUI32B.js";
 
 // src/VideoExportModal.tsx
 import { useState, useCallback, useId, useRef } from "react";
@@ -174,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"
   );
@@ -251,7 +251,7 @@ function VideoExportModal({
       setAnimationsEnabled(false);
       setCaptionMode("standard");
     } else {
-      setFps(24);
+      setFps(30);
       setAnimationsEnabled(true);
       setCaptionMode("off");
     }

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, e as VideoOutputFormat } from '../useVideoExport-raCbwbwb.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 */

package/dist/components/index.js

@@ -1,10 +1,10 @@
 import {
   VideoExportButton,
   VideoExportModal
-} from "../chunk-ERG6OLLO.js";
-import "../chunk-GLOLS2CQ.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-raCbwbwb.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.

package/dist/hooks/index.js

@@ -3,9 +3,9 @@ import {
   resolveVideoExportCover,
   useFrameCapture,
   useVideoExport
-} from "../chunk-GLOLS2CQ.js";
-import "../chunk-2XACUF6E.js";
-import "../chunk-MEPETH5V.js";
+} from "../chunk-F2XUI32B.js";
+import "../chunk-KJ5RKG67.js";
+import "../chunk-I4SXMCDF.js";
 export {
   DEFAULT_VIDEO_COVER_PRE_ROLL_SECONDS,
   resolveVideoExportCover,

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export { VideoExportButton, VideoExportButtonProps, VideoExportModal, VideoExportModalProps, VideoExportPalette } from './components/index.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-raCbwbwb.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';
 export { FrameCaptureHandle, FrameCaptureOptions, FrameCaptureRenderOptions, useFrameCapture } from './hooks/index.js';
-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';
 export { supportsWebCodecsAac } from './encoder/index.js';
 import 'react/jsx-runtime';

package/dist/index.js

@@ -1,20 +1,20 @@
 import {
   VideoExportButton,
   VideoExportModal
-} from "./chunk-ERG6OLLO.js";
+} from "./chunk-KW5BBYKP.js";
 import {
   DEFAULT_VIDEO_COVER_PRE_ROLL_SECONDS,
   resolveVideoExportCover,
   useFrameCapture,
   useVideoExport
-} from "./chunk-GLOLS2CQ.js";
+} from "./chunk-F2XUI32B.js";
 import {
   createEncoder,
   supportsWebCodecs,
   supportsWebCodecsAac,
   supportsWebCodecsH264
-} from "./chunk-2XACUF6E.js";
-import "./chunk-MEPETH5V.js";
+} from "./chunk-KJ5RKG67.js";
+import "./chunk-I4SXMCDF.js";
 export {
   DEFAULT_VIDEO_COVER_PRE_ROLL_SECONDS,
   VideoExportButton,

package/dist/{mainThreadEncoder-BgcFyYvO.d.ts → mainThreadEncoder-CiVsL1Bf.d.ts}

@@ -44,6 +44,8 @@ interface MainThreadEncoder {
     addAudioChunk?(chunk: EncodedAudioChunk, meta?: EncodedAudioChunkMetadata): void;
     /** Flush pending frames and finalize the MP4. Returns the MP4 ArrayBuffer. */
     finalize(): Promise<ArrayBuffer>;
+    /** Finalize directly into a Blob, avoiding a second full-file allocation. */
+    finalizeBlob?(): Promise<Blob>;
     /** Close the encoder without producing output (e.g., on cancel). */
     close(): void;
 }

package/dist/{useVideoExport-raCbwbwb.d.ts → useVideoExport-CM5XiM6Z.d.ts}

@@ -2,7 +2,7 @@ import { MediaProvider, Theme, VideoPresentation, VideoPipSize, VideoPipShape, V
 import { ResourcePolicy } from '@bendyline/squisq/markdown';
 import { VideoQuality, VideoOrientation, FfmpegWasmLoadConfig } from '@bendyline/squisq-video';
 import { CaptionMode } from '@bendyline/squisq-react';
-import { a as EncoderFrameSource } from './mainThreadEncoder-BgcFyYvO.js';
+import { a as EncoderFrameSource } from './mainThreadEncoder-CiVsL1Bf.js';
 
 /**
  * useVideoExport — Main orchestration hook for browser video export.

package/dist/workers/encode.worker.js

@@ -3,7 +3,7 @@ import {
   createMp4Muxer,
   resolveWebCodecsQueueLimit,
   shouldEncodeFfmpegBatch
-} from "../chunk-MEPETH5V.js";
+} from "../chunk-I4SXMCDF.js";
 
 // src/workers/encode.worker.ts
 import {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bendyline/squisq-video-react",
-  "version": "2.2.10",
+  "version": "2.2.11",
   "description": "React components for browser-based MP4 and animated-GIF export of Squisq documents",
   "license": "MIT",
   "author": "Bendyline",
@@ -67,7 +67,7 @@
   "dependencies": {
     "@bendyline/squisq": "2.4.4",
     "@bendyline/squisq-video": "2.2.8",
-    "@bendyline/squisq-react": "2.4.6",
+    "@bendyline/squisq-react": "2.4.7",
     "@ffmpeg/core": "0.12.9",
     "@ffmpeg/ffmpeg": "0.12.15",
     "@ffmpeg/util": "0.12.2",