@motionscript/browser 0.1.0-alpha.0 → 0.1.0-alpha.10

package/dist/exporter.d.ts

@@ -1,5 +1,9 @@
-import { Registry, type AssetManifest, type ProjectDocument, type SceneDocument, type Size2D } from "@motionscript/core";
-import { type Quality } from 'mediabunny';
+import { ManifestAssetCatalog, Registry, type AssetManifest, type FrameRange, type ProjectDocument, type RenderIssue, type VisualDocument, type Size2D, type StorageAdapter, type Theme } from "@motionscript/core";
+import { type VideoFrameSink } from "./frame-loop";
+import { type Quality, type VideoCodec } from 'mediabunny';
+import type { BrowserRenderContext } from "./engine";
+import { type RendererWasmOption } from "./renderer";
+import { type VideoFormat } from "./formats";
 /** Reports export progress in [0, 1]; video encoding occupies most of the range, audio mixing/finalize the tail. */
 export type ExportProgressCallback = (progress: number) => void;
 /**
@@ -10,17 +14,19 @@ export type ExportProgressCallback = (progress: number) => void;
  */
 export type VideoEncoderOptions = {
     /**
-     * Which codec the video track is encoded with. Defaults to `'avc'` (H.264),
-     * which every player, editor and upload target accepts.
+     * Which codec the video track is encoded with. Defaults to the format's own:
+     * `'avc'` (H.264) for MP4, which every player, editor and upload target
+     * accepts, and `'vp9'` for WebM.
      *
      * `'hevc'` and `'av1'` reconstruct sharp edges far better at the same
      * bitrate, which is what a listing of syntax-highlighted code or a hairline
      * stroke is made of — worth reaching for when the file is going somewhere
      * that decodes them. Both are still 4:2:0, so they narrow the gap rather
      * than close it. Availability depends on the platform's encoders; an
-     * unsupported choice falls back to `'avc'` rather than failing the export.
+     * unsupported choice, or one the container cannot hold (`'avc'` in WebM),
+     * falls back to the format's default rather than failing the export.
      */
-    codec?: 'avc' | 'hevc' | 'av1' | 'vp9';
+    codec?: 'avc' | 'hevc' | 'av1' | 'vp9' | 'vp8';
     /**
      * Which encoder implementation WebCodecs should prefer.
      *
@@ -88,24 +94,29 @@ export type VideoEncoderOptions = {
 export declare function motionGraphicsBitrate(width: number, height: number, fps: number): number;
 /** How the mixed audio track is encoded. */
 export type AudioEncoderOptions = {
-    /** AAC bitrate in bits per second. Defaults to 192 kbps. */
+    /** Bitrate in bits per second for AAC, Opus and MP3; WAV ignores it. Defaults to 192 kbps. */
     bitrate?: number;
-    /** Mixdown sample rate in Hz. Defaults to the mixer's own (44100). */
+    /** Mixdown sample rate in Hz. Defaults to the mixer's own (44100); Opus is resampled to 48 kHz. */
     sampleRate?: number;
 };
-export type ExportParams = {
+export type ExportParams = RendererWasmOption & {
     /** A project, or a lone still or composition as the one track of one. */
-    document: ProjectDocument | SceneDocument;
+    document: ProjectDocument | VisualDocument;
     /** The vocabulary its clips compile against. Defaults to what the library ships. */
     registry?: Registry;
     /** Win over the document's own; 1920×1080 at 60 fps when neither says. */
     viewport?: Size2D;
     fps?: number;
     scale?: number;
+    /** The container, and with it the default codecs: H.264 and AAC for `'mp4'` (the default), VP9 and Opus for `'webm'`. */
+    format?: VideoFormat;
+    /** Defaults to `export.<extension>`. */
     filename?: string;
     manifest?: AssetManifest;
+    /** Theme for a document that carries none of its own. */
+    theme?: Theme;
     /**
-     * Set false to produce a silent MP4 — no AAC track is added to the
+     * Set false to produce a silent file — no audio track is added to the
      * container and the mix is skipped entirely. Defaults to true.
      */
     includeAudio?: boolean;
@@ -113,9 +124,20 @@ export type ExportParams = {
     video?: VideoEncoderOptions;
     /** Audio encoder settings; ignored when `includeAudio` is false. */
     audio?: AudioEncoderOptions;
+    /**
+     * Encode only these frames (`end` excluded), timestamped from 0 and silent:
+     * one segment of a split export, for `concatVideoSegments` to join. Mix
+     * the audio once with `mixTimelineAudio` instead.
+     */
+    frames?: FrameRange;
     onProgress?: ExportProgressCallback;
     signal?: AbortSignal;
-    wasmUrl?: string;
+    /**
+     * What the renderer drew but not as the document says, once per kind,
+     * feature and node. A lost GPU device fails the export with a
+     * `RenderBackendError` instead.
+     */
+    onIssue?: (issue: RenderIssue) => void;
     /**
      * Render each frame at this multiple of the output resolution and downsample
      * it before encoding. **Defaults to 2**; pass 1 to turn it off.
@@ -142,20 +164,117 @@ export type ExportParams = {
      */
     supersample?: number;
     /**
-     * When true, the encoded MP4 bytes are returned instead of triggering a
+     * When true, the encoded bytes are returned instead of triggering a
      * browser download. Used by headless drivers (e.g. the CLI) that capture
      * the output themselves and write it to disk; leave unset for the
      * interactive player, which downloads via an `<a>` element.
      */
     returnBytes?: boolean;
 };
+/**
+ * mediabunny/WebCodecs implementation of the frame sink, writing whichever
+ * container `format` names.
+ *
+ * Wraps the very `<canvas>` the renderer draws into, so `addFrame` costs nothing but
+ * a timestamp — WebCodecs pulls the pixels from the canvas itself, with no
+ * GPU→CPU readback. That is why the seam signals a frame rather than passing one.
+ *
+ * The readback claim holds only while the encoder is a hardware one, which is
+ * why {@link VideoEncoderOptions.hardwareAcceleration} defaults to letting the
+ * platform choose: a software encoder has to be handed CPU pixels, so it drags
+ * a full-frame copy off the GPU on every single frame.
+ */
+export declare class MediabunnyVideoSink implements VideoFrameSink<AudioBuffer> {
+    private readonly format;
+    private readonly audioOptions;
+    private readonly target;
+    private readonly output;
+    private readonly video;
+    private audio;
+    constructor(canvas: HTMLCanvasElement, 
+    /** Encoded output size, which is the canvas' own unless supersampling is on. */
+    output: {
+        width: number;
+        height: number;
+    }, format: VideoFormat, encoding: ResolvedVideoEncoding, audioOptions?: AudioEncoderOptions);
+    start(info: {
+        fps: number;
+        hasAudio: boolean;
+    }): Promise<void>;
+    addFrame(timestamp: number, duration: number): Promise<void>;
+    addAudio(mixed: AudioBuffer): Promise<void>;
+    finalize(): Promise<Uint8Array>;
+}
+/**
+ * Every encoder setting, decided. A split export pins one of these across its
+ * segments, since `concatVideoSegments` refuses parts encoded differently. With
+ * a numeric `bitrate` (see {@link plainVideoEncoding}) it is plain data and
+ * crosses a process boundary.
+ */
+export interface ResolvedVideoEncoding {
+    codec: VideoCodec;
+    /** A `Quality` is left for the encoder to size, as an export always has. */
+    bitrate: number | Quality;
+    hardwareAcceleration: NonNullable<VideoEncoderOptions['hardwareAcceleration']>;
+    keyFrameInterval: number;
+    latencyMode: NonNullable<VideoEncoderOptions['latencyMode']>;
+    contentHint: string;
+    bitrateMode?: VideoEncoderOptions['bitrateMode'];
+}
+/** {@link VideoEncoderOptions} with its defaults applied against the encoded size and rate. */
+export declare function resolveVideoEncoding(video: VideoEncoderOptions | undefined, format: VideoFormat, output: {
+    width: number;
+    height: number;
+}, fps: number): Promise<ResolvedVideoEncoding>;
+/**
+ * The encoding with a `Quality` turned into the bits per second mediabunny would
+ * give it at this size, since a class instance cannot cross a `MessagePort`.
+ */
+export declare function plainVideoEncoding(encoding: ResolvedVideoEncoding, output: {
+    width: number;
+    height: number;
+}): ResolvedVideoEncoding & {
+    bitrate: number;
+};
+/** The encoded size, rounded up to even, and how far each frame is supersampled. */
+export declare function exportGeometry(viewport: Size2D, scale: number, supersample: number): {
+    output: {
+        width: number;
+        height: number;
+    };
+    oversample: number;
+    renderScale: number;
+};
+/** A hidden canvas with a mounted render context, reusable across renders of one project. */
+export interface ExportSurface {
+    canvas: HTMLCanvasElement;
+    renderContext: BrowserRenderContext;
+    storageAdapter: StorageAdapter;
+    assetCatalog: ManifestAssetCatalog;
+    dispose(): void;
+}
+/**
+ * Open the canvas, renderer, storage and render context an export draws with,
+ * resolving once the surface can draw (a frame drawn before an asynchronously
+ * started surface is ready encodes blank). The canvas is a whole multiple of the
+ * output, so the downsample is exact.
+ */
+export declare function openExportSurface(params: {
+    canvasSize: {
+        width: number;
+        height: number;
+    };
+    viewport: Size2D;
+    fps: number;
+    manifest: AssetManifest;
+} & RendererWasmOption): Promise<ExportSurface>;
 /**
  * Renders a document frame-by-frame to an offscreen canvas and muxes the result
- * into an MP4 via mediabunny.
+ * into an MP4 or WebM via mediabunny.
  *
  * The frame loop itself — discovery, state evaluation, the warm-and-re-render retry
  * that keeps every frame accurate, audio scheduling, progress and cancellation —
- * lives in `@motionscript/skia-render`'s `renderTimeline`. What this function
+ * lives in `renderTimeline` (frame-loop.ts). What this function
  * supplies is the browser-specific half: a canvas to draw into, a WebCodecs sink,
  * a Web Audio mixer, and the `<a download>` delivery.
  */

package/dist/exporter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"exporter.d.ts","sourceRoot":"","sources":["../src/exporter.ts"],"names":[],"mappings":"AAAA,OAAO,EACmB,QAAQ,EAA0B,KAAK,aAAa,EAC1E,KAAK,eAAe,EAAE,KAAK,aAAa,EAAE,KAAK,MAAM,EACxD,MAAM,oBAAoB,CAAC;AAK5B,OAAO,EAOH,KAAK,OAAO,EAEf,MAAM,YAAY,CAAC;AAOpB,oHAAoH;AACpH,MAAM,MAAM,sBAAsB,GAAG,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;AAEhE;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAC9B;;;;;;;;;;OAUG;IACH,KAAK,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,KAAK,CAAC;IACvC;;;;;;;;;;;;;;;OAeG;IACH,oBAAoB,CAAC,EAAE,eAAe,GAAG,iBAAiB,GAAG,iBAAiB,CAAC;IAC/E;;;;;;;;;OASG;IACH,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAC3B,6FAA6F;IAC7F,WAAW,CAAC,EAAE,UAAU,GAAG,UAAU,CAAC;IACtC;;;;;;;;OAQG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;OAIG;IACH,WAAW,CAAC,EAAE,SAAS,GAAG,UAAU,CAAC;IACrC;;;;;;;OAOG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AAsBF;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAGxF;AAED,4CAA4C;AAC5C,MAAM,MAAM,mBAAmB,GAAG;IAC9B,4DAA4D;IAC5D,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,sEAAsE;IACtE,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAQF,MAAM,MAAM,YAAY,GAAG;IACvB,yEAAyE;IACzE,QAAQ,EAAE,eAAe,GAAG,aAAa,CAAC;IAC1C,oFAAoF;IACpF,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,0EAA0E;IAC1E,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,aAAa,CAAC;IACzB;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,gFAAgF;IAChF,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B,oEAAoE;IACpE,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B,UAAU,CAAC,EAAE,sBAAsB,CAAC;IACpC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;CACzB,CAAA;AAgKD;;;;;;;;;GASG;AACH,wBAAsB,WAAW,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAmFlF"}
+{"version":3,"file":"exporter.d.ts","sourceRoot":"","sources":["../src/exporter.ts"],"names":[],"mappings":"AAAA,OAAO,EACa,oBAAoB,EAAE,QAAQ,EAA0B,KAAK,aAAa,EAC1F,KAAK,UAAU,EAAE,KAAK,eAAe,EAAE,KAAK,WAAW,EAAE,KAAK,cAAc,EAAE,KAAK,MAAM,EAAE,KAAK,cAAc,EAAE,KAAK,KAAK,EAC7H,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAEH,KAAK,cAAc,EACtB,MAAM,cAAc,CAAC;AACtB,OAAO,EAMH,KAAK,OAAO,EACZ,KAAK,UAAU,EAClB,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AACrD,OAAO,EAAgB,KAAK,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAGnE,OAAO,EACsE,KAAK,WAAW,EAC5F,MAAM,WAAW,CAAC;AAEnB,oHAAoH;AACpH,MAAM,MAAM,sBAAsB,GAAG,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;AAEhE;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAC9B;;;;;;;;;;;;OAYG;IACH,KAAK,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,CAAC;IAC/C;;;;;;;;;;;;;;;OAeG;IACH,oBAAoB,CAAC,EAAE,eAAe,GAAG,iBAAiB,GAAG,iBAAiB,CAAC;IAC/E;;;;;;;;;OASG;IACH,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAC3B,6FAA6F;IAC7F,WAAW,CAAC,EAAE,UAAU,GAAG,UAAU,CAAC;IACtC;;;;;;;;OAQG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;OAIG;IACH,WAAW,CAAC,EAAE,SAAS,GAAG,UAAU,CAAC;IACrC;;;;;;;OAOG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AAsBF;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAGxF;AAED,4CAA4C;AAC5C,MAAM,MAAM,mBAAmB,GAAG;IAC9B,8FAA8F;IAC9F,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,mGAAmG;IACnG,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAOF,MAAM,MAAM,YAAY,GAAG,kBAAkB,GAAG;IAC5C,yEAAyE;IACzE,QAAQ,EAAE,eAAe,GAAG,cAAc,CAAC;IAC3C,oFAAoF;IACpF,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,0EAA0E;IAC1E,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,yHAAyH;IACzH,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,wCAAwC;IACxC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,aAAa,CAAC;IACzB,yDAAyD;IACzD,KAAK,CAAC,EAAE,KAAK,CAAC;IACd;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,gFAAgF;IAChF,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B,oEAAoE;IACpE,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B;;;;OAIG;IACH,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB,UAAU,CAAC,EAAE,sBAAsB,CAAC;IACpC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB;;;;OAIG;IACH,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC;IACvC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;CACzB,CAAA;AAgBD;;;;;;;;;;;;GAYG;AACH,qBAAa,mBAAoB,YAAW,cAAc,CAAC,WAAW,CAAC;IAU/D,OAAO,CAAC,QAAQ,CAAC,MAAM;IAEvB,OAAO,CAAC,QAAQ,CAAC,YAAY;IAXjC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsB;IAC7C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAe;IACrC,OAAO,CAAC,KAAK,CAAkC;gBAG3C,MAAM,EAAE,iBAAiB;IACzB,gFAAgF;IAChF,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,EACxB,MAAM,EAAE,WAAW,EACpC,QAAQ,EAAE,qBAAqB,EACd,YAAY,GAAE,mBAAwB;IAmBrD,KAAK,CAAC,IAAI,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAY9D,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAI5D,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAK3C,QAAQ,IAAI,OAAO,CAAC,UAAU,CAAC;CAQxC;AAmFD;;;;;GAKG;AACH,MAAM,WAAW,qBAAqB;IAClC,KAAK,EAAE,UAAU,CAAC;IAClB,4EAA4E;IAC5E,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC;IAC1B,oBAAoB,EAAE,WAAW,CAAC,mBAAmB,CAAC,sBAAsB,CAAC,CAAC,CAAC;IAC/E,gBAAgB,EAAE,MAAM,CAAC;IACzB,WAAW,EAAE,WAAW,CAAC,mBAAmB,CAAC,aAAa,CAAC,CAAC,CAAC;IAC7D,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,mBAAmB,CAAC,aAAa,CAAC,CAAC;CACpD;AAED,+FAA+F;AAC/F,wBAAsB,oBAAoB,CACtC,KAAK,EAAE,mBAAmB,GAAG,SAAS,EACtC,MAAM,EAAE,WAAW,EACnB,MAAM,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EACzC,GAAG,EAAE,MAAM,GACZ,OAAO,CAAC,qBAAqB,CAAC,CAWhC;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAC9B,QAAQ,EAAE,qBAAqB,EAC/B,MAAM,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAC1C,qBAAqB,GAAG;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,CAK7C;AAED,oFAAoF;AACpF,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM;;;;;;;EAMlF;AAED,6FAA6F;AAC7F,MAAM,WAAW,aAAa;IAC1B,MAAM,EAAE,iBAAiB,CAAC;IAC1B,aAAa,EAAE,oBAAoB,CAAC;IACpC,cAAc,EAAE,cAAc,CAAC;IAC/B,YAAY,EAAE,oBAAoB,CAAC;IACnC,OAAO,IAAI,IAAI,CAAC;CACnB;AAED;;;;;GAKG;AACH,wBAAsB,iBAAiB,CAAC,MAAM,EAAE;IAC5C,UAAU,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAC9C,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,aAAa,CAAC;CAC3B,GAAG,kBAAkB,GAAG,OAAO,CAAC,aAAa,CAAC,CAwB9C;AAED;;;;;;;;;GASG;AACH,wBAAsB,WAAW,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAqDlF"}

package/dist/exporter.js

@@ -1,11 +1,10 @@
-import { ManifestAssetCatalog, Registry, resolveProjectDocument, } from "@motionscript/core";
-import { renderTimeline, } from "@motionscript/skia-render/export";
-import { AudioBufferSource, BufferTarget, CanvasSource, canEncodeVideo, Mp4OutputFormat, Output, } from 'mediabunny';
-import { WebRenderContext } from "./render-context";
-import { WebStorageAdapter } from "./storage-adapter";
-import { getCanvasKit } from "./getter";
+import { DEFAULT_OUTPUT, ManifestAssetCatalog, Registry, resolveProjectDocument, } from "@motionscript/core";
+import { renderTimeline, } from "./frame-loop";
+import { BufferTarget, CanvasSource, canEncodeVideo, Output, } from 'mediabunny';
+import { loadRenderer } from "./renderer";
 import { WebAudioMixer } from "./audio/mixer";
-import { DEFAULT_OUTPUT } from "./output";
+import { deliver } from "./deliver";
+import { audioTrackSource, DEFAULT_AUDIO_BITRATE, ensureAudioEncoder, formatSpec, } from "./formats";
 /**
  * Bits per pixel per frame the default bitrate is built from.
  *
@@ -37,7 +36,6 @@ export function motionGraphicsBitrate(width, height, fps) {
     const raw = width * height * fps * BITS_PER_PIXEL;
     return Math.round(Math.min(MAX_VIDEO_BITRATE, Math.max(MIN_VIDEO_BITRATE, raw)));
 }
-const DEFAULT_AUDIO_BITRATE = 192_000;
 /** See {@link VideoEncoderOptions.keyFrameInterval}. */
 const DEFAULT_KEY_FRAME_INTERVAL = 1;
 /** See {@link ExportParams.supersample}. */
@@ -54,9 +52,10 @@ const EMPTY_MANIFEST = {
 // split export and a whole one cannot mix differently.
 // ── Video sink ───────────────────────────────────────────────────────────────
 /**
- * mediabunny/WebCodecs implementation of the frame sink.
+ * mediabunny/WebCodecs implementation of the frame sink, writing whichever
+ * container `format` names.
  *
- * Wraps the very `<canvas>` CanvasKit draws into, so `addFrame` costs nothing but
+ * Wraps the very `<canvas>` the renderer draws into, so `addFrame` costs nothing but
  * a timestamp — WebCodecs pulls the pixels from the canvas itself, with no
  * GPU→CPU readback. That is why the seam signals a frame rather than passing one.
  *
@@ -65,44 +64,41 @@ const EMPTY_MANIFEST = {
  * platform choose: a software encoder has to be handed CPU pixels, so it drags
  * a full-frame copy off the GPU on every single frame.
  */
-class MediabunnyVideoSink {
+export class MediabunnyVideoSink {
+    format;
     audioOptions;
     target = new BufferTarget();
     output;
     video;
     audio = null;
-    constructor(canvas, fps, 
+    constructor(canvas, 
     /** Encoded output size, which is the canvas' own unless supersampling is on. */
-    output, video = {}, audioOptions = {}, codec = 'avc') {
+    output, format, encoding, audioOptions = {}) {
+        this.format = format;
         this.audioOptions = audioOptions;
         const downsampling = output.width !== canvas.width || output.height !== canvas.height;
         this.video = new CanvasSource(canvas, {
-            codec,
-            // Resolved against what is actually being encoded — the *output*
-            // size and the rate the frame loop will feed it — rather than
-            // against a subjective level that never sees the frame rate.
-            bitrate: video.bitrate ?? motionGraphicsBitrate(output.width, output.height, fps),
-            hardwareAcceleration: video.hardwareAcceleration ?? 'no-preference',
-            keyFrameInterval: video.keyFrameInterval ?? DEFAULT_KEY_FRAME_INTERVAL,
-            latencyMode: video.latencyMode ?? 'quality',
-            contentHint: video.contentHint ?? 'detail',
-            ...(video.bitrateMode !== undefined && { bitrateMode: video.bitrateMode }),
+            codec: encoding.codec,
+            bitrate: encoding.bitrate,
+            hardwareAcceleration: encoding.hardwareAcceleration,
+            keyFrameInterval: encoding.keyFrameInterval,
+            latencyMode: encoding.latencyMode,
+            contentHint: encoding.contentHint,
+            ...(encoding.bitrateMode !== undefined && { bitrateMode: encoding.bitrateMode }),
             // `fit` is exact here — the supersampled canvas is a whole multiple
             // of the output — but mediabunny requires it whenever both axes are
             // given, so it is stated rather than inferred.
             ...(downsampling && { transform: { width: output.width, height: output.height, fit: 'fill' } }),
         });
-        this.output = new Output({ format: new Mp4OutputFormat(), target: this.target });
+        this.output = new Output({ format: formatSpec(format).container(), target: this.target });
     }
     async start(info) {
         this.output.addVideoTrack(this.video, { frameRate: info.fps });
         // Tracks must be declared before the muxer starts, which is why the
         // orchestrator reports this rather than leaving it to be inferred.
         if (info.hasAudio) {
-            this.audio = new AudioBufferSource({
-                codec: 'aac',
-                bitrate: this.audioOptions.bitrate ?? DEFAULT_AUDIO_BITRATE,
-            });
+            await ensureAudioEncoder(this.format);
+            this.audio = audioTrackSource(this.format, this.audioOptions.bitrate ?? DEFAULT_AUDIO_BITRATE);
             this.output.addAudioTrack(this.audio);
         }
         await this.output.start();
@@ -157,107 +153,156 @@ function fittedSupersample(requested, output) {
     return factor;
 }
 /**
- * The codec to actually encode with: the one asked for if this platform can
- * encode it at this size, `'avc'` otherwise.
+ * The codec to actually encode with: the one asked for if the container holds
+ * it and this platform can encode it at this size, else the format's default,
+ * else its fallback (`'avc'` for MP4, `'vp8'` for WebM).
  *
- * A better codec is the single largest quality win available on synthetic
- * content — but which ones a machine has encoders for varies by OS, browser and
- * GPU, and an export that dies at the muxer because the machine has no HEVC
- * encoder is worse than one that quietly produces H.264. AVC is not probed: it
- * is the fallback, and there is nothing to fall back to.
+ * Which encoders a machine has varies by OS, browser and GPU, and an export that
+ * dies at the muxer for want of an HEVC encoder is worse than one that quietly
+ * produces H.264. The fallback is not probed: there is nothing to fall back to.
  */
-async function resolveCodec(requested, size, fps) {
-    if (!requested || requested === 'avc')
-        return 'avc';
+async function resolveCodec(requested, format, size, fps) {
+    const { codecs, fallback } = formatSpec(format).video;
+    let wanted = requested ?? codecs[0];
+    if (!codecs.includes(wanted)) {
+        console.warn(`[motionscript] ${format.toUpperCase()} cannot hold ${wanted}; exporting as ${CODEC_NAMES[codecs[0]]} instead.`);
+        wanted = codecs[0];
+    }
+    for (const codec of new Set([wanted, codecs[0], fallback])) {
+        if (codec === fallback || await canEncode(codec, size, fps)) {
+            if (codec !== wanted) {
+                console.warn(`[motionscript] No ${wanted} encoder available; exporting as ${CODEC_NAMES[codec]} instead.`);
+            }
+            return codec;
+        }
+    }
+    return fallback;
+}
+const CODEC_NAMES = { avc: 'H.264', hevc: 'HEVC', vp9: 'VP9', av1: 'AV1', vp8: 'VP8' };
+async function canEncode(codec, size, fps) {
     try {
-        const ok = await canEncodeVideo(requested, {
+        return await canEncodeVideo(codec, {
             width: size.width,
             height: size.height,
             bitrate: motionGraphicsBitrate(size.width, size.height, fps),
         });
-        if (ok)
-            return requested;
     }
     catch {
         // A probe that throws is a probe that answered "no".
+        return false;
+    }
+}
+/** {@link VideoEncoderOptions} with its defaults applied against the encoded size and rate. */
+export async function resolveVideoEncoding(video, format, output, fps) {
+    const codec = await resolveCodec(video?.codec, format, output, fps);
+    return {
+        codec,
+        bitrate: video?.bitrate ?? motionGraphicsBitrate(output.width, output.height, fps),
+        hardwareAcceleration: video?.hardwareAcceleration ?? 'no-preference',
+        keyFrameInterval: video?.keyFrameInterval ?? DEFAULT_KEY_FRAME_INTERVAL,
+        latencyMode: video?.latencyMode ?? 'quality',
+        contentHint: video?.contentHint ?? 'detail',
+        ...(video?.bitrateMode !== undefined && { bitrateMode: video.bitrateMode }),
+    };
+}
+/**
+ * The encoding with a `Quality` turned into the bits per second mediabunny would
+ * give it at this size, since a class instance cannot cross a `MessagePort`.
+ */
+export function plainVideoEncoding(encoding, output) {
+    const { bitrate } = encoding;
+    if (typeof bitrate === 'number')
+        return { ...encoding, bitrate };
+    const quality = bitrate;
+    return { ...encoding, bitrate: quality._toVideoBitrate(encoding.codec, output.width, output.height) };
+}
+/** The encoded size, rounded up to even, and how far each frame is supersampled. */
+export function exportGeometry(viewport, scale, supersample) {
+    // Every block-based codec works in macroblocks, so an odd dimension is
+    // padded by the encoder with a smeared strip that was never drawn.
+    const output = { width: evenUp(viewport.width * scale), height: evenUp(viewport.height * scale) };
+    const oversample = fittedSupersample(supersample, output);
+    return { output, oversample, renderScale: scale * oversample };
+}
+/**
+ * Open the canvas, renderer, storage and render context an export draws with,
+ * resolving once the surface can draw (a frame drawn before an asynchronously
+ * started surface is ready encodes blank). The canvas is a whole multiple of the
+ * output, so the downsample is exact.
+ */
+export async function openExportSurface(params) {
+    const canvas = document.createElement('canvas');
+    canvas.width = params.canvasSize.width;
+    canvas.height = params.canvasSize.height;
+    canvas.style.display = 'none';
+    document.body.appendChild(canvas);
+    try {
+        const assetCatalog = new ManifestAssetCatalog(params.manifest);
+        const renderer = await loadRenderer(params);
+        const storageAdapter = renderer.createStorageAdapter({ catalog: assetCatalog, viewport: params.viewport, fps: params.fps });
+        const renderContext = renderer.createRenderContext(storageAdapter);
+        renderContext.mount(canvas);
+        await renderContext.whenMounted?.();
+        return {
+            canvas, renderContext, storageAdapter, assetCatalog,
+            dispose: () => {
+                renderContext.dispose();
+                canvas.remove();
+            },
+        };
+    }
+    catch (error) {
+        canvas.remove();
+        throw error;
     }
-    console.warn(`[motion-script] No ${requested} encoder available; exporting as H.264 instead.`);
-    return 'avc';
 }
 /**
  * Renders a document frame-by-frame to an offscreen canvas and muxes the result
- * into an MP4 via mediabunny.
+ * into an MP4 or WebM via mediabunny.
  *
  * The frame loop itself — discovery, state evaluation, the warm-and-re-render retry
  * that keeps every frame accurate, audio scheduling, progress and cancellation —
- * lives in `@motionscript/skia-render`'s `renderTimeline`. What this function
+ * lives in `renderTimeline` (frame-loop.ts). What this function
  * supplies is the browser-specific half: a canvas to draw into, a WebCodecs sink,
  * a Web Audio mixer, and the `<a download>` delivery.
  */
 export async function exportVideo(params) {
     const { 
     // Not `document`, which would shadow the DOM global this function uses.
-    document: source, registry = new Registry(), scale = 1, filename = 'export.mp4', manifest = EMPTY_MANIFEST, includeAudio = true, video, audio = {}, onProgress, signal, wasmUrl, supersample = DEFAULT_SUPERSAMPLE, returnBytes = false, } = params;
+    document: source, registry = new Registry(), scale = 1, format = 'mp4', manifest = EMPTY_MANIFEST, theme, includeAudio = true, video, audio = {}, frames, onProgress, signal, rendererWasmUrl, supersample = DEFAULT_SUPERSAMPLE, returnBytes = false, } = params;
+    const spec = formatSpec(format);
+    if (spec.kind !== 'video')
+        throw new RangeError(`exportVideo writes video; "${format}" is audio, which exportAudio writes.`);
+    const filename = params.filename ?? `export.${spec.extension}`;
     const project = resolveProjectDocument(source, params, DEFAULT_OUTPUT);
     if (project.tracks.length === 0)
         return;
     signal?.throwIfAborted();
     const viewport = project.viewport;
     const fps = project.fps;
-    // Every block-based codec works in macroblocks, so an odd dimension is
-    // padded by the encoder and the padding is *not* what was drawn — it shows up
-    // as a smeared or discoloured strip down one edge. Rounding up to an even
-    // size instead costs at most half a pixel of centring and keeps the whole
-    // frame real.
-    const outputSize = {
-        width: evenUp(viewport.width * scale),
-        height: evenUp(viewport.height * scale),
-    };
-    const oversample = fittedSupersample(supersample, outputSize);
-    const renderScale = scale * oversample;
-    const offscreenCanvas = document.createElement('canvas');
-    offscreenCanvas.width = evenUp(viewport.width * renderScale);
-    offscreenCanvas.height = evenUp(viewport.height * renderScale);
-    offscreenCanvas.style.display = 'none';
-    document.body.appendChild(offscreenCanvas);
-    const canvasKit = await getCanvasKit(wasmUrl);
-    const assetCatalog = new ManifestAssetCatalog(manifest);
-    const storageAdapter = new WebStorageAdapter(canvasKit, assetCatalog, viewport, fps);
-    const renderContext = new WebRenderContext(canvasKit, storageAdapter);
-    renderContext.mount(offscreenCanvas);
-    const codec = await resolveCodec(video?.codec, outputSize, fps);
+    const { output, oversample, renderScale } = exportGeometry(viewport, scale, supersample);
+    const surface = await openExportSurface({
+        canvasSize: { width: output.width * oversample, height: output.height * oversample },
+        viewport, fps, manifest, rendererWasmUrl,
+    });
     let bytes;
     try {
+        const encoding = await resolveVideoEncoding(video, format, output, fps);
         bytes = await renderTimeline({
-            project, registry, scale: renderScale, includeAudio,
-            renderContext, storageAdapter, assetCatalog,
-            sink: new MediabunnyVideoSink(offscreenCanvas, fps, outputSize, video, audio, codec),
-            mixer: new WebAudioMixer(audio.sampleRate, assetCatalog),
+            project, registry, theme, scale: renderScale, includeAudio, frames,
+            renderContext: surface.renderContext, storageAdapter: surface.storageAdapter, assetCatalog: surface.assetCatalog,
+            sink: new MediabunnyVideoSink(surface.canvas, output, format, encoding, audio),
+            mixer: new WebAudioMixer(audio.sampleRate, surface.assetCatalog),
             onProgress,
+            onIssue: params.onIssue,
             signal,
         });
     }
     finally {
-        renderContext.dispose();
-        document.body.removeChild(offscreenCanvas);
+        surface.dispose();
     }
     if (!bytes)
         return;
-    // Headless callers capture the bytes and write them to disk themselves,
-    // so skip the DOM-based download path entirely.
-    if (returnBytes)
-        return bytes;
-    // The sink builds this Uint8Array over a whole, plain ArrayBuffer, so the cast
-    // is sound — TS only balks because the generic parameter admits a
-    // SharedArrayBuffer, which a BlobPart may not be.
-    const blob = new Blob([bytes.buffer], { type: 'video/mp4' });
-    const url = URL.createObjectURL(blob);
-    const link = document.createElement('a');
-    link.href = url;
-    link.download = filename;
-    document.body.appendChild(link);
-    link.click();
-    document.body.removeChild(link);
-    URL.revokeObjectURL(url);
+    return deliver(bytes, { returnBytes, filename, mimeType: spec.mimeType });
 }
 //# sourceMappingURL=exporter.js.map