@bendyline/squisq-video-react 2.4.20 → 2.4.22

package/dist/chunk-FMQI6WK2.js

@@ -0,0 +1,157 @@
+import {
+  LOSSY_FORMATS,
+  assertOpen,
+  blockFrames,
+  createSerialQueue
+} from "./chunk-2W6JQSIY.js";
+
+// src/audioFile/wavStream.ts
+var HEADER_BYTES = 44;
+var BYTES_PER_SAMPLE = 2;
+var MAX_WAV_DATA_BYTES = 4294967295 - 36;
+var DEFAULT_CHUNK_BYTES = 1 << 20;
+function wavHeader(sampleRate, channels, dataBytes) {
+  const header = new Uint8Array(HEADER_BYTES);
+  const view = new DataView(header.buffer);
+  const ascii = (offset, text) => {
+    for (let i = 0; i < text.length; i++) view.setUint8(offset + i, text.charCodeAt(i));
+  };
+  const blockAlign = channels * BYTES_PER_SAMPLE;
+  ascii(0, "RIFF");
+  view.setUint32(4, 36 + dataBytes, true);
+  ascii(8, "WAVE");
+  ascii(12, "fmt ");
+  view.setUint32(16, 16, true);
+  view.setUint16(20, 1, true);
+  view.setUint16(22, channels, true);
+  view.setUint32(24, sampleRate, true);
+  view.setUint32(28, sampleRate * blockAlign, true);
+  view.setUint16(32, blockAlign, true);
+  view.setUint16(34, BYTES_PER_SAMPLE * 8, true);
+  ascii(36, "data");
+  view.setUint32(40, dataBytes, true);
+  return header;
+}
+function toPcm16(sample) {
+  if (!(sample > -1)) return sample <= -1 ? -32768 : 0;
+  if (sample >= 1) return 32767;
+  return Math.round(sample < 0 ? sample * 32768 : sample * 32767);
+}
+function createWavStreamWriter(sampleRate, channels, options = {}) {
+  const blockAlign = channels * BYTES_PER_SAMPLE;
+  const chunkFrames = Math.max(
+    1,
+    Math.floor((options.chunkBytes ?? DEFAULT_CHUNK_BYTES) / blockAlign)
+  );
+  const scratch = new ArrayBuffer(chunkFrames * blockAlign);
+  const view = new DataView(scratch);
+  const parts = [];
+  let pendingFrames = 0;
+  let dataBytes = 0;
+  let finished = false;
+  const flushScratch = () => {
+    if (pendingFrames === 0) return;
+    parts.push(new Blob([new Uint8Array(scratch, 0, pendingFrames * blockAlign)]));
+    pendingFrames = 0;
+  };
+  return {
+    get dataBytes() {
+      return dataBytes;
+    },
+    append(planar) {
+      if (finished) throw new Error("The WAV writer is already finished.");
+      const frames = planar[0]?.length ?? 0;
+      if (frames === 0) return;
+      if (dataBytes + frames * blockAlign > MAX_WAV_DATA_BYTES) {
+        throw new RangeError("WAV files cannot exceed 4 GiB; use a compressed format instead.");
+      }
+      for (let frame = 0; frame < frames; frame++) {
+        let offset = pendingFrames * blockAlign;
+        for (let c = 0; c < channels; c++) {
+          view.setInt16(offset, toPcm16(planar[c][frame]), true);
+          offset += BYTES_PER_SAMPLE;
+        }
+        pendingFrames += 1;
+        if (pendingFrames === chunkFrames) flushScratch();
+      }
+      dataBytes += frames * blockAlign;
+    },
+    finish() {
+      if (finished) throw new Error("The WAV writer is already finished.");
+      finished = true;
+      flushScratch();
+      const blob = new Blob([wavHeader(sampleRate, channels, dataBytes), ...parts], {
+        type: "audio/wav"
+      });
+      parts.length = 0;
+      return blob;
+    }
+  };
+}
+
+// src/audioFile/audioFileEncoder.ts
+var lossyModule = null;
+function loadLossyModule() {
+  lossyModule ?? (lossyModule = import("./lossyEncoder-EIXBAOLG.js"));
+  return lossyModule;
+}
+function validateOptions(options) {
+  if (options.format !== "wav" && !(options.format in LOSSY_FORMATS)) {
+    throw new RangeError(`Unknown audio file format: ${String(options.format)}`);
+  }
+  if (!Number.isInteger(options.sampleRate) || options.sampleRate < 3e3 || options.sampleRate > 768e3) {
+    throw new RangeError(`Unsupported sample rate: ${options.sampleRate}`);
+  }
+  if (options.channels !== 1 && options.channels !== 2) {
+    throw new RangeError(`Audio files support 1 or 2 channels (got ${String(options.channels)}).`);
+  }
+  if (options.bitrate !== void 0 && (!Number.isFinite(options.bitrate) || options.bitrate < 6e3 || options.bitrate > 512e3)) {
+    throw new RangeError(`Unsupported bitrate: ${options.bitrate}`);
+  }
+}
+async function supportedAudioFileFormats() {
+  const formats = [];
+  try {
+    const lossy = await loadLossyModule();
+    for (const info of [LOSSY_FORMATS.m4a, LOSSY_FORMATS["opus-webm"]]) {
+      if (await lossy.canEncodeLossyFormat(info)) formats.push(info.format);
+    }
+  } catch {
+  }
+  formats.push("wav");
+  return formats;
+}
+async function createAudioFileEncoder(options) {
+  validateOptions(options);
+  if (options.format === "wav") return createWavEncoder(options);
+  const lossy = await loadLossyModule();
+  return lossy.createLossyEncoder(options, LOSSY_FORMATS[options.format]);
+}
+function createWavEncoder(options) {
+  const writer = createWavStreamWriter(options.sampleRate, options.channels);
+  const serial = createSerialQueue();
+  let state = "open";
+  return {
+    format: "wav",
+    mimeType: "audio/wav",
+    extension: "wav",
+    append: (block) => serial(async () => {
+      assertOpen(state);
+      blockFrames(block, options.channels);
+      writer.append(block);
+    }),
+    finish: () => serial(async () => {
+      assertOpen(state);
+      state = "finished";
+      return writer.finish();
+    }),
+    cancel: async () => {
+      if (state === "open") state = "cancelled";
+    }
+  };
+}
+
+export {
+  supportedAudioFileFormats,
+  createAudioFileEncoder
+};

package/dist/{chunk-GBIYYDMY.js → chunk-ISYJJJXN.js}

@@ -450,6 +450,68 @@ async function muxAudioWithFfmpegWasm(videoMp4, wav, audioBitrate, loadConfig) {
   }
 }
 
+// src/documentAudio.ts
+import { computeAudioTimeline } from "@bendyline/squisq-video";
+function documentAudioTimeline(doc, options = {}) {
+  const offset = options.offsetSec ?? 0;
+  return options.processedAudio ? computeAudioTimeline(doc, offset, { processedAudio: options.processedAudio }) : computeAudioTimeline(doc, offset);
+}
+async function loadAudioTimelineSources(timeline, readMedia, signal) {
+  const buffers = /* @__PURE__ */ new Map();
+  const missing = [];
+  for (const src of new Set(timeline.map((clip) => clip.src))) {
+    signal?.throwIfAborted();
+    const data = await readMedia(src);
+    if (data) buffers.set(src, data);
+    else missing.push(src);
+  }
+  signal?.throwIfAborted();
+  return { buffers, missing };
+}
+function audioTimelineEnd(timeline, minDurationSec = 0) {
+  const floor = Number.isFinite(minDurationSec) ? Math.max(0, minDurationSec) : 0;
+  return timeline.reduce((end, clip) => Math.max(end, clip.startSec + clip.durationSec), floor);
+}
+function mixAudioTimeline(timeline, buffers, minDurationSec, sampleRate = EXPORT_AUDIO_SAMPLE_RATE) {
+  return renderAudioTimeline(
+    timeline,
+    buffers,
+    audioTimelineEnd(timeline, minDurationSec),
+    sampleRate
+  );
+}
+async function renderDocumentAudio(doc, options) {
+  const { signal } = options;
+  signal?.throwIfAborted();
+  const timeline = documentAudioTimeline(
+    doc,
+    options.processedAudio ? { processedAudio: options.processedAudio } : {}
+  );
+  if (timeline.length === 0) return null;
+  const { buffers, missing } = await loadAudioTimelineSources(
+    timeline,
+    (src) => options.readMedia(src),
+    signal
+  );
+  try {
+    if (missing.length > 0 && (options.missingMedia ?? "error") === "error") {
+      throw new Error(`Audio files could not be loaded: ${missing.join(", ")}`);
+    }
+    const playable = timeline.filter((clip) => buffers.has(clip.src));
+    if (playable.length === 0) return null;
+    const mixed = await mixAudioTimeline(
+      playable,
+      buffers,
+      doc.duration,
+      options.sampleRate ?? EXPORT_AUDIO_SAMPLE_RATE
+    );
+    signal?.throwIfAborted();
+    return mixed;
+  } finally {
+    buffers.clear();
+  }
+}
+
 export {
   supportsWebCodecs,
   supportsWebCodecsH264,
@@ -461,5 +523,9 @@ export {
   renderAudioTimeline,
   encodeAacTrack,
   audioBufferToWav,
-  muxAudioWithFfmpegWasm
+  muxAudioWithFfmpegWasm,
+  documentAudioTimeline,
+  loadAudioTimelineSources,
+  mixAudioTimeline,
+  renderDocumentAudio
 };

package/dist/{chunk-KJQVUVOG.js → chunk-JDIMPME5.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-3NJDHK62.js";
 import {
   useFrameCapture
-} from "./chunk-QJWEZRZS.js";
+} from "./chunk-A52VG7RA.js";
 
 // src/CoverImageExportModal.tsx
 import { useCallback, useId, useRef, useState } from "react";

package/dist/{chunk-JKWCZION.js → chunk-OLFWEKY5.js}

@@ -7,7 +7,7 @@ var inlineDenoiser = createRnnoiseDenoiserFactory(
   () => import("@shiguredo/rnnoise-wasm").then(({ Rnnoise }) => Rnnoise.load())
 );
 async function inlineEngine() {
-  return import("./mediaEditEngine-ZLG7D3TB.js");
+  return import("./mediaEditEngine-JLZ4Z5BB.js");
 }
 function inlineOptions(options) {
   return { ...options, denoiser: options.denoiser ?? inlineDenoiser };

package/dist/{chunk-A6ED7EVY.js → chunk-TUZLVOSP.js}

@@ -1,6 +1,6 @@
 import {
   useVideoExport
-} from "./chunk-MI4EJXTD.js";
+} from "./chunk-47ODXCBA.js";
 
 // src/VideoExportModal.tsx
 import { useState, useCallback, useEffect, useId, useRef } from "react";
@@ -317,6 +317,7 @@ function VideoExportModal({
   ]);
   const [saving, setSaving] = useState(false);
   const [saveError, setSaveError] = useState(null);
+  const [savedOutput, setSavedOutput] = useState(null);
   const handleSave = useCallback(async () => {
     if (!downloadUrl || !outputBlob) return;
     const ts = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
@@ -329,11 +330,12 @@ function VideoExportModal({
       document.body.appendChild(a);
       a.click();
       document.body.removeChild(a);
+      setSavedOutput(outputBlob);
       return;
     }
     setSaving(true);
     try {
-      await saveOutput(outputBlob, filename);
+      if (await saveOutput(outputBlob, filename) !== false) setSavedOutput(outputBlob);
     } catch (caught) {
       setSaveError(caught instanceof Error ? caught.message : "The export could not be saved.");
     } finally {
@@ -349,10 +351,11 @@ function VideoExportModal({
     onClose();
   }, [state, cancelExport, resetExport, onClose]);
   const isExporting = state === "preparing" || state === "capturing" || state === "encoding";
+  const escapeCloses = !preparingEdits && (state === "idle" || state === "error" || state === "complete" && outputBlob !== null && savedOutput === outputBlob);
   useModalDialog({
     rootRef: overlayRef,
     dialogRef,
-    closeOnEscape: false,
+    closeOnEscape: escapeCloses,
     onClose: handleClose
   });
   return /* @__PURE__ */ jsx(

package/dist/components/index.js

@@ -1,17 +1,17 @@
 import {
   VideoExportButton,
   VideoExportModal
-} from "../chunk-A6ED7EVY.js";
+} from "../chunk-TUZLVOSP.js";
 import {
   CoverImageExportModal,
   coverImageFilename,
   validateCoverImageDimensions
-} from "../chunk-KJQVUVOG.js";
+} from "../chunk-JDIMPME5.js";
 import "../chunk-3NJDHK62.js";
-import "../chunk-MI4EJXTD.js";
-import "../chunk-QJWEZRZS.js";
-import "../chunk-4GFZ3GUE.js";
-import "../chunk-GBIYYDMY.js";
+import "../chunk-47ODXCBA.js";
+import "../chunk-A52VG7RA.js";
+import "../chunk-C7NEHV5X.js";
+import "../chunk-ISYJJJXN.js";
 import "../chunk-5MFQMJ5Z.js";
 export {
   CoverImageExportModal,

package/dist/cover-image/index.js

@@ -2,10 +2,10 @@ import {
   CoverImageExportModal,
   coverImageFilename,
   validateCoverImageDimensions
-} from "../chunk-KJQVUVOG.js";
+} from "../chunk-JDIMPME5.js";
 import "../chunk-3NJDHK62.js";
-import "../chunk-QJWEZRZS.js";
-import "../chunk-4GFZ3GUE.js";
+import "../chunk-A52VG7RA.js";
+import "../chunk-C7NEHV5X.js";
 export {
   CoverImageExportModal,
   coverImageFilename,

package/dist/dashboard-image/index.js

@@ -7,8 +7,8 @@ import {
 } from "../chunk-3NJDHK62.js";
 import {
   useFrameCapture
-} from "../chunk-QJWEZRZS.js";
-import "../chunk-4GFZ3GUE.js";
+} from "../chunk-A52VG7RA.js";
+import "../chunk-C7NEHV5X.js";
 
 // src/DashboardImageExportModal.tsx
 import { useCallback, useId, useMemo, useRef, useState } from "react";

package/dist/encoder/index.d.ts

@@ -1,5 +1,7 @@
 export { E as EncoderConfig, a as EncoderFrameSource, M as MainThreadEncoder, c as createEncoder, s as supportsWebCodecs, b as supportsWebCodecsH264 } from '../mainThreadEncoder-BVCLjlfj.js';
-export { FfmpegWasmLoadConfig } from '@bendyline/squisq-video';
+import { AudioTimelineClip } from '@bendyline/squisq-video';
+export { AudioTimelineClip, FfmpegWasmLoadConfig } from '@bendyline/squisq-video';
+import { MediaScheduleOptions, Doc } from '@bendyline/squisq/schemas';
 
 /**
  * audioTrack — In-browser audio rendering + AAC encoding for MP4 export.
@@ -26,5 +28,127 @@ export { FfmpegWasmLoadConfig } from '@bendyline/squisq-video';
  * older Chromium) or the config is unsupported.
  */
 declare function supportsWebCodecsAac(sampleRate?: number, channels?: number): Promise<boolean>;
+/**
+ * Mix a list of timeline clips into one `AudioBuffer`.
+ *
+ * Decodes each unique source once, then schedules an `AudioBufferSourceNode`
+ * per clip at its `startSec` with the trim window (`offset = sourceInSec`,
+ * `duration = durationSec`). Authored audio/narration sources must decode.
+ * Video sources are optional because a valid video can be silent: each is
+ * decoded independently, silent ones are skipped, and every audible video is
+ * connected to the same destination so overlapping tracks are mixed.
+ */
+declare function renderAudioTimeline(clips: AudioTimelineClip[], buffers: Map<string, ArrayBuffer>, totalDurationSec: number, sampleRate?: number): Promise<AudioBuffer | null>;
+
+/**
+ * Types and helpers shared by the audio-file encoder's WAV and lossy paths.
+ */
+type AudioFileFormat = 'm4a' | 'opus-webm' | 'wav';
+interface AudioFileEncoderOptions {
+    readonly format: AudioFileFormat;
+    /** Sample rate of the PCM passed to `append` (e.g. 24000 or 48000). */
+    readonly sampleRate: number;
+    readonly channels: 1 | 2;
+    /** Bits per second for lossy formats. Defaults depend on format and channel count. */
+    readonly bitrate?: number;
+}
+interface AudioFileEncoder {
+    readonly format: AudioFileFormat;
+    /** `'audio/mp4'` | `'audio/webm'` | `'audio/wav'` */
+    readonly mimeType: string;
+    /** `'m4a'` | `'webm'` | `'wav'` */
+    readonly extension: string;
+    /**
+     * Append planar float32 PCM, one Float32Array per channel, at
+     * `options.sampleRate`. Streams; never buffers the whole file in float32.
+     * Calls are serialized, but awaiting each one respects encoder backpressure.
+     */
+    append(channels: readonly Float32Array[]): Promise<void>;
+    /** Flush and return the finished file. */
+    finish(): Promise<Blob>;
+    /** Abandon the file and release encoder resources. */
+    cancel(): Promise<void>;
+}
+
+/**
+ * Streaming audio-file encoder: planar float32 PCM in, an M4A (AAC), Opus/WebM
+ * or WAV `Blob` out.
+ *
+ * - `m4a` — AAC in an audio-only MP4 (mediabunny's MP4 writer; unlike the
+ *   video export's muxer it declares no video track). Needs a WebCodecs AAC
+ *   encoder, which Linux Chromium lacks.
+ * - `opus-webm` — Opus in WebM, the container recorded takes already use.
+ * - `wav` — 16-bit PCM, always available, written by a streaming writer.
+ *
+ * Callers append blocks at their own sample rate. When the codec cannot encode
+ * that rate (WebCodecs AAC takes only 44.1/48 kHz; TTS commonly emits 24 kHz)
+ * the encoder resamples in-stream with a band-limited converter. Input is
+ * consumed in short slices, so appending even a whole document's buffer never
+ * allocates another copy of it; lossy output accumulates as encoded bytes only.
+ *
+ * The lossy path (mediabunny) sits behind a dynamic import, so WAV-only
+ * callers and the rest of the `/encoder` entry never load it.
+ */
+
+/**
+ * Formats this runtime can encode. `'wav'` is always included; `'m4a'` needs a
+ * WebCodecs AAC encoder (absent on Linux Chromium) and `'opus-webm'` an Opus
+ * one. Ordered m4a, opus-webm, wav.
+ */
+declare function supportedAudioFileFormats(): Promise<readonly AudioFileFormat[]>;
+/**
+ * Create a streaming encoder for one audio file. Rejects when the runtime
+ * cannot encode the requested format (probe with
+ * {@link supportedAudioFileFormats} first); it never silently switches format.
+ */
+declare function createAudioFileEncoder(options: AudioFileEncoderOptions): Promise<AudioFileEncoder>;
+
+/**
+ * documentAudio — the doc → mixed `AudioBuffer` path shared by MP4 export and
+ * hosts that export a document's audio on its own.
+ *
+ * One pipeline, three steps, so the two consumers cannot drift:
+ *
+ *  1. {@link documentAudioTimeline} schedules every clip the doc plays —
+ *     `doc.audio.segments`, `documentMedia` and `block.media` (including the
+ *     audio of scheduled video) — via `computeAudioTimeline`, substituting
+ *     media-edit renders through `processedAudio` exactly as video export does.
+ *  2. {@link loadAudioTimelineSources} reads each unique source once.
+ *  3. {@link mixAudioTimeline} renders the mix with `renderAudioTimeline`
+ *     (OfflineAudioContext), at least as long as the doc's timeline.
+ *
+ * {@link renderDocumentAudio} composes the three for hosts.
+ */
+
+interface RenderDocumentAudioOptions {
+    /** Read a media file referenced by the doc (relative src), or null if missing. */
+    readMedia(src: string): Promise<ArrayBuffer | null>;
+    /** Mix sample rate (default 48000). */
+    readonly sampleRate?: number;
+    readonly signal?: AbortSignal;
+    /**
+     * Media-edit render lookup (`fx` recipes), as `VideoExportConfig.processedAudio`:
+     * an edited clip mixes its processed render instead of its source. Hosts
+     * typically pass `createMediaEditRenderManager(...).processedAudio` after
+     * awaiting pending renders. Omitted → original audio everywhere.
+     */
+    readonly processedAudio?: MediaScheduleOptions['processedAudio'];
+    /**
+     * What to do when `readMedia` returns null for a scheduled source.
+     * `'error'` (default) rejects, naming the missing files; `'skip'` mixes
+     * whatever could be read.
+     */
+    readonly missingMedia?: 'error' | 'skip';
+}
+/**
+ * Mix every audio clip the doc schedules (`doc.audio.segments`,
+ * `documentMedia`, `block.media`) on the doc's timeline, honoring media-edit
+ * renders the same way video export does. The result spans the doc's duration
+ * (or the last clip's end, if later). Null when the doc has no audio.
+ *
+ * Pass the same prepared doc video export would get — narration timing and
+ * audio mapping already resolved (`resolveAudioMapping`).
+ */
+declare function renderDocumentAudio(doc: Doc, options: RenderDocumentAudioOptions): Promise<AudioBuffer | null>;
 
-export { supportsWebCodecsAac };
+export { type AudioFileEncoder, type AudioFileEncoderOptions, type AudioFileFormat, type RenderDocumentAudioOptions, createAudioFileEncoder, renderAudioTimeline, renderDocumentAudio, supportedAudioFileFormats, supportsWebCodecsAac };

package/dist/encoder/index.js

@@ -1,12 +1,23 @@
+import {
+  createAudioFileEncoder,
+  supportedAudioFileFormats
+} from "../chunk-FMQI6WK2.js";
+import "../chunk-2W6JQSIY.js";
 import {
   createEncoder,
+  renderAudioTimeline,
+  renderDocumentAudio,
   supportsWebCodecs,
   supportsWebCodecsAac,
   supportsWebCodecsH264
-} from "../chunk-GBIYYDMY.js";
+} from "../chunk-ISYJJJXN.js";
 import "../chunk-5MFQMJ5Z.js";
 export {
+  createAudioFileEncoder,
   createEncoder,
+  renderAudioTimeline,
+  renderDocumentAudio,
+  supportedAudioFileFormats,
   supportsWebCodecs,
   supportsWebCodecsAac,
   supportsWebCodecsH264

package/dist/hooks/index.js

@@ -3,12 +3,12 @@ import {
   resolveVideoCoverFramePlan,
   resolveVideoExportCover,
   useVideoExport
-} from "../chunk-MI4EJXTD.js";
+} from "../chunk-47ODXCBA.js";
 import {
   useFrameCapture
-} from "../chunk-QJWEZRZS.js";
-import "../chunk-4GFZ3GUE.js";
-import "../chunk-GBIYYDMY.js";
+} from "../chunk-A52VG7RA.js";
+import "../chunk-C7NEHV5X.js";
+import "../chunk-ISYJJJXN.js";
 import "../chunk-5MFQMJ5Z.js";
 export {
   DEFAULT_VIDEO_COVER_PRE_ROLL_SECONDS,

package/dist/index.d.ts

@@ -3,8 +3,8 @@ export { CoverImageExportFormat, CoverImageExportModal, CoverImageExportModalPro
 export { D as DEFAULT_VIDEO_COVER_PRE_ROLL_SECONDS, R as ResolvedVideoExportCover, U as UseVideoExportOptions, V as VideoAudioPolicy, a as VideoCoverFramePlan, b as VideoExportConfig, c as VideoExportFramePreview, d as VideoExportResult, e as VideoExportState, f as VideoOutputFormat, r as resolveVideoCoverFramePlan, g as resolveVideoExportCover, u as useVideoExport } from './useVideoExport-DsNDpjmO.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-BVCLjlfj.js';
-export { FfmpegWasmLoadConfig } from '@bendyline/squisq-video';
-export { supportsWebCodecsAac } from './encoder/index.js';
+export { AudioTimelineClip, FfmpegWasmLoadConfig } from '@bendyline/squisq-video';
+export { AudioFileEncoder, AudioFileEncoderOptions, AudioFileFormat, RenderDocumentAudioOptions, createAudioFileEncoder, renderAudioTimeline, renderDocumentAudio, supportedAudioFileFormats, supportsWebCodecsAac } from './encoder/index.js';
 export { M as MediaEditJobOptions, a as MediaEditPausesRequest, b as MediaEditPausesResult, c as MediaEditPreviewRequest, d as MediaEditPreviewResult, e as MediaEditRenderManager, f as MediaEditRenderManagerOptions, g as MediaEditRenderRequest, h as MediaEditRenderResult, i as MediaEditRenderState, j as MediaEditRenderStatus, k as MediaEditRenderer, l as MediaEditRendererOptions, m as createMediaEditRenderManager, n as createMediaEditRenderer } from './mediaEditRenderManager-W_o6RRhT.js';
 export { MediaEditRendersView, useMediaEditRenders, useMediaEditStatus, useProcessedAudio } from './media-edit/index.js';
 import 'react/jsx-runtime';

package/dist/index.js

@@ -1,36 +1,43 @@
 import {
   VideoExportButton,
   VideoExportModal
-} from "./chunk-A6ED7EVY.js";
+} from "./chunk-TUZLVOSP.js";
 import {
   CoverImageExportModal,
   coverImageFilename,
   validateCoverImageDimensions
-} from "./chunk-KJQVUVOG.js";
+} from "./chunk-JDIMPME5.js";
 import "./chunk-3NJDHK62.js";
 import {
   DEFAULT_VIDEO_COVER_PRE_ROLL_SECONDS,
   resolveVideoCoverFramePlan,
   resolveVideoExportCover,
   useVideoExport
-} from "./chunk-MI4EJXTD.js";
+} from "./chunk-47ODXCBA.js";
 import {
   useFrameCapture
-} from "./chunk-QJWEZRZS.js";
-import "./chunk-4GFZ3GUE.js";
+} from "./chunk-A52VG7RA.js";
+import "./chunk-C7NEHV5X.js";
+import {
+  createAudioFileEncoder,
+  supportedAudioFileFormats
+} from "./chunk-FMQI6WK2.js";
+import "./chunk-2W6JQSIY.js";
 import {
   createEncoder,
+  renderAudioTimeline,
+  renderDocumentAudio,
   supportsWebCodecs,
   supportsWebCodecsAac,
   supportsWebCodecsH264
-} from "./chunk-GBIYYDMY.js";
+} from "./chunk-ISYJJJXN.js";
 import {
   createMediaEditRenderManager,
   createMediaEditRenderer,
   useMediaEditRenders,
   useMediaEditStatus,
   useProcessedAudio
-} from "./chunk-JKWCZION.js";
+} from "./chunk-OLFWEKY5.js";
 import "./chunk-TL2IMDIZ.js";
 import "./chunk-5MFQMJ5Z.js";
 export {
@@ -39,11 +46,15 @@ export {
   VideoExportButton,
   VideoExportModal,
   coverImageFilename,
+  createAudioFileEncoder,
   createEncoder,
   createMediaEditRenderManager,
   createMediaEditRenderer,
+  renderAudioTimeline,
+  renderDocumentAudio,
   resolveVideoCoverFramePlan,
   resolveVideoExportCover,
+  supportedAudioFileFormats,
   supportsWebCodecs,
   supportsWebCodecsAac,
   supportsWebCodecsH264,