@bendyline/squisq-video-react 2.4.11 → 2.4.12

package/dist/chunk-SLLH2RTX.js

@@ -0,0 +1,452 @@
+import {
+  createRnnoiseDenoiserFactory
+} from "./chunk-TL2IMDIZ.js";
+
+// src/mediaEdit/mediaEditRenderer.ts
+var inlineDenoiser = createRnnoiseDenoiserFactory(
+  () => import("@shiguredo/rnnoise-wasm").then(({ Rnnoise }) => Rnnoise.load())
+);
+async function inlineEngine() {
+  return import("./mediaEditEngine-ZLG7D3TB.js");
+}
+function inlineOptions(options) {
+  return { ...options, denoiser: options.denoiser ?? inlineDenoiser };
+}
+function defaultWorker() {
+  return new Worker(new URL("./workers/mediaEdit.worker.js", import.meta.url), { type: "module" });
+}
+function abortError() {
+  return new DOMException("The media-edit job was cancelled.", "AbortError");
+}
+function createMediaEditRenderer(options = {}) {
+  let worker;
+  let nextId = 1;
+  const pending = /* @__PURE__ */ new Map();
+  const failAll = (reason) => {
+    for (const job of pending.values()) job.reject(reason);
+    pending.clear();
+  };
+  const ensureWorker = () => {
+    if (worker !== void 0) return worker;
+    try {
+      worker = (options.createWorker ?? defaultWorker)();
+    } catch {
+      worker = null;
+    }
+    if (worker) {
+      worker.onmessage = (event) => {
+        const msg = event.data;
+        const job = pending.get(msg.id);
+        if (!job) return;
+        if (msg.type === "progress") {
+          job.onProgress?.(msg.fraction);
+          return;
+        }
+        pending.delete(msg.id);
+        if (msg.type === "error") job.reject(msg.aborted ? abortError() : new Error(msg.message));
+        else job.resolve(msg.result);
+      };
+      worker.onerror = (event) => {
+        event.preventDefault();
+        worker?.terminate();
+        worker = null;
+        const orphans = [...pending.values()];
+        pending.clear();
+        for (const job of orphans) job.inline().then(job.resolve, job.reject);
+      };
+    }
+    return worker;
+  };
+  function dispatch(request, jobOptions, inline) {
+    const target = ensureWorker();
+    if (!target) return inline();
+    return new Promise((resolve, reject) => {
+      if (jobOptions.signal?.aborted) {
+        reject(abortError());
+        return;
+      }
+      pending.set(request.id, {
+        resolve,
+        reject,
+        onProgress: jobOptions.onProgress,
+        inline
+      });
+      jobOptions.signal?.addEventListener(
+        "abort",
+        () => target.postMessage({ type: "cancel", id: request.id }),
+        { once: true }
+      );
+      target.postMessage(request);
+    });
+  }
+  return {
+    render(request, jobOptions = {}) {
+      return dispatch(
+        { ...request, type: "render", id: nextId++ },
+        jobOptions,
+        async () => (await inlineEngine()).renderMediaEditAudio(request, inlineOptions(jobOptions))
+      );
+    },
+    analyze(request, jobOptions = {}) {
+      return dispatch(
+        { ...request, type: "analyze", id: nextId++ },
+        jobOptions,
+        async () => (await inlineEngine()).analyzeMediaEditAudio(request, inlineOptions(jobOptions))
+      );
+    },
+    preview(request, jobOptions = {}) {
+      return dispatch(
+        { ...request, type: "preview", id: nextId++ },
+        jobOptions,
+        async () => (await inlineEngine()).previewMediaEditAudio(request, inlineOptions(jobOptions))
+      );
+    },
+    pauses(request, jobOptions = {}) {
+      return dispatch(
+        { ...request, type: "pauses", id: nextId++ },
+        jobOptions,
+        async () => (await inlineEngine()).analyzeMediaEditPauses(request, jobOptions)
+      );
+    },
+    dispose() {
+      failAll(abortError());
+      worker?.terminate();
+      worker = null;
+    }
+  };
+}
+
+// src/mediaEdit/mediaEditRenderManager.ts
+import {
+  MEDIA_FX_ORDER,
+  MEDIA_RENDER_MANIFEST_VERSION,
+  buildMediaRenderIndex,
+  collectDocMediaClips,
+  mediaClipRenderKey,
+  mediaRenderFilePath,
+  mediaRenderManifestPath,
+  mediaRenderStaleness,
+  parseMediaRenderManifest,
+  referencedMediaRenderKeys,
+  selectMediaRendersForGc,
+  serializeMediaFx,
+  serializeMediaRenderManifest
+} from "@bendyline/squisq/mediaEdit";
+function sourceSizeOf(sizes, src) {
+  const direct = sizes.get(src);
+  if (direct != null) return direct;
+  for (const [name, size] of sizes) if (name.endsWith(`/${src}`)) return size;
+  return null;
+}
+function createMediaEditRenderManager(options) {
+  const provider = options.mediaProvider;
+  const ownsRenderer = !options.renderer;
+  const renderer = options.renderer ?? createMediaEditRenderer();
+  const fetchImpl = options.fetch ?? ((input, init) => fetch(input, init));
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  let index = /* @__PURE__ */ new Map();
+  let sourceSizes = /* @__PURE__ */ new Map();
+  const manifests = /* @__PURE__ */ new Map();
+  const staleKeys = /* @__PURE__ */ new Set();
+  const statuses = /* @__PURE__ */ new Map();
+  const queue = [];
+  const listeners = /* @__PURE__ */ new Set();
+  let version = 0;
+  let indexVersion = 0;
+  let indexLoad = null;
+  let running = null;
+  let disposed = false;
+  let latestDoc = null;
+  let lastExtras = [];
+  const indexSignature = () => [...index].filter(([key]) => !staleKeys.has(key)).map(([key, entry]) => `${key}=${entry.path}`).sort().join("|");
+  const notify = () => {
+    version++;
+    for (const listener of listeners) listener();
+  };
+  const loadText = async (path) => {
+    try {
+      const url = await provider.resolveUrl(path);
+      const response = await fetchImpl(url);
+      return response.ok ? await response.text() : null;
+    } catch {
+      return null;
+    }
+  };
+  const manifestFor = async (key) => {
+    if (manifests.has(key)) return manifests.get(key) ?? null;
+    const entry = index.get(key);
+    const manifest = entry?.manifestPath ? parseMediaRenderManifest(await loadText(entry.manifestPath) ?? "") : null;
+    manifests.set(key, manifest);
+    return manifest;
+  };
+  const refreshIndex = async () => {
+    const entries = await provider.listMedia();
+    const before = indexSignature();
+    index = buildMediaRenderIndex(entries);
+    sourceSizes = new Map(entries.map((e) => [e.name, e.size]));
+    staleKeys.clear();
+    for (const [key] of index) {
+      const manifest = await manifestFor(key);
+      if (!manifest) continue;
+      const staleness = mediaRenderStaleness(manifest, {
+        sourceSize: sourceSizeOf(sourceSizes, manifest.src),
+        knownOps: MEDIA_FX_ORDER
+      });
+      if (staleness) staleKeys.add(key);
+    }
+    if (indexSignature() !== before) indexVersion++;
+    notify();
+  };
+  const ensureIndex = () => {
+    indexLoad ?? (indexLoad = refreshIndex().catch(() => {
+      indexLoad = null;
+    }));
+    return indexLoad;
+  };
+  const isCurrent = (key) => index.has(key) && !staleKeys.has(key);
+  const pump = async () => {
+    if (running || disposed) return;
+    const job = queue.shift();
+    if (!job) return;
+    const controller = new AbortController();
+    running = { key: job.key, controller };
+    statuses.set(job.key, { key: job.key, state: "rendering", progress: 0 });
+    notify();
+    let lastReported = 0;
+    try {
+      const source = await loadSource(job.clip.src);
+      const result = await renderer.render(
+        { source, fx: job.fx },
+        {
+          signal: controller.signal,
+          onProgress: (fraction) => {
+            if (fraction - lastReported < 0.01 && fraction < 1) return;
+            lastReported = fraction;
+            statuses.set(job.key, { key: job.key, state: "rendering", progress: fraction });
+            notify();
+          }
+        }
+      );
+      const renderPath = await provider.addMedia(
+        mediaRenderFilePath(job.clip.src, job.key, result.extension),
+        result.bytes,
+        result.mimeType
+      );
+      const manifest = {
+        version: MEDIA_RENDER_MANIFEST_VERSION,
+        src: job.clip.src,
+        key: job.key,
+        fx: job.fx,
+        ignoredOps: result.ignoredOps,
+        file: renderPath,
+        mimeType: result.mimeType,
+        sourceSize: source.size,
+        sourceDuration: result.sourceDuration,
+        engine: result.engine,
+        createdAt: now().toISOString(),
+        analysis: {
+          ...result.analysis.integratedLufs != null ? { integratedLufs: result.analysis.integratedLufs } : {},
+          appliedGainDb: result.analysis.loudnessGainDb,
+          breathCount: result.analysis.breaths.length
+        }
+      };
+      const manifestPath = await provider.addMedia(
+        mediaRenderManifestPath(job.clip.src, job.key),
+        new TextEncoder().encode(serializeMediaRenderManifest(manifest)),
+        "application/json"
+      );
+      index.set(job.key, {
+        key: job.key,
+        path: renderPath,
+        manifestPath,
+        size: result.bytes.byteLength
+      });
+      manifests.set(job.key, manifest);
+      staleKeys.delete(job.key);
+      indexVersion++;
+      statuses.set(job.key, { key: job.key, state: "ready" });
+    } catch (err) {
+      const aborted = err instanceof DOMException && err.name === "AbortError";
+      if (aborted) statuses.delete(job.key);
+      else {
+        statuses.set(job.key, {
+          key: job.key,
+          state: "failed",
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    } finally {
+      running = null;
+      notify();
+      void pump();
+    }
+  };
+  const enqueue = (clip, force) => {
+    const key = mediaClipRenderKey(clip);
+    const fx = clip.edits?.fx;
+    if (!key || !fx) return;
+    if (!force && (isCurrent(key) || statuses.get(key)?.state === "failed")) return;
+    if (running?.key === key || queue.some((job) => job.key === key)) return;
+    queue.push({ key, clip, fx: serializeMediaFx({ ops: fx.ops, unknown: [] }) });
+    statuses.set(key, { key, state: "queued" });
+  };
+  async function loadSource(src) {
+    const url = await provider.resolveUrl(src);
+    const response = await fetchImpl(url);
+    if (!response.ok) throw new Error(`Could not read ${src} (${response.status}).`);
+    return response.blob();
+  }
+  const requiredKeys = (doc) => {
+    const keys = referencedMediaRenderKeys(doc);
+    for (const clip of lastExtras) {
+      const key = mediaClipRenderKey(clip);
+      if (key) keys.add(key);
+    }
+    return keys;
+  };
+  const manager = {
+    renderer,
+    sync(doc, extraClips) {
+      latestDoc = doc;
+      const extras = extraClips ?? lastExtras;
+      lastExtras = extras;
+      void ensureIndex().then(() => {
+        if (disposed || latestDoc !== doc) return;
+        const clips = [...collectDocMediaClips(doc), ...extras];
+        const wanted = new Set(
+          clips.map((clip) => mediaClipRenderKey(clip)).filter((key) => key != null)
+        );
+        for (let i = queue.length - 1; i >= 0; i--) {
+          if (!wanted.has(queue[i].key)) {
+            statuses.delete(queue[i].key);
+            queue.splice(i, 1);
+          }
+        }
+        for (const clip of clips) enqueue(clip, false);
+        notify();
+        void pump();
+      });
+    },
+    processedAudio(clip) {
+      const key = mediaClipRenderKey(clip);
+      return key && isCurrent(key) ? index.get(key)?.path : void 0;
+    },
+    status(clip) {
+      const key = mediaClipRenderKey(clip);
+      if (!key) return null;
+      if (isCurrent(key)) return statuses.get(key) ?? { key, state: "ready" };
+      return statuses.get(key) ?? { key, state: "queued" };
+    },
+    whenReady(doc, signal) {
+      manager.sync(doc);
+      return new Promise((resolve, reject) => {
+        const check = () => {
+          if (signal?.aborted) {
+            unsubscribe();
+            reject(new DOMException("Waiting for renders was cancelled.", "AbortError"));
+            return;
+          }
+          const pending = [...requiredKeys(doc)].some((key) => {
+            if (isCurrent(key)) return false;
+            return statuses.get(key)?.state !== "failed";
+          });
+          if (!pending && indexLoad) {
+            unsubscribe();
+            resolve();
+          }
+        };
+        const unsubscribe = manager.subscribe(check);
+        signal?.addEventListener("abort", check, { once: true });
+        void ensureIndex().then(check);
+      });
+    },
+    retry(clip) {
+      const key = mediaClipRenderKey(clip);
+      if (!key) return;
+      statuses.delete(key);
+      enqueue(clip, true);
+      notify();
+      void pump();
+    },
+    loadSource,
+    async collectGarbage(doc, at = now()) {
+      await refreshIndex();
+      const docSources = new Set(
+        [...collectDocMediaClips(doc), ...lastExtras].map((clip) => clip.src)
+      );
+      const busy = /* @__PURE__ */ new Set([...queue.map((job) => job.key), ...running ? [running.key] : []]);
+      const candidates = /* @__PURE__ */ new Map();
+      const loaded = /* @__PURE__ */ new Map();
+      for (const [key, entry] of index) {
+        const manifest = await manifestFor(key);
+        if (!manifest || !docSources.has(manifest.src) || busy.has(key)) continue;
+        candidates.set(key, entry);
+        loaded.set(key, manifest);
+      }
+      const paths = selectMediaRendersForGc(candidates, requiredKeys(doc), loaded, at);
+      for (const path of paths) await provider.removeMedia(path);
+      if (paths.length > 0) {
+        for (const key of candidates.keys()) {
+          const entry = index.get(key);
+          if (entry && paths.includes(entry.path)) {
+            index.delete(key);
+            manifests.delete(key);
+          }
+        }
+        indexVersion++;
+        notify();
+      }
+      return paths;
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    getVersion: () => version,
+    getIndexVersion: () => indexVersion,
+    dispose() {
+      disposed = true;
+      queue.length = 0;
+      running?.controller.abort();
+      listeners.clear();
+      if (ownsRenderer) renderer.dispose();
+    }
+  };
+  return manager;
+}
+
+// src/mediaEdit/useMediaEditRenders.ts
+import { useCallback, useEffect, useSyncExternalStore } from "react";
+var noSubscribe = () => () => {
+};
+var zero = () => 0;
+function useProcessedAudio(manager) {
+  const indexVersion = useSyncExternalStore(
+    manager ? manager.subscribe : noSubscribe,
+    manager ? manager.getIndexVersion : zero,
+    zero
+  );
+  return useCallback((clip) => manager?.processedAudio(clip), [manager, indexVersion]);
+}
+function useMediaEditStatus(manager) {
+  const version = useSyncExternalStore(
+    manager ? manager.subscribe : noSubscribe,
+    manager ? manager.getVersion : zero,
+    zero
+  );
+  return useCallback((clip) => manager?.status(clip) ?? null, [manager, version]);
+}
+function useMediaEditRenders(manager, doc) {
+  useEffect(() => {
+    if (manager && doc) manager.sync(doc);
+  }, [manager, doc]);
+  return { processedAudio: useProcessedAudio(manager), status: useMediaEditStatus(manager) };
+}
+
+export {
+  createMediaEditRenderer,
+  createMediaEditRenderManager,
+  useProcessedAudio,
+  useMediaEditStatus,
+  useMediaEditRenders
+};

package/dist/chunk-TL2IMDIZ.js

@@ -0,0 +1,27 @@
+// src/mediaEdit/rnnoiseDenoiser.ts
+var RNNOISE_SAMPLE_RATE = 48e3;
+var RNNOISE_LATENCY = 960;
+var PCM16_SCALE = 32768;
+function createRnnoiseDenoiserFactory(load) {
+  let loading = null;
+  return async () => {
+    loading ?? (loading = load());
+    const rnnoise = await loading;
+    const state = rnnoise.createDenoiseState();
+    return {
+      frameSize: rnnoise.frameSize,
+      sampleRate: RNNOISE_SAMPLE_RATE,
+      latency: RNNOISE_LATENCY,
+      processFrame(frame) {
+        for (let i = 0; i < frame.length; i++) frame[i] *= PCM16_SCALE;
+        state.processFrame(frame);
+        for (let i = 0; i < frame.length; i++) frame[i] /= PCM16_SCALE;
+      },
+      dispose: () => state.destroy()
+    };
+  };
+}
+
+export {
+  createRnnoiseDenoiserFactory
+};

package/dist/components/index.d.ts

@@ -1,7 +1,9 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { Doc, MediaProvider } from '@bendyline/squisq/schemas';
-import { b as VideoExportConfig, f as VideoOutputFormat } from '../useVideoExport-B2eVCvTX.js';
+import { e as MediaEditRenderManager } from '../mediaEditRenderManager-W_o6RRhT.js';
+import { b as VideoExportConfig, f as VideoOutputFormat } from '../useVideoExport-DsNDpjmO.js';
 export { CoverImageExportFormat, CoverImageExportModal, CoverImageExportModalProps, coverImageFilename, validateCoverImageDimensions } from '../cover-image/index.js';
+import '@bendyline/squisq/mediaEdit';
 import '@bendyline/squisq/markdown';
 import '@bendyline/squisq/doc';
 import '@bendyline/squisq-video';
@@ -24,6 +26,11 @@ interface VideoExportModalProps {
     images?: Map<string, ArrayBuffer>;
     /** Pre-collected audio map */
     audio?: Map<string, ArrayBuffer>;
+    /**
+     * Processed-audio renders for media-edit recipes. Export waits for pending
+     * renders, then mixes each edited clip's render instead of its original.
+     */
+    mediaEditRenders?: MediaEditRenderManager | null;
     /**
      * Seeds the modal's initial format, motion, quality, FPS, orientation, and
      * caption selections. It is merged (as a base) into the config passed to the
@@ -59,7 +66,7 @@ interface VideoExportPalette {
     success: string;
     danger: string;
 }
-declare function VideoExportModal({ doc, playerScript, mediaProvider, images, audio, defaultConfig, colorScheme, uiPalette, saveOutput, saveActionLabel, onClose, }: VideoExportModalProps): react_jsx_runtime.JSX.Element;
+declare function VideoExportModal({ doc, playerScript, mediaProvider, images, audio, mediaEditRenders, defaultConfig, colorScheme, uiPalette, saveOutput, saveActionLabel, onClose, }: VideoExportModalProps): react_jsx_runtime.JSX.Element;
 
 interface VideoExportButtonProps {
     /** The document to export */

package/dist/components/index.js

@@ -1,16 +1,17 @@
 import {
   VideoExportButton,
   VideoExportModal
-} from "../chunk-JGSJQZGU.js";
+} from "../chunk-BNUM3BXO.js";
 import {
   CoverImageExportModal,
   coverImageFilename,
   validateCoverImageDimensions
-} from "../chunk-BRE3IRIM.js";
+} from "../chunk-3EJKBFEK.js";
 import "../chunk-3NJDHK62.js";
-import "../chunk-BGS2NEYC.js";
-import "../chunk-4NI2QIFE.js";
-import "../chunk-32QCPFXE.js";
+import "../chunk-ED7QK6VC.js";
+import "../chunk-7ZMJ25DC.js";
+import "../chunk-4GFZ3GUE.js";
+import "../chunk-GBIYYDMY.js";
 import "../chunk-5MFQMJ5Z.js";
 export {
   CoverImageExportModal,

package/dist/cover-image/index.js

@@ -2,9 +2,10 @@ import {
   CoverImageExportModal,
   coverImageFilename,
   validateCoverImageDimensions
-} from "../chunk-BRE3IRIM.js";
+} from "../chunk-3EJKBFEK.js";
 import "../chunk-3NJDHK62.js";
-import "../chunk-4NI2QIFE.js";
+import "../chunk-7ZMJ25DC.js";
+import "../chunk-4GFZ3GUE.js";
 export {
   CoverImageExportModal,
   coverImageFilename,

package/dist/dashboard-image/index.js

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

package/dist/encoder/index.js

@@ -3,7 +3,7 @@ import {
   supportsWebCodecs,
   supportsWebCodecsAac,
   supportsWebCodecsH264
-} from "../chunk-32QCPFXE.js";
+} from "../chunk-GBIYYDMY.js";
 import "../chunk-5MFQMJ5Z.js";
 export {
   createEncoder,

package/dist/hooks/index.d.ts

@@ -1,4 +1,4 @@
-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-B2eVCvTX.js';
+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';
 import * as _bendyline_squisq_doc from '@bendyline/squisq/doc';
 import { Doc, MediaProvider } from '@bendyline/squisq/schemas';
 import { RenderHtmlOptions } from '@bendyline/squisq-video';

package/dist/hooks/index.js

@@ -3,11 +3,12 @@ import {
   resolveVideoCoverFramePlan,
   resolveVideoExportCover,
   useVideoExport
-} from "../chunk-BGS2NEYC.js";
+} from "../chunk-ED7QK6VC.js";
 import {
   useFrameCapture
-} from "../chunk-4NI2QIFE.js";
-import "../chunk-32QCPFXE.js";
+} from "../chunk-7ZMJ25DC.js";
+import "../chunk-4GFZ3GUE.js";
+import "../chunk-GBIYYDMY.js";
 import "../chunk-5MFQMJ5Z.js";
 export {
   DEFAULT_VIDEO_COVER_PRE_ROLL_SECONDS,

package/dist/index.d.ts

@@ -1,13 +1,16 @@
 export { VideoExportButton, VideoExportButtonProps, VideoExportModal, VideoExportModalProps, VideoExportPalette } from './components/index.js';
 export { CoverImageExportFormat, CoverImageExportModal, CoverImageExportModalProps, coverImageFilename, validateCoverImageDimensions } from './cover-image/index.js';
-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-B2eVCvTX.js';
+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 { 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';
 import '@bendyline/squisq/schemas';
 import '@bendyline/squisq/doc';
 import './imageExportShared-B6nqWtE-.js';
 import '@bendyline/squisq/markdown';
 import '@bendyline/squisq-react';
+import '@bendyline/squisq/mediaEdit';

package/dist/index.js

@@ -1,28 +1,37 @@
 import {
   VideoExportButton,
   VideoExportModal
-} from "./chunk-JGSJQZGU.js";
+} from "./chunk-BNUM3BXO.js";
 import {
   CoverImageExportModal,
   coverImageFilename,
   validateCoverImageDimensions
-} from "./chunk-BRE3IRIM.js";
+} from "./chunk-3EJKBFEK.js";
 import "./chunk-3NJDHK62.js";
 import {
   DEFAULT_VIDEO_COVER_PRE_ROLL_SECONDS,
   resolveVideoCoverFramePlan,
   resolveVideoExportCover,
   useVideoExport
-} from "./chunk-BGS2NEYC.js";
+} from "./chunk-ED7QK6VC.js";
 import {
   useFrameCapture
-} from "./chunk-4NI2QIFE.js";
+} from "./chunk-7ZMJ25DC.js";
+import "./chunk-4GFZ3GUE.js";
 import {
   createEncoder,
   supportsWebCodecs,
   supportsWebCodecsAac,
   supportsWebCodecsH264
-} from "./chunk-32QCPFXE.js";
+} from "./chunk-GBIYYDMY.js";
+import {
+  createMediaEditRenderManager,
+  createMediaEditRenderer,
+  useMediaEditRenders,
+  useMediaEditStatus,
+  useProcessedAudio
+} from "./chunk-SLLH2RTX.js";
+import "./chunk-TL2IMDIZ.js";
 import "./chunk-5MFQMJ5Z.js";
 export {
   CoverImageExportModal,
@@ -31,12 +40,17 @@ export {
   VideoExportModal,
   coverImageFilename,
   createEncoder,
+  createMediaEditRenderManager,
+  createMediaEditRenderer,
   resolveVideoCoverFramePlan,
   resolveVideoExportCover,
   supportsWebCodecs,
   supportsWebCodecsAac,
   supportsWebCodecsH264,
   useFrameCapture,
+  useMediaEditRenders,
+  useMediaEditStatus,
+  useProcessedAudio,
   useVideoExport,
   validateCoverImageDimensions
 };