@motionscript/browser 0.1.0-alpha.7 → 0.1.0-alpha.8

package/dist/browser/manifest.json

@@ -1,18 +1,23 @@
 {
   "name": "@motionscript/browser",
-  "version": "0.1.0-alpha.7",
+  "version": "0.1.0-alpha.8",
   "exports": {
     ".": "dist/browser/index.js",
     "./audio": "dist/browser/audio.js"
   },
   "peers": [
-    "@motionscript/canvaskit",
     "@motionscript/core"
   ],
   "assets": {
-    "esbuild.wasm": "dist/browser/esbuild.wasm"
+    "esbuild.wasm": "dist/browser/esbuild.wasm",
+    "ms_renderer_bg.wasm": "dist/browser/ms_renderer_bg.wasm"
   },
   "thirdParty": [
+    {
+      "name": "@mediabunny/mp3-encoder",
+      "version": "1.62.1",
+      "license": "MPL-2.0"
+    },
     {
       "name": "esbuild-wasm",
       "version": "0.28.2",
@@ -22,11 +27,6 @@
       "name": "mediabunny",
       "version": "1.49.0",
       "license": "MPL-2.0"
-    },
-    {
-      "name": "three",
-      "version": "0.185.1",
-      "license": "MIT"
     }
   ]
 }

package/dist/canvaskit-renderer.d.ts

@@ -0,0 +1,8 @@
+import type { BrowserRenderer } from "./engine";
+import { getCanvasKit } from "./getter";
+import { WebStorageAdapter } from "./storage-adapter";
+/** The default backend: CanvasKit over WebGL. */
+export declare function canvasKitRenderer(canvasKit: Awaited<ReturnType<typeof getCanvasKit>>): BrowserRenderer<WebStorageAdapter>;
+/** `renderer` when a host gave one; else CanvasKit, loaded only now. */
+export declare function resolveRenderer(renderer: BrowserRenderer | undefined, wasmUrl?: string): Promise<BrowserRenderer>;
+//# sourceMappingURL=canvaskit-renderer.d.ts.map

package/dist/canvaskit-renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canvaskit-renderer.d.ts","sourceRoot":"","sources":["../src/canvaskit-renderer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAGxC,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAEtD,iDAAiD;AACjD,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC,GAAG,eAAe,CAAC,iBAAiB,CAAC,CAYzH;AAED,wEAAwE;AACxE,wBAAsB,eAAe,CAAC,QAAQ,EAAE,eAAe,GAAG,SAAS,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAEvH"}

package/dist/canvaskit-renderer.js

@@ -0,0 +1,23 @@
+import { getCanvasKit } from "./getter";
+import { WebMeasureContext } from "./measure-context";
+import { WebRenderContext } from "./render-context";
+import { WebStorageAdapter } from "./storage-adapter";
+/** The default backend: CanvasKit over WebGL. */
+export function canvasKitRenderer(canvasKit) {
+    return {
+        createStorageAdapter({ catalog, viewport, fps }) {
+            return new WebStorageAdapter(canvasKit, catalog, viewport, fps);
+        },
+        createRenderContext(storage) {
+            return new WebRenderContext(canvasKit, storage);
+        },
+        createMeasureContext(storage) {
+            return new WebMeasureContext(storage);
+        },
+    };
+}
+/** `renderer` when a host gave one; else CanvasKit, loaded only now. */
+export async function resolveRenderer(renderer, wasmUrl) {
+    return renderer ?? canvasKitRenderer(await getCanvasKit(wasmUrl));
+}
+//# sourceMappingURL=canvaskit-renderer.js.map

package/dist/canvaskit-renderer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"canvaskit-renderer.js","sourceRoot":"","sources":["../src/canvaskit-renderer.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAEtD,iDAAiD;AACjD,MAAM,UAAU,iBAAiB,CAAC,SAAmD;IACjF,OAAO;QACH,oBAAoB,CAAC,EAAE,OAAO,EAAE,QAAQ,EAAE,GAAG,EAAgB;YACzD,OAAO,IAAI,iBAAiB,CAAC,SAAS,EAAE,OAAO,EAAE,QAAQ,EAAE,GAAG,CAAC,CAAC;QACpE,CAAC;QACD,mBAAmB,CAAC,OAA0B;YAC1C,OAAO,IAAI,gBAAgB,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;QACpD,CAAC;QACD,oBAAoB,CAAC,OAA0B;YAC3C,OAAO,IAAI,iBAAiB,CAAC,OAAO,CAAC,CAAC;QAC1C,CAAC;KACJ,CAAC;AACN,CAAC;AAED,wEAAwE;AACxE,MAAM,CAAC,KAAK,UAAU,eAAe,CAAC,QAAqC,EAAE,OAAgB;IACzF,OAAO,QAAQ,IAAI,iBAAiB,CAAC,MAAM,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC;AACtE,CAAC","sourcesContent":["import type { MeasureContext2D, PlatformDeps } from \"@motionscript/core\";\r\nimport type { BrowserRenderer } from \"./engine\";\r\nimport { getCanvasKit } from \"./getter\";\r\nimport { WebMeasureContext } from \"./measure-context\";\r\nimport { WebRenderContext } from \"./render-context\";\r\nimport { WebStorageAdapter } from \"./storage-adapter\";\r\n\r\n/** The default backend: CanvasKit over WebGL. */\r\nexport function canvasKitRenderer(canvasKit: Awaited<ReturnType<typeof getCanvasKit>>): BrowserRenderer<WebStorageAdapter> {\r\n    return {\r\n        createStorageAdapter({ catalog, viewport, fps }: PlatformDeps): WebStorageAdapter {\r\n            return new WebStorageAdapter(canvasKit, catalog, viewport, fps);\r\n        },\r\n        createRenderContext(storage: WebStorageAdapter): WebRenderContext {\r\n            return new WebRenderContext(canvasKit, storage);\r\n        },\r\n        createMeasureContext(storage: WebStorageAdapter): MeasureContext2D {\r\n            return new WebMeasureContext(storage);\r\n        },\r\n    };\r\n}\r\n\r\n/** `renderer` when a host gave one; else CanvasKit, loaded only now. */\r\nexport async function resolveRenderer(renderer: BrowserRenderer | undefined, wasmUrl?: string): Promise<BrowserRenderer> {\r\n    return renderer ?? canvasKitRenderer(await getCanvasKit(wasmUrl));\r\n}\r\n"]}

package/dist/concat.d.ts

@@ -1,5 +1,5 @@
 /**
- * Join encoded MP4 segments end to end, without re-encoding.
+ * Join encoded MP4 or WebM segments end to end, without re-encoding.
  *
  * The point of this is what it *doesn't* do: no decode, no encode, no pixels.
  * Each segment is demuxed to its encoded packets, the packets are re-stamped onto
@@ -15,8 +15,8 @@
  *
  * ## What the caller has to guarantee
  *
- * **Every segment must be encoded with an identical configuration** — same codec,
- * same resolution, same bitrate settings. A container carries exactly one decoder
+ * **Every segment must be encoded with an identical configuration** — same
+ * container, codec, resolution and bitrate settings. A container carries exactly one decoder
  * configuration for a track, so a segment whose parameter sets differ from the
  * first would be described by a configuration that isn't its own, and decode as
  * garbage from that point on. That is not a theoretical concern: hardware encoders
@@ -56,7 +56,7 @@ export interface ConcatOptions {
      * one. One buffer in, one encode, no seams.
      */
     audio?: AudioBuffer | null;
-    /** AAC bitrate for that track. Defaults to 192 kbps. */
+    /** Bitrate for that track: AAC in an MP4, Opus in a WebM. Defaults to 192 kbps. */
     audioBitrate?: number;
     /**
      * Write the result out as it is muxed instead of returning it.
@@ -81,13 +81,39 @@ export interface ConcatOptions {
         position: number;
     }>;
 }
+/** Joins segments one at a time, in timeline order, as each becomes available. */
+export interface SegmentJoiner {
+    /**
+     * Mux the next segment after the ones already appended. Appends must not
+     * overlap: await each before starting the next.
+     *
+     * @throws {ConcatMismatchError} as {@link concatVideoSegments} does.
+     */
+    append(segment: Uint8Array): Promise<void>;
+    /** Finish the container. The bytes, or an empty array when they went to `stream`. */
+    finish(): Promise<Uint8Array>;
+    /** Abandon the join; nothing more is written. */
+    cancel(): Promise<void>;
+}
+/**
+ * {@link concatVideoSegments} one segment at a time, so a split export can write
+ * each piece the moment it and every piece before it exist, instead of holding
+ * every segment until the last one lands.
+ *
+ * The audio, when given, is encoded as soon as the first segment fixes the
+ * container, ahead of the video: the muxer holds the (small) audio packets and
+ * interleaves them as the video catches up.
+ */
+export declare function createSegmentJoiner(options?: ConcatOptions): SegmentJoiner;
 /**
- * Concatenate `segments` (each a complete MP4) into one MP4.
+ * Concatenate `segments` (each a complete MP4, or each a complete WebM) into one
+ * file of the same container.
  *
  * Segments are joined in array order. Returns the muxed bytes.
  *
- * @throws {ConcatMismatchError} if a segment carries no video track, or one whose
- *         decoder configuration differs from the first segment's. Callers that can
+ * @throws {ConcatMismatchError} if a segment carries no video track, is in another
+ *         container than the first, or has a decoder configuration that differs
+ *         from the first segment's. Callers that can
  *         fall back to a single-threaded export should catch this and do so — the
  *         alternative is shipping a file that decodes into garbage halfway through.
  */

package/dist/concat.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"concat.d.ts","sourceRoot":"","sources":["../src/concat.ts"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH,wFAAwF;AACxF,qBAAa,mBAAoB,SAAQ,KAAK;IAEtC,yDAAyD;IACzD,QAAQ,CAAC,OAAO,EAAE,MAAM;;IADxB,yDAAyD;IAChD,OAAO,EAAE,MAAM,EACxB,OAAO,EAAE,MAAM;CAKtB;AA0CD,MAAM,WAAW,aAAa;IAC1B;;;;;;;;OAQG;IACH,KAAK,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;IAC3B,wDAAwD;IACxD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;;;;;;;;;;;;OAgBG;IACH,MAAM,CAAC,EAAE,cAAc,CAAC;QAAE,IAAI,EAAE,OAAO,CAAC;QAAC,IAAI,EAAE,UAAU,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAClF;AAID;;;;;;;;;GASG;AACH,wBAAsB,mBAAmB,CACrC,QAAQ,EAAE,UAAU,EAAE,EACtB,OAAO,GAAE,aAAkB,GAC5B,OAAO,CAAC,UAAU,CAAC,CA8ErB"}
+{"version":3,"file":"concat.d.ts","sourceRoot":"","sources":["../src/concat.ts"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH,wFAAwF;AACxF,qBAAa,mBAAoB,SAAQ,KAAK;IAEtC,yDAAyD;IACzD,QAAQ,CAAC,OAAO,EAAE,MAAM;;IADxB,yDAAyD;IAChD,OAAO,EAAE,MAAM,EACxB,OAAO,EAAE,MAAM;CAKtB;AA2CD,MAAM,WAAW,aAAa;IAC1B;;;;;;;;OAQG;IACH,KAAK,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;IAC3B,mFAAmF;IACnF,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;;;;;;;;;;;;OAgBG;IACH,MAAM,CAAC,EAAE,cAAc,CAAC;QAAE,IAAI,EAAE,OAAO,CAAC;QAAC,IAAI,EAAE,UAAU,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAClF;AAED,kFAAkF;AAClF,MAAM,WAAW,aAAa;IAC1B;;;;;OAKG;IACH,MAAM,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3C,qFAAqF;IACrF,MAAM,IAAI,OAAO,CAAC,UAAU,CAAC,CAAC;IAC9B,iDAAiD;IACjD,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3B;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,GAAE,aAAkB,GAAG,aAAa,CAoE9E;AAuBD;;;;;;;;;;;GAWG;AACH,wBAAsB,mBAAmB,CACrC,QAAQ,EAAE,UAAU,EAAE,EACtB,OAAO,GAAE,aAAkB,GAC5B,OAAO,CAAC,UAAU,CAAC,CAcrB"}

package/dist/concat.js

@@ -1,6 +1,7 @@
-import { AudioBufferSource, BufferSource, BufferTarget, EncodedPacketSink, EncodedVideoPacketSource, Input, MP4, Mp4OutputFormat, Output, StreamTarget, } from "mediabunny";
+import { BufferSource, BufferTarget, EncodedPacketSink, EncodedVideoPacketSource, Input, MP4, Output, StreamTarget, WEBM, } from "mediabunny";
+import { audioTrackSource, formatSpec } from "./formats";
 /**
- * Join encoded MP4 segments end to end, without re-encoding.
+ * Join encoded MP4 or WebM segments end to end, without re-encoding.
  *
  * The point of this is what it *doesn't* do: no decode, no encode, no pixels.
  * Each segment is demuxed to its encoded packets, the packets are re-stamped onto
@@ -16,8 +17,8 @@ import { AudioBufferSource, BufferSource, BufferTarget, EncodedPacketSink, Encod
  *
  * ## What the caller has to guarantee
  *
- * **Every segment must be encoded with an identical configuration** — same codec,
- * same resolution, same bitrate settings. A container carries exactly one decoder
+ * **Every segment must be encoded with an identical configuration** — same
+ * container, codec, resolution and bitrate settings. A container carries exactly one decoder
  * configuration for a track, so a segment whose parameter sets differ from the
  * first would be described by a configuration that isn't its own, and decode as
  * garbage from that point on. That is not a theoretical concern: hardware encoders
@@ -86,14 +87,114 @@ function toBytes(description) {
     }
     return new Uint8Array(description);
 }
-const DEFAULT_AUDIO_BITRATE = 192_000;
 /**
- * Concatenate `segments` (each a complete MP4) into one MP4.
+ * {@link concatVideoSegments} one segment at a time, so a split export can write
+ * each piece the moment it and every piece before it exist, instead of holding
+ * every segment until the last one lands.
+ *
+ * The audio, when given, is encoded as soon as the first segment fixes the
+ * container, ahead of the video: the muxer holds the (small) audio packets and
+ * interleaves them as the video catches up.
+ */
+export function createSegmentJoiner(options = {}) {
+    let first = null;
+    let output = null;
+    let source = null;
+    let audioSource = null;
+    let target = null;
+    let index = 0;
+    let offset = 0;
+    const start = async (segment) => {
+        target = options.stream
+            ? new StreamTarget(options.stream)
+            : new BufferTarget();
+        output = new Output({ format: formatSpec(segment.format).container(), target });
+        // `codec` comes off the track rather than the decoder config: the latter's
+        // `codec` is the full codec *string* (`avc1.64001f`), while the source wants
+        // the family.
+        source = new EncodedVideoPacketSource(segment.track.codec);
+        output.addVideoTrack(source);
+        // Declared before `start()`: a muxer fixes its track list up front.
+        audioSource = options.audio ? audioTrackSource(segment.format, options.audioBitrate) : null;
+        if (audioSource)
+            output.addAudioTrack(audioSource);
+        await output.start();
+        if (audioSource && options.audio)
+            await audioSource.add(options.audio);
+    };
+    return {
+        async append(bytes) {
+            const i = index++;
+            const input = new Input({ source: new BufferSource(bytes), formats: [MP4, WEBM] });
+            try {
+                const segment = await openSegment(input, i, first);
+                if (!first) {
+                    first = segment;
+                    await start(segment);
+                }
+                // The decoder config is handed over with each segment's first packet.
+                // Only the first can take effect (a container holds one per track), but
+                // every one has been checked equal to it.
+                let leading = true;
+                for await (const packet of new EncodedPacketSink(segment.track).packets()) {
+                    await source.add(packet.clone({ timestamp: packet.timestamp + offset }), leading ? { decoderConfig: segment.config } : undefined);
+                    leading = false;
+                }
+                // The segment's own duration rather than its last packet's end: summing
+                // packet durations accumulates rounding into a drift across many segments.
+                offset += segment.duration;
+            }
+            finally {
+                input.dispose();
+            }
+        },
+        async finish() {
+            if (!output)
+                throw new Error("concatVideoSegments: no segments");
+            source.close();
+            audioSource?.close();
+            await output.finalize();
+            if (options.stream)
+                return new Uint8Array(0);
+            const buffer = target.buffer;
+            if (!buffer)
+                throw new Error("concatVideoSegments produced no data");
+            return new Uint8Array(buffer);
+        },
+        async cancel() {
+            if (output && output.state !== "finalized" && output.state !== "canceled")
+                await output.cancel();
+        },
+    };
+}
+/** Demux one segment and check it can follow `first`. */
+async function openSegment(input, i, first) {
+    const format = (await input.getFormat()) === WEBM ? "webm" : "mp4";
+    if (first && format !== first.format) {
+        throw new ConcatMismatchError(i, `Segment ${i} is ${format} and segment 0 is ${first.format}.`);
+    }
+    const track = await input.getPrimaryVideoTrack();
+    if (!track)
+        throw new ConcatMismatchError(i, `Segment ${i} has no video track.`);
+    const config = await track.getDecoderConfig();
+    if (!config)
+        throw new ConcatMismatchError(i, `Segment ${i} has no decoder configuration.`);
+    if (first && !sameDecoderConfig(first.config, config)) {
+        throw new ConcatMismatchError(i, `Segment ${i} was encoded differently from segment 0 (${first.config.codec} `
+            + `${first.config.codedWidth}x${first.config.codedHeight} vs ${config.codec} `
+            + `${config.codedWidth}x${config.codedHeight}); joining them would decode as garbage.`);
+    }
+    return { format, track, config, duration: await track.computeDuration() };
+}
+/**
+ * Concatenate `segments` (each a complete MP4, or each a complete WebM) into one
+ * file of the same container.
  *
  * Segments are joined in array order. Returns the muxed bytes.
  *
- * @throws {ConcatMismatchError} if a segment carries no video track, or one whose
- *         decoder configuration differs from the first segment's. Callers that can
+ * @throws {ConcatMismatchError} if a segment carries no video track, is in another
+ *         container than the first, or has a decoder configuration that differs
+ *         from the first segment's. Callers that can
  *         fall back to a single-threaded export should catch this and do so — the
  *         alternative is shipping a file that decodes into garbage halfway through.
  */
@@ -104,71 +205,15 @@ export async function concatVideoSegments(segments, options = {}) {
     // to it, or it has to go to a sink, either of which means muxing after all.
     if (segments.length === 1 && !options.audio && !options.stream)
         return segments[0];
-    const opened = [];
-    for (let i = 0; i < segments.length; i++) {
-        const input = new Input({ source: new BufferSource(segments[i]), formats: [MP4] });
-        const track = await input.getPrimaryVideoTrack();
-        if (!track)
-            throw new ConcatMismatchError(i, `Segment ${i} has no video track.`);
-        const config = await track.getDecoderConfig();
-        if (!config)
-            throw new ConcatMismatchError(i, `Segment ${i} has no decoder configuration.`);
-        if (opened.length > 0 && !sameDecoderConfig(opened[0].config, config)) {
-            throw new ConcatMismatchError(i, `Segment ${i} was encoded differently from segment 0 (${opened[0].config.codec} `
-                + `${opened[0].config.codedWidth}x${opened[0].config.codedHeight} vs ${config.codec} `
-                + `${config.codedWidth}x${config.codedHeight}); joining them would decode as garbage.`);
-        }
-        opened.push({ track, config, duration: await track.computeDuration() });
+    const joiner = createSegmentJoiner(options);
+    try {
+        for (const segment of segments)
+            await joiner.append(segment);
+        return await joiner.finish();
     }
-    const target = options.stream
-        ? new StreamTarget(options.stream)
-        : new BufferTarget();
-    const output = new Output({ format: new Mp4OutputFormat(), target });
-    // `codec` comes off the track rather than the decoder config: the latter's
-    // `codec` is the full codec *string* (`avc1.64001f`), while the source wants
-    // the family.
-    const source = new EncodedVideoPacketSource(opened[0].track.codec);
-    output.addVideoTrack(source);
-    // Declared before `start()` — a muxer fixes its track list up front, so an
-    // audio track added later would have nowhere to go.
-    const audioSource = options.audio
-        ? new AudioBufferSource({
-            codec: "aac",
-            bitrate: options.audioBitrate ?? DEFAULT_AUDIO_BITRATE,
-        })
-        : null;
-    if (audioSource)
-        output.addAudioTrack(audioSource);
-    await output.start();
-    let offset = 0;
-    for (const segment of opened) {
-        // The decoder config is handed over with the first packet of each segment.
-        // Only the first one can take effect — a container holds one per track —
-        // but they have all been checked equal above, so restating it is harmless
-        // and keeps the muxer from having to infer anything.
-        let first = true;
-        for await (const packet of new EncodedPacketSink(segment.track).packets()) {
-            await source.add(packet.clone({ timestamp: packet.timestamp + offset }), first ? { decoderConfig: segment.config } : undefined);
-            first = false;
-        }
-        // Advance by the segment's own duration rather than by the last packet's
-        // end: a packet's `duration` is what the container recorded, and summing
-        // those would accumulate rounding into a drift across many segments.
-        offset += segment.duration;
+    catch (error) {
+        await joiner.cancel().catch(() => { });
+        throw error;
     }
-    // After the video packets, so the encode overlaps nothing it has to wait on.
-    if (audioSource && options.audio)
-        await audioSource.add(options.audio);
-    source.close();
-    audioSource?.close();
-    await output.finalize();
-    // A streamed result has already gone to the sink; there is nothing to hand
-    // back, and materialising it here would undo the point of streaming.
-    if (options.stream)
-        return new Uint8Array(0);
-    const buffer = target.buffer;
-    if (!buffer)
-        throw new Error("concatVideoSegments produced no data");
-    return new Uint8Array(buffer);
 }
 //# sourceMappingURL=concat.js.map

package/dist/concat.js.map

@@ -1 +1 @@
-{"version":3,"file":"concat.js","sourceRoot":"","sources":["../src/concat.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n    AudioBufferSource,\r\n    BufferSource,\r\n    BufferTarget,\r\n    EncodedPacketSink,\r\n    EncodedVideoPacketSource,\r\n    Input,\r\n    MP4,\r\n    Mp4OutputFormat,\r\n    Output,\r\n    StreamTarget,\r\n    type InputVideoTrack,\r\n    type VideoCodec,\r\n} from \"mediabunny\";\r\n\r\n/**\r\n * Join encoded MP4 segments end to end, without re-encoding.\r\n *\r\n * The point of this is what it *doesn't* do: no decode, no encode, no pixels.\r\n * Each segment is demuxed to its encoded packets, the packets are re-stamped onto\r\n * one continuous timeline, and a single muxer writes them into one container. The\r\n * bytes of every frame survive untouched, so the result is bit-identical to the\r\n * segments and the whole thing runs at I/O speed rather than encode speed.\r\n *\r\n * It exists so an export can be **split across workers**. Rendering a timeline is\r\n * embarrassingly parallel per scene — each scene's generator is independent — but\r\n * the output has to be one file, and re-encoding the parts to join them would give\r\n * back everything the parallelism won (and lose a generation of quality). Joining\r\n * at the packet level is what makes splitting worth doing.\r\n *\r\n * ## What the caller has to guarantee\r\n *\r\n * **Every segment must be encoded with an identical configuration** — same codec,\r\n * same resolution, same bitrate settings. A container carries exactly one decoder\r\n * configuration for a track, so a segment whose parameter sets differ from the\r\n * first would be described by a configuration that isn't its own, and decode as\r\n * garbage from that point on. That is not a theoretical concern: hardware encoders\r\n * are free to pick different parameter sets for the same nominal settings. This is\r\n * checked rather than assumed — see {@link ConcatMismatchError} — because the\r\n * failure is silent corruption rather than an exception.\r\n *\r\n * **Every segment must begin with a key frame.** Otherwise its first packets refer\r\n * back to frames that lived in the previous segment's GOP and no longer precede\r\n * them. Encoders start with a key frame by default; a caller choosing an explicit\r\n * `keyFrameInterval` needs it to divide the segment length.\r\n *\r\n * Audio is *muxed* here but never *joined*: the segments' own audio is ignored\r\n * entirely, and a single already-mixed buffer is encoded once across the whole\r\n * result (see {@link ConcatOptions.audio}). Concatenating separately-encoded AAC\r\n * would put the encoder's priming delay at every join — a click at each boundary\r\n * and a track that drifts further out of sync with every one — so the timeline's\r\n * audio is mixed in one pass by whoever owns the timeline, and arrives here as\r\n * one buffer.\r\n */\r\n\r\n/** Thrown when segments can't be joined losslessly. Carries which segment disagreed. */\r\nexport class ConcatMismatchError extends Error {\r\n    constructor(\r\n        /** Index of the offending segment in the input array. */\r\n        readonly segment: number,\r\n        message: string,\r\n    ) {\r\n        super(message);\r\n        this.name = \"ConcatMismatchError\";\r\n    }\r\n}\r\n\r\n/** One segment's demuxed video track, plus the config that describes it. */\r\ninterface Segment {\r\n    track: InputVideoTrack;\r\n    config: VideoDecoderConfig;\r\n    duration: number;\r\n}\r\n\r\n/**\r\n * Two decoder configurations describe the same bitstream.\r\n *\r\n * `description` holds the codec's parameter sets (the `avcC` box for H.264) and is\r\n * the field that actually decides decodability — a differing one is exactly the\r\n * silent-corruption case. Compared bytewise; the rest are compared by value.\r\n */\r\nfunction sameDecoderConfig(a: VideoDecoderConfig, b: VideoDecoderConfig): boolean {\r\n    if (a.codec !== b.codec) return false;\r\n    if (a.codedWidth !== b.codedWidth) return false;\r\n    if (a.codedHeight !== b.codedHeight) return false;\r\n\r\n    const da = toBytes(a.description);\r\n    const db = toBytes(b.description);\r\n    if (da === null || db === null) return da === db;\r\n    if (da.length !== db.length) return false;\r\n    for (let i = 0; i < da.length; i++) {\r\n        if (da[i] !== db[i]) return false;\r\n    }\r\n    return true;\r\n}\r\n\r\nfunction toBytes(description: VideoDecoderConfig[\"description\"]): Uint8Array | null {\r\n    if (!description) return null;\r\n    // `description` is a BufferSource: an ArrayBuffer, a SharedArrayBuffer, or any\r\n    // view over one. Views carry an offset into a larger buffer, so they must be\r\n    // narrowed rather than wrapped whole.\r\n    if (ArrayBuffer.isView(description)) {\r\n        return new Uint8Array(description.buffer, description.byteOffset, description.byteLength);\r\n    }\r\n    return new Uint8Array(description);\r\n}\r\n\r\nexport interface ConcatOptions {\r\n    /**\r\n     * One continuous audio track for the whole joined timeline.\r\n     *\r\n     * Mixed once by the caller (see `mixTimelineAudio`) rather than per segment,\r\n     * and that is not a convenience: separately-encoded AAC carries an encoder\r\n     * priming delay at the head of each piece, so joining them puts a click at\r\n     * every scene boundary and drifts the track further out of sync with each\r\n     * one. One buffer in, one encode, no seams.\r\n     */\r\n    audio?: AudioBuffer | null;\r\n    /** AAC bitrate for that track. Defaults to 192 kbps. */\r\n    audioBitrate?: number;\r\n    /**\r\n     * Write the result out as it is muxed instead of returning it.\r\n     *\r\n     * With this the joined file never exists in memory as one buffer, which is\r\n     * the difference between an export the process can hold and one it can't:\r\n     * a 4× 60fps render is hundreds of megabytes, and the default path costs\r\n     * roughly twice that at the tail once the `Blob` copy is counted.\r\n     *\r\n     * **Chunks carry a byte `position` and do not arrive in file order** — a\r\n     * muxer seeks back to patch atom sizes. A sink that appends will produce a\r\n     * file of exactly the right length whose size fields belong to a different\r\n     * one: unplayable, and indistinguishable from success until it is opened.\r\n     * Honour `position`.\r\n     *\r\n     * `concatVideoSegments` resolves to an empty array when this is used; the\r\n     * bytes went to the sink.\r\n     */\r\n    stream?: WritableStream<{ type: \"write\"; data: Uint8Array; position: number }>;\r\n}\r\n\r\nconst DEFAULT_AUDIO_BITRATE = 192_000;\r\n\r\n/**\r\n * Concatenate `segments` (each a complete MP4) into one MP4.\r\n *\r\n * Segments are joined in array order. Returns the muxed bytes.\r\n *\r\n * @throws {ConcatMismatchError} if a segment carries no video track, or one whose\r\n *         decoder configuration differs from the first segment's. Callers that can\r\n *         fall back to a single-threaded export should catch this and do so — the\r\n *         alternative is shipping a file that decodes into garbage halfway through.\r\n */\r\nexport async function concatVideoSegments(\r\n    segments: Uint8Array[],\r\n    options: ConcatOptions = {},\r\n): Promise<Uint8Array> {\r\n    if (segments.length === 0) throw new Error(\"concatVideoSegments: no segments\");\r\n    // A lone segment is already the finished file — unless a track has to be added\r\n    // to it, or it has to go to a sink, either of which means muxing after all.\r\n    if (segments.length === 1 && !options.audio && !options.stream) return segments[0];\r\n\r\n    const opened: Segment[] = [];\r\n    for (let i = 0; i < segments.length; i++) {\r\n        const input = new Input({ source: new BufferSource(segments[i]), formats: [MP4] });\r\n        const track = await input.getPrimaryVideoTrack();\r\n        if (!track) throw new ConcatMismatchError(i, `Segment ${i} has no video track.`);\r\n        const config = await track.getDecoderConfig();\r\n        if (!config) throw new ConcatMismatchError(i, `Segment ${i} has no decoder configuration.`);\r\n        if (opened.length > 0 && !sameDecoderConfig(opened[0].config, config)) {\r\n            throw new ConcatMismatchError(\r\n                i,\r\n                `Segment ${i} was encoded differently from segment 0 (${opened[0].config.codec} `\r\n                + `${opened[0].config.codedWidth}x${opened[0].config.codedHeight} vs ${config.codec} `\r\n                + `${config.codedWidth}x${config.codedHeight}); joining them would decode as garbage.`,\r\n            );\r\n        }\r\n        opened.push({ track, config, duration: await track.computeDuration() });\r\n    }\r\n\r\n    const target = options.stream\r\n        ? new StreamTarget(options.stream as ConstructorParameters<typeof StreamTarget>[0])\r\n        : new BufferTarget();\r\n    const output = new Output({ format: new Mp4OutputFormat(), target });\r\n    // `codec` comes off the track rather than the decoder config: the latter's\r\n    // `codec` is the full codec *string* (`avc1.64001f`), while the source wants\r\n    // the family.\r\n    const source = new EncodedVideoPacketSource(opened[0].track.codec as VideoCodec);\r\n    output.addVideoTrack(source);\r\n    // Declared before `start()` — a muxer fixes its track list up front, so an\r\n    // audio track added later would have nowhere to go.\r\n    const audioSource = options.audio\r\n        ? new AudioBufferSource({\r\n            codec: \"aac\",\r\n            bitrate: options.audioBitrate ?? DEFAULT_AUDIO_BITRATE,\r\n        })\r\n        : null;\r\n    if (audioSource) output.addAudioTrack(audioSource);\r\n    await output.start();\r\n\r\n    let offset = 0;\r\n    for (const segment of opened) {\r\n        // The decoder config is handed over with the first packet of each segment.\r\n        // Only the first one can take effect — a container holds one per track —\r\n        // but they have all been checked equal above, so restating it is harmless\r\n        // and keeps the muxer from having to infer anything.\r\n        let first = true;\r\n        for await (const packet of new EncodedPacketSink(segment.track).packets()) {\r\n            await source.add(\r\n                packet.clone({ timestamp: packet.timestamp + offset }),\r\n                first ? { decoderConfig: segment.config } : undefined,\r\n            );\r\n            first = false;\r\n        }\r\n        // Advance by the segment's own duration rather than by the last packet's\r\n        // end: a packet's `duration` is what the container recorded, and summing\r\n        // those would accumulate rounding into a drift across many segments.\r\n        offset += segment.duration;\r\n    }\r\n\r\n    // After the video packets, so the encode overlaps nothing it has to wait on.\r\n    if (audioSource && options.audio) await audioSource.add(options.audio);\r\n\r\n    source.close();\r\n    audioSource?.close();\r\n    await output.finalize();\r\n\r\n    // A streamed result has already gone to the sink; there is nothing to hand\r\n    // back, and materialising it here would undo the point of streaming.\r\n    if (options.stream) return new Uint8Array(0);\r\n\r\n    const buffer = (target as BufferTarget).buffer;\r\n    if (!buffer) throw new Error(\"concatVideoSegments produced no data\");\r\n    return new Uint8Array(buffer);\r\n}\r\n"]}
+{"version":3,"file":"concat.js","sourceRoot":"","sources":["../src/concat.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n    BufferSource,\r\n    BufferTarget,\r\n    EncodedPacketSink,\r\n    EncodedVideoPacketSource,\r\n    Input,\r\n    MP4,\r\n    Output,\r\n    StreamTarget,\r\n    WEBM,\r\n    type InputVideoTrack,\r\n    type VideoCodec,\r\n} from \"mediabunny\";\r\n\r\nimport { audioTrackSource, formatSpec, type VideoFormat } from \"./formats\";\r\n\r\n/**\r\n * Join encoded MP4 or WebM segments end to end, without re-encoding.\r\n *\r\n * The point of this is what it *doesn't* do: no decode, no encode, no pixels.\r\n * Each segment is demuxed to its encoded packets, the packets are re-stamped onto\r\n * one continuous timeline, and a single muxer writes them into one container. The\r\n * bytes of every frame survive untouched, so the result is bit-identical to the\r\n * segments and the whole thing runs at I/O speed rather than encode speed.\r\n *\r\n * It exists so an export can be **split across workers**. Rendering a timeline is\r\n * embarrassingly parallel per scene — each scene's generator is independent — but\r\n * the output has to be one file, and re-encoding the parts to join them would give\r\n * back everything the parallelism won (and lose a generation of quality). Joining\r\n * at the packet level is what makes splitting worth doing.\r\n *\r\n * ## What the caller has to guarantee\r\n *\r\n * **Every segment must be encoded with an identical configuration** — same\r\n * container, codec, resolution and bitrate settings. A container carries exactly one decoder\r\n * configuration for a track, so a segment whose parameter sets differ from the\r\n * first would be described by a configuration that isn't its own, and decode as\r\n * garbage from that point on. That is not a theoretical concern: hardware encoders\r\n * are free to pick different parameter sets for the same nominal settings. This is\r\n * checked rather than assumed — see {@link ConcatMismatchError} — because the\r\n * failure is silent corruption rather than an exception.\r\n *\r\n * **Every segment must begin with a key frame.** Otherwise its first packets refer\r\n * back to frames that lived in the previous segment's GOP and no longer precede\r\n * them. Encoders start with a key frame by default; a caller choosing an explicit\r\n * `keyFrameInterval` needs it to divide the segment length.\r\n *\r\n * Audio is *muxed* here but never *joined*: the segments' own audio is ignored\r\n * entirely, and a single already-mixed buffer is encoded once across the whole\r\n * result (see {@link ConcatOptions.audio}). Concatenating separately-encoded AAC\r\n * would put the encoder's priming delay at every join — a click at each boundary\r\n * and a track that drifts further out of sync with every one — so the timeline's\r\n * audio is mixed in one pass by whoever owns the timeline, and arrives here as\r\n * one buffer.\r\n */\r\n\r\n/** Thrown when segments can't be joined losslessly. Carries which segment disagreed. */\r\nexport class ConcatMismatchError extends Error {\r\n    constructor(\r\n        /** Index of the offending segment in the input array. */\r\n        readonly segment: number,\r\n        message: string,\r\n    ) {\r\n        super(message);\r\n        this.name = \"ConcatMismatchError\";\r\n    }\r\n}\r\n\r\n/** One segment's demuxed video track, plus the config that describes it. */\r\ninterface Segment {\r\n    format: VideoFormat;\r\n    track: InputVideoTrack;\r\n    config: VideoDecoderConfig;\r\n    duration: number;\r\n}\r\n\r\n/**\r\n * Two decoder configurations describe the same bitstream.\r\n *\r\n * `description` holds the codec's parameter sets (the `avcC` box for H.264) and is\r\n * the field that actually decides decodability — a differing one is exactly the\r\n * silent-corruption case. Compared bytewise; the rest are compared by value.\r\n */\r\nfunction sameDecoderConfig(a: VideoDecoderConfig, b: VideoDecoderConfig): boolean {\r\n    if (a.codec !== b.codec) return false;\r\n    if (a.codedWidth !== b.codedWidth) return false;\r\n    if (a.codedHeight !== b.codedHeight) return false;\r\n\r\n    const da = toBytes(a.description);\r\n    const db = toBytes(b.description);\r\n    if (da === null || db === null) return da === db;\r\n    if (da.length !== db.length) return false;\r\n    for (let i = 0; i < da.length; i++) {\r\n        if (da[i] !== db[i]) return false;\r\n    }\r\n    return true;\r\n}\r\n\r\nfunction toBytes(description: VideoDecoderConfig[\"description\"]): Uint8Array | null {\r\n    if (!description) return null;\r\n    // `description` is a BufferSource: an ArrayBuffer, a SharedArrayBuffer, or any\r\n    // view over one. Views carry an offset into a larger buffer, so they must be\r\n    // narrowed rather than wrapped whole.\r\n    if (ArrayBuffer.isView(description)) {\r\n        return new Uint8Array(description.buffer, description.byteOffset, description.byteLength);\r\n    }\r\n    return new Uint8Array(description);\r\n}\r\n\r\nexport interface ConcatOptions {\r\n    /**\r\n     * One continuous audio track for the whole joined timeline.\r\n     *\r\n     * Mixed once by the caller (see `mixTimelineAudio`) rather than per segment,\r\n     * and that is not a convenience: separately-encoded AAC carries an encoder\r\n     * priming delay at the head of each piece, so joining them puts a click at\r\n     * every scene boundary and drifts the track further out of sync with each\r\n     * one. One buffer in, one encode, no seams.\r\n     */\r\n    audio?: AudioBuffer | null;\r\n    /** Bitrate for that track: AAC in an MP4, Opus in a WebM. Defaults to 192 kbps. */\r\n    audioBitrate?: number;\r\n    /**\r\n     * Write the result out as it is muxed instead of returning it.\r\n     *\r\n     * With this the joined file never exists in memory as one buffer, which is\r\n     * the difference between an export the process can hold and one it can't:\r\n     * a 4× 60fps render is hundreds of megabytes, and the default path costs\r\n     * roughly twice that at the tail once the `Blob` copy is counted.\r\n     *\r\n     * **Chunks carry a byte `position` and do not arrive in file order** — a\r\n     * muxer seeks back to patch atom sizes. A sink that appends will produce a\r\n     * file of exactly the right length whose size fields belong to a different\r\n     * one: unplayable, and indistinguishable from success until it is opened.\r\n     * Honour `position`.\r\n     *\r\n     * `concatVideoSegments` resolves to an empty array when this is used; the\r\n     * bytes went to the sink.\r\n     */\r\n    stream?: WritableStream<{ type: \"write\"; data: Uint8Array; position: number }>;\r\n}\r\n\r\n/** Joins segments one at a time, in timeline order, as each becomes available. */\r\nexport interface SegmentJoiner {\r\n    /**\r\n     * Mux the next segment after the ones already appended. Appends must not\r\n     * overlap: await each before starting the next.\r\n     *\r\n     * @throws {ConcatMismatchError} as {@link concatVideoSegments} does.\r\n     */\r\n    append(segment: Uint8Array): Promise<void>;\r\n    /** Finish the container. The bytes, or an empty array when they went to `stream`. */\r\n    finish(): Promise<Uint8Array>;\r\n    /** Abandon the join; nothing more is written. */\r\n    cancel(): Promise<void>;\r\n}\r\n\r\n/**\r\n * {@link concatVideoSegments} one segment at a time, so a split export can write\r\n * each piece the moment it and every piece before it exist, instead of holding\r\n * every segment until the last one lands.\r\n *\r\n * The audio, when given, is encoded as soon as the first segment fixes the\r\n * container, ahead of the video: the muxer holds the (small) audio packets and\r\n * interleaves them as the video catches up.\r\n */\r\nexport function createSegmentJoiner(options: ConcatOptions = {}): SegmentJoiner {\r\n    let first: Segment | null = null;\r\n    let output: Output | null = null;\r\n    let source: EncodedVideoPacketSource | null = null;\r\n    let audioSource: ReturnType<typeof audioTrackSource> | null = null;\r\n    let target: StreamTarget | BufferTarget | null = null;\r\n    let index = 0;\r\n    let offset = 0;\r\n\r\n    const start = async (segment: Segment) => {\r\n        target = options.stream\r\n            ? new StreamTarget(options.stream as ConstructorParameters<typeof StreamTarget>[0])\r\n            : new BufferTarget();\r\n        output = new Output({ format: formatSpec(segment.format).container(), target });\r\n        // `codec` comes off the track rather than the decoder config: the latter's\r\n        // `codec` is the full codec *string* (`avc1.64001f`), while the source wants\r\n        // the family.\r\n        source = new EncodedVideoPacketSource(segment.track.codec as VideoCodec);\r\n        output.addVideoTrack(source);\r\n        // Declared before `start()`: a muxer fixes its track list up front.\r\n        audioSource = options.audio ? audioTrackSource(segment.format, options.audioBitrate) : null;\r\n        if (audioSource) output.addAudioTrack(audioSource);\r\n        await output.start();\r\n        if (audioSource && options.audio) await audioSource.add(options.audio);\r\n    };\r\n\r\n    return {\r\n        async append(bytes) {\r\n            const i = index++;\r\n            const input = new Input({ source: new BufferSource(bytes), formats: [MP4, WEBM] });\r\n            try {\r\n                const segment = await openSegment(input, i, first);\r\n                if (!first) {\r\n                    first = segment;\r\n                    await start(segment);\r\n                }\r\n                // The decoder config is handed over with each segment's first packet.\r\n                // Only the first can take effect (a container holds one per track), but\r\n                // every one has been checked equal to it.\r\n                let leading = true;\r\n                for await (const packet of new EncodedPacketSink(segment.track).packets()) {\r\n                    await source!.add(\r\n                        packet.clone({ timestamp: packet.timestamp + offset }),\r\n                        leading ? { decoderConfig: segment.config } : undefined,\r\n                    );\r\n                    leading = false;\r\n                }\r\n                // The segment's own duration rather than its last packet's end: summing\r\n                // packet durations accumulates rounding into a drift across many segments.\r\n                offset += segment.duration;\r\n            } finally {\r\n                input.dispose();\r\n            }\r\n        },\r\n        async finish() {\r\n            if (!output) throw new Error(\"concatVideoSegments: no segments\");\r\n            source!.close();\r\n            audioSource?.close();\r\n            await output.finalize();\r\n            if (options.stream) return new Uint8Array(0);\r\n            const buffer = (target as BufferTarget).buffer;\r\n            if (!buffer) throw new Error(\"concatVideoSegments produced no data\");\r\n            return new Uint8Array(buffer);\r\n        },\r\n        async cancel() {\r\n            if (output && output.state !== \"finalized\" && output.state !== \"canceled\") await output.cancel();\r\n        },\r\n    };\r\n}\r\n\r\n/** Demux one segment and check it can follow `first`. */\r\nasync function openSegment(input: Input, i: number, first: Segment | null): Promise<Segment> {\r\n    const format: VideoFormat = (await input.getFormat()) === WEBM ? \"webm\" : \"mp4\";\r\n    if (first && format !== first.format) {\r\n        throw new ConcatMismatchError(i, `Segment ${i} is ${format} and segment 0 is ${first.format}.`);\r\n    }\r\n    const track = await input.getPrimaryVideoTrack();\r\n    if (!track) throw new ConcatMismatchError(i, `Segment ${i} has no video track.`);\r\n    const config = await track.getDecoderConfig();\r\n    if (!config) throw new ConcatMismatchError(i, `Segment ${i} has no decoder configuration.`);\r\n    if (first && !sameDecoderConfig(first.config, config)) {\r\n        throw new ConcatMismatchError(\r\n            i,\r\n            `Segment ${i} was encoded differently from segment 0 (${first.config.codec} `\r\n            + `${first.config.codedWidth}x${first.config.codedHeight} vs ${config.codec} `\r\n            + `${config.codedWidth}x${config.codedHeight}); joining them would decode as garbage.`,\r\n        );\r\n    }\r\n    return { format, track, config, duration: await track.computeDuration() };\r\n}\r\n\r\n/**\r\n * Concatenate `segments` (each a complete MP4, or each a complete WebM) into one\r\n * file of the same container.\r\n *\r\n * Segments are joined in array order. Returns the muxed bytes.\r\n *\r\n * @throws {ConcatMismatchError} if a segment carries no video track, is in another\r\n *         container than the first, or has a decoder configuration that differs\r\n *         from the first segment's. Callers that can\r\n *         fall back to a single-threaded export should catch this and do so — the\r\n *         alternative is shipping a file that decodes into garbage halfway through.\r\n */\r\nexport async function concatVideoSegments(\r\n    segments: Uint8Array[],\r\n    options: ConcatOptions = {},\r\n): Promise<Uint8Array> {\r\n    if (segments.length === 0) throw new Error(\"concatVideoSegments: no segments\");\r\n    // A lone segment is already the finished file — unless a track has to be added\r\n    // to it, or it has to go to a sink, either of which means muxing after all.\r\n    if (segments.length === 1 && !options.audio && !options.stream) return segments[0];\r\n\r\n    const joiner = createSegmentJoiner(options);\r\n    try {\r\n        for (const segment of segments) await joiner.append(segment);\r\n        return await joiner.finish();\r\n    } catch (error) {\r\n        await joiner.cancel().catch(() => {});\r\n        throw error;\r\n    }\r\n}\r\n"]}

package/dist/deliver.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Hand an export's bytes back, or download them through an `<a download>`.
+ * Headless callers capture the bytes and write the file themselves.
+ */
+export declare function deliver(bytes: Uint8Array, options: {
+    returnBytes: boolean;
+    filename: string;
+    mimeType: string;
+}): Uint8Array | undefined;
+//# sourceMappingURL=deliver.d.ts.map

package/dist/deliver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deliver.d.ts","sourceRoot":"","sources":["../src/deliver.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,OAAO,CACnB,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE;IAAE,WAAW,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GACtE,UAAU,GAAG,SAAS,CAgBxB"}

package/dist/deliver.js

@@ -0,0 +1,22 @@
+/**
+ * Hand an export's bytes back, or download them through an `<a download>`.
+ * Headless callers capture the bytes and write the file themselves.
+ */
+export function deliver(bytes, options) {
+    if (options.returnBytes)
+        return bytes;
+    // Every encoder here builds its 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: options.mimeType });
+    const url = URL.createObjectURL(blob);
+    const link = document.createElement("a");
+    link.href = url;
+    link.download = options.filename;
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+    URL.revokeObjectURL(url);
+    return undefined;
+}
+//# sourceMappingURL=deliver.js.map

package/dist/deliver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deliver.js","sourceRoot":"","sources":["../src/deliver.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,UAAU,OAAO,CACnB,KAAiB,EACjB,OAAqE;IAErE,IAAI,OAAO,CAAC,WAAW;QAAE,OAAO,KAAK,CAAC;IAEtC,+EAA+E;IAC/E,2EAA2E;IAC3E,kDAAkD;IAClD,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,CAAC,KAAK,CAAC,MAAqB,CAAC,EAAE,EAAE,IAAI,EAAE,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;IACjF,MAAM,GAAG,GAAG,GAAG,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;IACtC,MAAM,IAAI,GAAG,QAAQ,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;IACzC,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC;IAChB,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;IACjC,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IAChC,IAAI,CAAC,KAAK,EAAE,CAAC;IACb,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;IAChC,GAAG,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC;IACzB,OAAO,SAAS,CAAC;AACrB,CAAC","sourcesContent":["/**\n * Hand an export's bytes back, or download them through an `<a download>`.\n * Headless callers capture the bytes and write the file themselves.\n */\nexport function deliver(\n    bytes: Uint8Array,\n    options: { returnBytes: boolean; filename: string; mimeType: string },\n): Uint8Array | undefined {\n    if (options.returnBytes) return bytes;\n\n    // Every encoder here builds its Uint8Array over a whole, plain ArrayBuffer, so\n    // the cast is sound — TS only balks because the generic parameter admits a\n    // SharedArrayBuffer, which a BlobPart may not be.\n    const blob = new Blob([bytes.buffer as ArrayBuffer], { type: options.mimeType });\n    const url = URL.createObjectURL(blob);\n    const link = document.createElement(\"a\");\n    link.href = url;\n    link.download = options.filename;\n    document.body.appendChild(link);\n    link.click();\n    document.body.removeChild(link);\n    URL.revokeObjectURL(url);\n    return undefined;\n}\n"]}

package/dist/dynamic-nodes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dynamic-nodes.d.ts","sourceRoot":"","sources":["../src/dynamic-nodes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AA8C5D;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAC/B,OAAO,EAAE,OAAO,CAAC,iBAAiB,CAAC,GAAG,SAAS,EAC/C,eAAe,CAAC,EAAE,MAAM,GACzB,iBAAiB,CAMnB"}
+{"version":3,"file":"dynamic-nodes.d.ts","sourceRoot":"","sources":["../src/dynamic-nodes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AA6C5D;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAC/B,OAAO,EAAE,OAAO,CAAC,iBAAiB,CAAC,GAAG,SAAS,EAC/C,eAAe,CAAC,EAAE,MAAM,GACzB,iBAAiB,CAMnB"}

package/dist/dynamic-nodes.js

@@ -11,19 +11,18 @@ import * as esbuild from "esbuild-wasm";
  * `@motionscript/sdk` barrel (that package depends on `core`, so the reverse
  * would be circular) — `browser` is where this concern actually belongs: the
  * package whose entire job is "what running in an actual browser tab looks
- * like" already owns `getCanvasKit`/`WebAudioSink`/`WebTicker` on exactly that
+ * like" already owns the renderer, `WebAudioSink` and `WebTicker` on exactly that
  * basis.
  */
 // Default to the wasm shipped by esbuild-wasm, resolved lazily — `import.meta.url`
 // is empty in a non-ESM output (an IIFE bundle, which is what the headless page
 // loads), and `new URL("…", "")` throws on import, before a caller has had the
 // chance to pass an explicit URL that would have made the default irrelevant.
-// Mirrors `getCanvasKit`'s own `defaultWasmUrl` in `getter.ts`.
 function defaultCompilerWasmUrl() {
     return new URL("esbuild-wasm/esbuild.wasm", import.meta.url).href;
 }
 let compilerPromise;
-/** Loaded once, memoized process-wide — mirrors how `getCanvasKit` is shared. */
+/** Loaded once, memoized process-wide. */
 function defaultCompiler(wasmUrl) {
     return (compilerPromise ??= (async () => {
         await esbuild.initialize({ wasmURL: wasmUrl ?? defaultCompilerWasmUrl() });

package/dist/dynamic-nodes.js.map

@@ -1 +1 @@
-{"version":3,"file":"dynamic-nodes.js","sourceRoot":"","sources":["../src/dynamic-nodes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,GAAG,MAAM,wBAAwB,CAAC;AAC9C,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AAExC;;;;;;;;;;;;;GAaG;AAEH,mFAAmF;AACnF,gFAAgF;AAChF,+EAA+E;AAC/E,8EAA8E;AAC9E,gEAAgE;AAChE,SAAS,sBAAsB;IAC3B,OAAO,IAAI,GAAG,CAAC,2BAA2B,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC;AACtE,CAAC;AAED,IAAI,eAAyE,CAAC;AAE9E,iFAAiF;AACjF,SAAS,eAAe,CAAC,OAAgB;IACrC,OAAO,CAAC,eAAe,KAAK,CAAC,KAAK,IAAI,EAAE;QACpC,MAAM,OAAO,CAAC,UAAU,CAAC,EAAE,OAAO,EAAE,OAAO,IAAI,sBAAsB,EAAE,EAAE,CAAC,CAAC;QAC3E,OAAO,KAAK,EAAE,MAAc,EAAE,EAAE;YAC5B,MAAM,EAAE,IAAI,EAAE,GAAG,MAAM,OAAO,CAAC,SAAS,CAAC,MAAM,EAAE;gBAC7C,iEAAiE;gBACjE,MAAM,EAAE,IAAI;gBACZ,MAAM,EAAE,KAAK;gBACb,MAAM,EAAE,QAAQ;aACnB,CAAC,CAAC;YACH,OAAO,IAAI,CAAC;QAChB,CAAC,CAAC;IACN,CAAC,CAAC,EAAE,CAAC,CAAC;AACV,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,mBAAmB,CAC/B,OAA+C,EAC/C,eAAwB;IAExB,OAAO;QACH,GAAG,EAAE,OAAO,EAAE,GAAG,IAAI,GAAG;QACxB,OAAO,EAAE,OAAO,EAAE,OAAO;QACzB,OAAO,EAAE,OAAO,EAAE,OAAO,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,CAAC,CAAC,MAAM,eAAe,CAAC,eAAe,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;KACpG,CAAC;AACN,CAAC","sourcesContent":["import type { DynamicNodeConfig } from \"@motionscript/core\";\r\nimport * as sdk from \"@motionscript/core/sdk\";\r\nimport * as esbuild from \"esbuild-wasm\";\r\n\r\n/**\r\n * `browser`'s real, working default for `Registry.addNodeFromSource` — the\r\n * `sdk` half is cheap (re-exports, no WASM) and imported eagerly; the compiler\r\n * is the expensive half, and stays behind a lazy `import()` so an app that\r\n * never registers a source-string node never pays for it, however long the\r\n * engine has been running.\r\n *\r\n * `core` has no compiler dependency of its own and cannot import the published\r\n * `@motionscript/sdk` barrel (that package depends on `core`, so the reverse\r\n * would be circular) — `browser` is where this concern actually belongs: the\r\n * package whose entire job is \"what running in an actual browser tab looks\r\n * like\" already owns `getCanvasKit`/`WebAudioSink`/`WebTicker` on exactly that\r\n * basis.\r\n */\r\n\r\n// Default to the wasm shipped by esbuild-wasm, resolved lazily — `import.meta.url`\r\n// is empty in a non-ESM output (an IIFE bundle, which is what the headless page\r\n// loads), and `new URL(\"…\", \"\")` throws on import, before a caller has had the\r\n// chance to pass an explicit URL that would have made the default irrelevant.\r\n// Mirrors `getCanvasKit`'s own `defaultWasmUrl` in `getter.ts`.\r\nfunction defaultCompilerWasmUrl(): string {\r\n    return new URL(\"esbuild-wasm/esbuild.wasm\", import.meta.url).href;\r\n}\r\n\r\nlet compilerPromise: Promise<(source: string) => Promise<string>> | undefined;\r\n\r\n/** Loaded once, memoized process-wide — mirrors how `getCanvasKit` is shared. */\r\nfunction defaultCompiler(wasmUrl?: string): Promise<(source: string) => Promise<string>> {\r\n    return (compilerPromise ??= (async () => {\r\n        await esbuild.initialize({ wasmURL: wasmUrl ?? defaultCompilerWasmUrl() });\r\n        return async (source: string) => {\r\n            const { code } = await esbuild.transform(source, {\r\n                // A component is written with calls: there is no JSX to compile.\r\n                loader: \"ts\",\r\n                format: \"cjs\",\r\n                target: \"es2020\",\r\n            });\r\n            return code;\r\n        };\r\n    })());\r\n}\r\n\r\n/**\r\n * Resolves a full `DynamicNodeConfig`, filling in whatever the caller left\r\n * unset with `browser`'s own default. Synchronous — the WASM import happens\r\n * on `compile`'s first actual call, not here, so attaching this to every\r\n * engine costs nothing until a source string is genuinely registered.\r\n */\r\nexport function resolveDynamicNodes(\r\n    partial: Partial<DynamicNodeConfig> | undefined,\r\n    compilerWasmUrl?: string,\r\n): DynamicNodeConfig {\r\n    return {\r\n        sdk: partial?.sdk ?? sdk,\r\n        modules: partial?.modules,\r\n        compile: partial?.compile ?? (async (source) => (await defaultCompiler(compilerWasmUrl))(source)),\r\n    };\r\n}\r\n"]}
+{"version":3,"file":"dynamic-nodes.js","sourceRoot":"","sources":["../src/dynamic-nodes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,GAAG,MAAM,wBAAwB,CAAC;AAC9C,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AAExC;;;;;;;;;;;;;GAaG;AAEH,mFAAmF;AACnF,gFAAgF;AAChF,+EAA+E;AAC/E,8EAA8E;AAC9E,SAAS,sBAAsB;IAC3B,OAAO,IAAI,GAAG,CAAC,2BAA2B,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC;AACtE,CAAC;AAED,IAAI,eAAyE,CAAC;AAE9E,0CAA0C;AAC1C,SAAS,eAAe,CAAC,OAAgB;IACrC,OAAO,CAAC,eAAe,KAAK,CAAC,KAAK,IAAI,EAAE;QACpC,MAAM,OAAO,CAAC,UAAU,CAAC,EAAE,OAAO,EAAE,OAAO,IAAI,sBAAsB,EAAE,EAAE,CAAC,CAAC;QAC3E,OAAO,KAAK,EAAE,MAAc,EAAE,EAAE;YAC5B,MAAM,EAAE,IAAI,EAAE,GAAG,MAAM,OAAO,CAAC,SAAS,CAAC,MAAM,EAAE;gBAC7C,iEAAiE;gBACjE,MAAM,EAAE,IAAI;gBACZ,MAAM,EAAE,KAAK;gBACb,MAAM,EAAE,QAAQ;aACnB,CAAC,CAAC;YACH,OAAO,IAAI,CAAC;QAChB,CAAC,CAAC;IACN,CAAC,CAAC,EAAE,CAAC,CAAC;AACV,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,mBAAmB,CAC/B,OAA+C,EAC/C,eAAwB;IAExB,OAAO;QACH,GAAG,EAAE,OAAO,EAAE,GAAG,IAAI,GAAG;QACxB,OAAO,EAAE,OAAO,EAAE,OAAO;QACzB,OAAO,EAAE,OAAO,EAAE,OAAO,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,CAAC,CAAC,MAAM,eAAe,CAAC,eAAe,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;KACpG,CAAC;AACN,CAAC","sourcesContent":["import type { DynamicNodeConfig } from \"@motionscript/core\";\r\nimport * as sdk from \"@motionscript/core/sdk\";\r\nimport * as esbuild from \"esbuild-wasm\";\r\n\r\n/**\r\n * `browser`'s real, working default for `Registry.addNodeFromSource` — the\r\n * `sdk` half is cheap (re-exports, no WASM) and imported eagerly; the compiler\r\n * is the expensive half, and stays behind a lazy `import()` so an app that\r\n * never registers a source-string node never pays for it, however long the\r\n * engine has been running.\r\n *\r\n * `core` has no compiler dependency of its own and cannot import the published\r\n * `@motionscript/sdk` barrel (that package depends on `core`, so the reverse\r\n * would be circular) — `browser` is where this concern actually belongs: the\r\n * package whose entire job is \"what running in an actual browser tab looks\r\n * like\" already owns the renderer, `WebAudioSink` and `WebTicker` on exactly that\r\n * basis.\r\n */\r\n\r\n// Default to the wasm shipped by esbuild-wasm, resolved lazily — `import.meta.url`\r\n// is empty in a non-ESM output (an IIFE bundle, which is what the headless page\r\n// loads), and `new URL(\"…\", \"\")` throws on import, before a caller has had the\r\n// chance to pass an explicit URL that would have made the default irrelevant.\r\nfunction defaultCompilerWasmUrl(): string {\r\n    return new URL(\"esbuild-wasm/esbuild.wasm\", import.meta.url).href;\r\n}\r\n\r\nlet compilerPromise: Promise<(source: string) => Promise<string>> | undefined;\r\n\r\n/** Loaded once, memoized process-wide. */\r\nfunction defaultCompiler(wasmUrl?: string): Promise<(source: string) => Promise<string>> {\r\n    return (compilerPromise ??= (async () => {\r\n        await esbuild.initialize({ wasmURL: wasmUrl ?? defaultCompilerWasmUrl() });\r\n        return async (source: string) => {\r\n            const { code } = await esbuild.transform(source, {\r\n                // A component is written with calls: there is no JSX to compile.\r\n                loader: \"ts\",\r\n                format: \"cjs\",\r\n                target: \"es2020\",\r\n            });\r\n            return code;\r\n        };\r\n    })());\r\n}\r\n\r\n/**\r\n * Resolves a full `DynamicNodeConfig`, filling in whatever the caller left\r\n * unset with `browser`'s own default. Synchronous — the WASM import happens\r\n * on `compile`'s first actual call, not here, so attaching this to every\r\n * engine costs nothing until a source string is genuinely registered.\r\n */\r\nexport function resolveDynamicNodes(\r\n    partial: Partial<DynamicNodeConfig> | undefined,\r\n    compilerWasmUrl?: string,\r\n): DynamicNodeConfig {\r\n    return {\r\n        sdk: partial?.sdk ?? sdk,\r\n        modules: partial?.modules,\r\n        compile: partial?.compile ?? (async (source) => (await defaultCompiler(compilerWasmUrl))(source)),\r\n    };\r\n}\r\n"]}