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

package/dist/mix-timeline-audio.d.ts

@@ -1,5 +1,6 @@
 import { Registry, type AssetManifest, type ProjectDocument, type VisualDocument, type Size2D } from "@motionscript/core";
-export interface MixTimelineAudioParams {
+import { type RendererWasmOption } from "./renderer";
+export interface MixTimelineAudioParams extends RendererWasmOption {
     /** A project, or a lone still or composition as the one track of one. */
     document: ProjectDocument | VisualDocument;
     /** The vocabulary its clips compile against. Defaults to what the library ships. */
@@ -10,7 +11,6 @@ export interface MixTimelineAudioParams {
     manifest?: AssetManifest;
     /** Mixdown rate. Defaults to the mixer's own (44100). */
     sampleRate?: number;
-    wasmUrl?: string;
 }
 /**
  * Mix a timeline's audio without rendering a single frame.
@@ -34,9 +34,9 @@ export interface MixTimelineAudioParams {
  * that puts its nodes in the tree, so there is no way to know what plays when
  * without it.
  *
- * Nothing is drawn, so this takes a {@link WebMeasureContext} rather than a render
- * context: discovery lays each clip out, which needs text measured, not
- * rasterized. No canvas, no surface, no GPU.
+ * Nothing is drawn, so this takes the renderer's measure context rather than a
+ * render context: discovery lays each clip out, which needs text measured, not
+ * rasterized. No canvas, no surface, no GPU, so WebGPU is not required.
  */
 export declare function mixTimelineAudio(params: MixTimelineAudioParams): Promise<AudioBuffer | null>;
 //# sourceMappingURL=mix-timeline-audio.d.ts.map

package/dist/mix-timeline-audio.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mix-timeline-audio.d.ts","sourceRoot":"","sources":["../src/mix-timeline-audio.ts"],"names":[],"mappings":"AAAA,OAAO,EAIH,QAAQ,EAER,KAAK,aAAa,EAClB,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,MAAM,EACd,MAAM,oBAAoB,CAAC;AAQ5B,MAAM,WAAW,sBAAsB;IACnC,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,QAAQ,CAAC,EAAE,aAAa,CAAC;IACzB,yDAAyD;IACzD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;CACpB;AAID;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAsB,gBAAgB,CAClC,MAAM,EAAE,sBAAsB,GAC/B,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CA4B7B"}
+{"version":3,"file":"mix-timeline-audio.d.ts","sourceRoot":"","sources":["../src/mix-timeline-audio.ts"],"names":[],"mappings":"AAAA,OAAO,EAIH,QAAQ,EAER,KAAK,aAAa,EAClB,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,MAAM,EACd,MAAM,oBAAoB,CAAC;AAI5B,OAAO,EAAgB,KAAK,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAEnE,MAAM,WAAW,sBAAuB,SAAQ,kBAAkB;IAC9D,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,QAAQ,CAAC,EAAE,aAAa,CAAC;IACzB,yDAAyD;IACzD,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB;AAID;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAsB,gBAAgB,CAClC,MAAM,EAAE,sBAAsB,GAC/B,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CA4B7B"}

package/dist/mix-timeline-audio.js

@@ -1,9 +1,7 @@
 import { DEFAULT_OUTPUT, ManifestAssetCatalog, AssetTimeline, Registry, resolveProjectDocument, } from "@motionscript/core";
-import { collectAudio } from "@motionscript/skia-render/export";
+import { collectAudio } from "./frame-loop";
 import { mixAudio } from "./audio/mixer";
-import { getCanvasKit } from "./getter";
-import { WebMeasureContext } from "./measure-context";
-import { WebStorageAdapter } from "./storage-adapter";
+import { loadRenderer } from "./renderer";
 const EMPTY_MANIFEST = { image: {}, video: {}, audio: {}, font: {} };
 /**
  * Mix a timeline's audio without rendering a single frame.
@@ -27,22 +25,22 @@ const EMPTY_MANIFEST = { image: {}, video: {}, audio: {}, font: {} };
  * that puts its nodes in the tree, so there is no way to know what plays when
  * without it.
  *
- * Nothing is drawn, so this takes a {@link WebMeasureContext} rather than a render
- * context: discovery lays each clip out, which needs text measured, not
- * rasterized. No canvas, no surface, no GPU.
+ * Nothing is drawn, so this takes the renderer's measure context rather than a
+ * render context: discovery lays each clip out, which needs text measured, not
+ * rasterized. No canvas, no surface, no GPU, so WebGPU is not required.
  */
 export async function mixTimelineAudio(params) {
-    const { registry = new Registry(), manifest = EMPTY_MANIFEST, sampleRate, wasmUrl } = params;
+    const { registry = new Registry(), manifest = EMPTY_MANIFEST, sampleRate } = params;
     const project = resolveProjectDocument(params.document, params, DEFAULT_OUTPUT);
     if (project.tracks.length === 0)
         return null;
     const viewport = project.viewport;
     const fps = project.fps;
-    // CanvasKit only for its font manager — `WebMeasureContext` shapes text through it.
-    const canvasKit = await getCanvasKit(wasmUrl);
+    // The renderer only for its text shaper; nothing is drawn.
+    const renderer = await loadRenderer(params, { gpu: false });
     const catalog = new ManifestAssetCatalog(manifest);
-    const storage = new WebStorageAdapter(canvasKit, catalog, viewport, fps);
-    const measurer = new WebMeasureContext(storage);
+    const storage = renderer.createStorageAdapter({ catalog, viewport, fps });
+    const measurer = renderer.createMeasureContext(storage);
     // Audio is declared from each node's arrival state, so no asset windows are refined.
     const precomper = new AssetTimeline(project, { registry, viewport, fps, assets: catalog, measurer }, { assets: false });
     try {

package/dist/mix-timeline-audio.js.map

@@ -1 +1 @@
-{"version":3,"file":"mix-timeline-audio.js","sourceRoot":"","sources":["../src/mix-timeline-audio.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,cAAc,EACd,oBAAoB,EACpB,aAAa,EACb,QAAQ,EACR,sBAAsB,GAKzB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAEhE,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACxC,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAgBtD,MAAM,cAAc,GAAkB,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC;AAEpF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CAClC,MAA8B;IAE9B,MAAM,EAAE,QAAQ,GAAG,IAAI,QAAQ,EAAE,EAAE,QAAQ,GAAG,cAAc,EAAE,UAAU,EAAE,OAAO,EAAE,GAAG,MAAM,CAAC;IAC7F,MAAM,OAAO,GAAG,sBAAsB,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,cAAc,CAAC,CAAC;IAChF,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IAC7C,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAS,CAAC;IACnC,MAAM,GAAG,GAAG,OAAO,CAAC,GAAI,CAAC;IAEzB,oFAAoF;IACpF,MAAM,SAAS,GAAG,MAAM,YAAY,CAAC,OAAO,CAAC,CAAC;IAC9C,MAAM,OAAO,GAAG,IAAI,oBAAoB,CAAC,QAAQ,CAAC,CAAC;IACnD,MAAM,OAAO,GAAG,IAAI,iBAAiB,CAAC,SAAS,EAAE,OAAO,EAAE,QAAQ,EAAE,GAAG,CAAC,CAAC;IACzE,MAAM,QAAQ,GAAG,IAAI,iBAAiB,CAAC,OAAO,CAAC,CAAC;IAEhD,qFAAqF;IACrF,MAAM,SAAS,GAAG,IAAI,aAAa,CAAC,OAAO,EAAE,EAAE,QAAQ,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC;IACxH,IAAI,CAAC;QACD,MAAM,OAAO,GAAG,SAAS,CAAC,GAAG,EAAE,CAAC;QAEhC,MAAM,SAAS,GAAG,YAAY,CAAC,OAAO,CAAC,CAAC;QACxC,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,IAAI,CAAC;QAExC,OAAO,MAAM,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC,aAAa,EAAE,EAAE,UAAU,EAAE,OAAO,EAAE,CAAC,CAAC;IACrF,CAAC;YAAS,CAAC;QACP,SAAS,CAAC,OAAO,EAAE,CAAC;QACpB,0EAA0E;QAC1E,uCAAuC;QACvC,OAAO,CAAC,OAAO,EAAE,CAAC;IACtB,CAAC;AACL,CAAC","sourcesContent":["import {\r\n    DEFAULT_OUTPUT,\r\n    ManifestAssetCatalog,\r\n    AssetTimeline,\r\n    Registry,\r\n    resolveProjectDocument,\r\n    type AssetManifest,\r\n    type ProjectDocument,\r\n    type VisualDocument,\r\n    type Size2D,\r\n} from \"@motionscript/core\";\r\nimport { collectAudio } from \"@motionscript/skia-render/export\";\r\n\r\nimport { mixAudio } from \"./audio/mixer\";\r\nimport { getCanvasKit } from \"./getter\";\r\nimport { WebMeasureContext } from \"./measure-context\";\r\nimport { WebStorageAdapter } from \"./storage-adapter\";\r\n\r\nexport interface MixTimelineAudioParams {\r\n    /** A project, or a lone still or composition as the one track of one. */\r\n    document: ProjectDocument | VisualDocument;\r\n    /** The vocabulary its clips compile against. Defaults to what the library ships. */\r\n    registry?: Registry;\r\n    /** Win over the document's own; 1920×1080 at 60 fps when neither says. */\r\n    viewport?: Size2D;\r\n    fps?: number;\r\n    manifest?: AssetManifest;\r\n    /** Mixdown rate. Defaults to the mixer's own (44100). */\r\n    sampleRate?: number;\r\n    wasmUrl?: string;\r\n}\r\n\r\nconst EMPTY_MANIFEST: AssetManifest = { image: {}, video: {}, audio: {}, font: {} };\r\n\r\n/**\r\n * Mix a timeline's audio without rendering a single frame.\r\n *\r\n * `exportVideo` normally does this as part of the render, and for a\r\n * single-threaded export that is exactly right. A **split** export cannot: its\r\n * video is rendered in pieces by separate workers, and concatenating\r\n * separately-encoded AAC puts the encoder's priming delay at every join — a click\r\n * at each boundary and a track that drifts further out of sync with every one. So\r\n * the coordinator mixes the whole timeline once, here, and the joined file gets a\r\n * single continuous audio track.\r\n *\r\n * Returns `null` when the timeline schedules no audio at all, which is the common\r\n * case and not a failure — the caller should then mux video only rather than\r\n * declare an empty track.\r\n *\r\n * ## Why this discovers\r\n *\r\n * Audio requests are an *output of discovery*: each node declares its clips as it\r\n * enters the tree, and the pass that finds what a clip's frames draw is the one\r\n * that puts its nodes in the tree, so there is no way to know what plays when\r\n * without it.\r\n *\r\n * Nothing is drawn, so this takes a {@link WebMeasureContext} rather than a render\r\n * context: discovery lays each clip out, which needs text measured, not\r\n * rasterized. No canvas, no surface, no GPU.\r\n */\r\nexport async function mixTimelineAudio(\r\n    params: MixTimelineAudioParams,\r\n): Promise<AudioBuffer | null> {\r\n    const { registry = new Registry(), manifest = EMPTY_MANIFEST, sampleRate, wasmUrl } = params;\r\n    const project = resolveProjectDocument(params.document, params, DEFAULT_OUTPUT);\r\n    if (project.tracks.length === 0) return null;\r\n    const viewport = project.viewport!;\r\n    const fps = project.fps!;\r\n\r\n    // CanvasKit only for its font manager — `WebMeasureContext` shapes text through it.\r\n    const canvasKit = await getCanvasKit(wasmUrl);\r\n    const catalog = new ManifestAssetCatalog(manifest);\r\n    const storage = new WebStorageAdapter(canvasKit, catalog, viewport, fps);\r\n    const measurer = new WebMeasureContext(storage);\r\n\r\n    // Audio is declared from each node's arrival state, so no asset windows are refined.\r\n    const precomper = new AssetTimeline(project, { registry, viewport, fps, assets: catalog, measurer }, { assets: false });\r\n    try {\r\n        const precomp = precomper.run();\r\n\r\n        const scheduled = collectAudio(precomp);\r\n        if (scheduled.length === 0) return null;\r\n\r\n        return await mixAudio(scheduled, precomp.totalDuration, { sampleRate, catalog });\r\n    } finally {\r\n        precomper.dispose();\r\n        // The adapter holds decode sessions and cached images; without this a mix\r\n        // leaks them for the life of the page.\r\n        storage.dispose();\r\n    }\r\n}\r\n"]}
+{"version":3,"file":"mix-timeline-audio.js","sourceRoot":"","sources":["../src/mix-timeline-audio.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,cAAc,EACd,oBAAoB,EACpB,aAAa,EACb,QAAQ,EACR,sBAAsB,GAKzB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAE5C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,YAAY,EAA2B,MAAM,YAAY,CAAC;AAenE,MAAM,cAAc,GAAkB,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC;AAEpF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CAClC,MAA8B;IAE9B,MAAM,EAAE,QAAQ,GAAG,IAAI,QAAQ,EAAE,EAAE,QAAQ,GAAG,cAAc,EAAE,UAAU,EAAE,GAAG,MAAM,CAAC;IACpF,MAAM,OAAO,GAAG,sBAAsB,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,cAAc,CAAC,CAAC;IAChF,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IAC7C,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAS,CAAC;IACnC,MAAM,GAAG,GAAG,OAAO,CAAC,GAAI,CAAC;IAEzB,2DAA2D;IAC3D,MAAM,QAAQ,GAAG,MAAM,YAAY,CAAC,MAAM,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC,CAAC;IAC5D,MAAM,OAAO,GAAG,IAAI,oBAAoB,CAAC,QAAQ,CAAC,CAAC;IACnD,MAAM,OAAO,GAAG,QAAQ,CAAC,oBAAoB,CAAC,EAAE,OAAO,EAAE,QAAQ,EAAE,GAAG,EAAE,CAAC,CAAC;IAC1E,MAAM,QAAQ,GAAG,QAAQ,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAC;IAExD,qFAAqF;IACrF,MAAM,SAAS,GAAG,IAAI,aAAa,CAAC,OAAO,EAAE,EAAE,QAAQ,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC;IACxH,IAAI,CAAC;QACD,MAAM,OAAO,GAAG,SAAS,CAAC,GAAG,EAAE,CAAC;QAEhC,MAAM,SAAS,GAAG,YAAY,CAAC,OAAO,CAAC,CAAC;QACxC,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,IAAI,CAAC;QAExC,OAAO,MAAM,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC,aAAa,EAAE,EAAE,UAAU,EAAE,OAAO,EAAE,CAAC,CAAC;IACrF,CAAC;YAAS,CAAC;QACP,SAAS,CAAC,OAAO,EAAE,CAAC;QACpB,0EAA0E;QAC1E,uCAAuC;QACvC,OAAO,CAAC,OAAO,EAAE,CAAC;IACtB,CAAC;AACL,CAAC","sourcesContent":["import {\r\n    DEFAULT_OUTPUT,\r\n    ManifestAssetCatalog,\r\n    AssetTimeline,\r\n    Registry,\r\n    resolveProjectDocument,\r\n    type AssetManifest,\r\n    type ProjectDocument,\r\n    type VisualDocument,\r\n    type Size2D,\r\n} from \"@motionscript/core\";\r\nimport { collectAudio } from \"./frame-loop\";\r\n\r\nimport { mixAudio } from \"./audio/mixer\";\r\nimport { loadRenderer, type RendererWasmOption } from \"./renderer\";\r\n\r\nexport interface MixTimelineAudioParams extends RendererWasmOption {\r\n    /** A project, or a lone still or composition as the one track of one. */\r\n    document: ProjectDocument | VisualDocument;\r\n    /** The vocabulary its clips compile against. Defaults to what the library ships. */\r\n    registry?: Registry;\r\n    /** Win over the document's own; 1920×1080 at 60 fps when neither says. */\r\n    viewport?: Size2D;\r\n    fps?: number;\r\n    manifest?: AssetManifest;\r\n    /** Mixdown rate. Defaults to the mixer's own (44100). */\r\n    sampleRate?: number;\r\n}\r\n\r\nconst EMPTY_MANIFEST: AssetManifest = { image: {}, video: {}, audio: {}, font: {} };\r\n\r\n/**\r\n * Mix a timeline's audio without rendering a single frame.\r\n *\r\n * `exportVideo` normally does this as part of the render, and for a\r\n * single-threaded export that is exactly right. A **split** export cannot: its\r\n * video is rendered in pieces by separate workers, and concatenating\r\n * separately-encoded AAC puts the encoder's priming delay at every join — a click\r\n * at each boundary and a track that drifts further out of sync with every one. So\r\n * the coordinator mixes the whole timeline once, here, and the joined file gets a\r\n * single continuous audio track.\r\n *\r\n * Returns `null` when the timeline schedules no audio at all, which is the common\r\n * case and not a failure — the caller should then mux video only rather than\r\n * declare an empty track.\r\n *\r\n * ## Why this discovers\r\n *\r\n * Audio requests are an *output of discovery*: each node declares its clips as it\r\n * enters the tree, and the pass that finds what a clip's frames draw is the one\r\n * that puts its nodes in the tree, so there is no way to know what plays when\r\n * without it.\r\n *\r\n * Nothing is drawn, so this takes the renderer's measure context rather than a\r\n * render context: discovery lays each clip out, which needs text measured, not\r\n * rasterized. No canvas, no surface, no GPU, so WebGPU is not required.\r\n */\r\nexport async function mixTimelineAudio(\r\n    params: MixTimelineAudioParams,\r\n): Promise<AudioBuffer | null> {\r\n    const { registry = new Registry(), manifest = EMPTY_MANIFEST, sampleRate } = params;\r\n    const project = resolveProjectDocument(params.document, params, DEFAULT_OUTPUT);\r\n    if (project.tracks.length === 0) return null;\r\n    const viewport = project.viewport!;\r\n    const fps = project.fps!;\r\n\r\n    // The renderer only for its text shaper; nothing is drawn.\r\n    const renderer = await loadRenderer(params, { gpu: false });\r\n    const catalog = new ManifestAssetCatalog(manifest);\r\n    const storage = renderer.createStorageAdapter({ catalog, viewport, fps });\r\n    const measurer = renderer.createMeasureContext(storage);\r\n\r\n    // Audio is declared from each node's arrival state, so no asset windows are refined.\r\n    const precomper = new AssetTimeline(project, { registry, viewport, fps, assets: catalog, measurer }, { assets: false });\r\n    try {\r\n        const precomp = precomper.run();\r\n\r\n        const scheduled = collectAudio(precomp);\r\n        if (scheduled.length === 0) return null;\r\n\r\n        return await mixAudio(scheduled, precomp.totalDuration, { sampleRate, catalog });\r\n    } finally {\r\n        precomper.dispose();\r\n        // The adapter holds decode sessions and cached images; without this a mix\r\n        // leaks them for the life of the page.\r\n        storage.dispose();\r\n    }\r\n}\r\n"]}

package/dist/parallel/export-parallel.d.ts

@@ -0,0 +1,32 @@
+import { type ConcatOptions } from "../concat";
+import { type ExportParams } from "../exporter";
+import type { ExportLane } from "./lane";
+export interface ParallelExportParams extends Omit<ExportParams, "frames" | "returnBytes" | "filename"> {
+    /**
+     * Where the frames are drawn, most preferred first. Every run starts on the
+     * first alone and admits the next only while that raises throughput (see
+     * `LaneGovernor`), so the first should be the warmest: usually `localLane()`.
+     */
+    lanes: readonly ExportLane[];
+    /** Write the file here as it is joined; the call then resolves to an empty array. See `ConcatOptions.stream`. */
+    stream?: ConcatOptions["stream"];
+    /** Seconds per chunk; by default from the timeline's length and the lane count. */
+    chunkSeconds?: number;
+    /** Handed to every lane in its spec, for what only the host knows (see `serveExportLane`). */
+    host?: unknown;
+    /** How many lanes are rendering, each time that changes. */
+    onLanes?: (active: number) => void;
+}
+/**
+ * {@link exportVideo}, rendered in chunks across `lanes` and joined into one
+ * file without re-encoding.
+ *
+ * Each chunk is a frame range of the **whole** project, so layered and gapped
+ * timelines split like any other. Every chunk is encoded with one pinned
+ * configuration, the audio is mixed once over the whole timeline while the frames
+ * render (joined AAC would click at every seam), and each chunk is muxed the
+ * moment it and the ones before it are done. Progress is frames drawn across
+ * every lane, so it climbs smoothly and never goes back.
+ */
+export declare function exportVideoParallel(params: ParallelExportParams): Promise<Uint8Array>;
+//# sourceMappingURL=export-parallel.d.ts.map

package/dist/parallel/export-parallel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export-parallel.d.ts","sourceRoot":"","sources":["../../src/parallel/export-parallel.ts"],"names":[],"mappings":"AACA,OAAO,EAAuB,KAAK,aAAa,EAAE,MAAM,WAAW,CAAC;AACpE,OAAO,EAA4D,KAAK,YAAY,EAAE,MAAM,aAAa,CAAC;AAG1G,OAAO,KAAK,EAAE,UAAU,EAAe,MAAM,QAAQ,CAAC;AAItD,MAAM,WAAW,oBAAqB,SAAQ,IAAI,CAAC,YAAY,EAAE,QAAQ,GAAG,aAAa,GAAG,UAAU,CAAC;IACnG;;;;OAIG;IACH,KAAK,EAAE,SAAS,UAAU,EAAE,CAAC;IAC7B,iHAAiH;IACjH,MAAM,CAAC,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAC;IACjC,mFAAmF;IACnF,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,8FAA8F;IAC9F,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,4DAA4D;IAC5D,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;CACtC;AAOD;;;;;;;;;;GAUG;AACH,wBAAsB,mBAAmB,CAAC,MAAM,EAAE,oBAAoB,GAAG,OAAO,CAAC,UAAU,CAAC,CA4F3F"}

package/dist/parallel/export-parallel.js

@@ -0,0 +1,114 @@
+import { DEFAULT_OUTPUT, placeTracks, Registry, renderIssueKey, resolveProjectDocument, totalFramesOf } from "@motionscript/core";
+import { createSegmentJoiner } from "../concat";
+import { exportGeometry, plainVideoEncoding, resolveVideoEncoding } from "../exporter";
+import { formatSpec } from "../formats";
+import { mixTimelineAudio } from "../mix-timeline-audio";
+import { planChunks } from "./plan";
+import { runLanes } from "./run-lanes";
+const EMPTY_MANIFEST = { image: {}, video: {}, audio: {}, font: {} };
+const DEFAULT_SUPERSAMPLE = 2;
+/** The share of progress drawing takes; finishing the file is the rest. */
+const DRAWN = 0.97;
+/**
+ * {@link exportVideo}, rendered in chunks across `lanes` and joined into one
+ * file without re-encoding.
+ *
+ * Each chunk is a frame range of the **whole** project, so layered and gapped
+ * timelines split like any other. Every chunk is encoded with one pinned
+ * configuration, the audio is mixed once over the whole timeline while the frames
+ * render (joined AAC would click at every seam), and each chunk is muxed the
+ * moment it and the ones before it are done. Progress is frames drawn across
+ * every lane, so it climbs smoothly and never goes back.
+ */
+export async function exportVideoParallel(params) {
+    const { registry = new Registry(), scale = 1, format = "mp4", manifest = EMPTY_MANIFEST, includeAudio = true, audio = {}, signal, onProgress, supersample = DEFAULT_SUPERSAMPLE, } = params;
+    if (formatSpec(format).kind !== "video") {
+        throw new RangeError(`exportVideoParallel writes video; "${format}" is audio, which exportAudio writes.`);
+    }
+    const project = resolveProjectDocument(params.document, params, DEFAULT_OUTPUT);
+    if (project.tracks.length === 0)
+        throw new Error("exportVideoParallel: the project has no tracks.");
+    signal?.throwIfAborted();
+    const fps = project.fps;
+    const totalFrames = totalFramesOf(placeTracks(project.tracks, fps));
+    const { output } = exportGeometry(project.viewport, scale, supersample);
+    const encoding = plainVideoEncoding(await resolveVideoEncoding(params.video, format, output, fps), output);
+    const spec = {
+        project, manifest, theme: params.theme, scale, supersample, format, encoding, host: params.host,
+    };
+    const chunks = planChunks(totalFrames, {
+        fps, keyFrameInterval: encoding.keyFrameInterval, lanes: params.lanes.length, chunkSeconds: params.chunkSeconds,
+    });
+    // Started now so it is ready by the first join; failures surface there.
+    const mixed = includeAudio
+        ? mixTimelineAudio({
+            document: project, registry, manifest, sampleRate: audio.sampleRate,
+            rendererWasmUrl: params.rendererWasmUrl,
+        })
+        : Promise.resolve(null);
+    mixed.catch(() => { });
+    let reported = 0;
+    const seenIssues = new Set();
+    const report = (p) => {
+        if (p <= reported)
+            return;
+        reported = p;
+        onProgress?.(p);
+    };
+    // One signal for both ways a run ends early: the caller cancelling, and the join failing.
+    const run = new AbortController();
+    const abortRun = () => run.abort(signal?.reason);
+    if (signal?.aborted)
+        abortRun();
+    signal?.addEventListener("abort", abortRun, { once: true });
+    // Keyed by first frame: a merged range spans several planned chunks.
+    const ready = new Map();
+    let joinedTo = 0;
+    let joining = Promise.resolve();
+    let joiner = null;
+    const pump = () => {
+        joining = joining.then(async () => {
+            while (ready.has(joinedTo)) {
+                joiner ??= createSegmentJoiner({ stream: params.stream, audio: await mixed, audioBitrate: audio.bitrate });
+                const { end, bytes } = ready.get(joinedTo);
+                ready.delete(joinedTo);
+                joinedTo = end;
+                await joiner.append(bytes);
+            }
+        });
+        return joining;
+    };
+    try {
+        await runLanes({
+            lanes: params.lanes, spec, chunks, signal: run.signal,
+            onIssue: (issue) => {
+                const key = renderIssueKey(issue);
+                if (seenIssues.has(key))
+                    return;
+                seenIssues.add(key);
+                params.onIssue?.(issue);
+            },
+            onFrames: (frames) => report(DRAWN * Math.min(1, frames / totalFrames)),
+            onActive: params.onLanes,
+            onChunk: (chunk, bytes) => {
+                ready.set(chunk.start, { end: chunk.end, bytes });
+                pump().catch((error) => run.abort(error));
+            },
+        });
+        await pump();
+        if (joinedTo !== totalFrames)
+            throw new Error(`exportVideoParallel: joined ${joinedTo} of ${totalFrames} frames.`);
+        const bytes = await joiner.finish();
+        report(1);
+        return bytes;
+    }
+    catch (error) {
+        await joining.catch(() => { });
+        await joiner?.cancel().catch(() => { });
+        throw error;
+    }
+    finally {
+        signal?.removeEventListener("abort", abortRun);
+    }
+}
+//# sourceMappingURL=export-parallel.js.map

package/dist/parallel/export-parallel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"export-parallel.js","sourceRoot":"","sources":["../../src/parallel/export-parallel.ts"],"names":[],"mappings":"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","sourcesContent":["import { DEFAULT_OUTPUT, placeTracks, Registry, renderIssueKey, resolveProjectDocument, totalFramesOf, type AssetManifest } from \"@motionscript/core\";\r\nimport { createSegmentJoiner, type ConcatOptions } from \"../concat\";\r\nimport { exportGeometry, plainVideoEncoding, resolveVideoEncoding, type ExportParams } from \"../exporter\";\r\nimport { formatSpec } from \"../formats\";\r\nimport { mixTimelineAudio } from \"../mix-timeline-audio\";\r\nimport type { ExportLane, SegmentSpec } from \"./lane\";\r\nimport { planChunks } from \"./plan\";\r\nimport { runLanes } from \"./run-lanes\";\r\n\r\nexport interface ParallelExportParams extends Omit<ExportParams, \"frames\" | \"returnBytes\" | \"filename\"> {\r\n    /**\r\n     * Where the frames are drawn, most preferred first. Every run starts on the\r\n     * first alone and admits the next only while that raises throughput (see\r\n     * `LaneGovernor`), so the first should be the warmest: usually `localLane()`.\r\n     */\r\n    lanes: readonly ExportLane[];\r\n    /** Write the file here as it is joined; the call then resolves to an empty array. See `ConcatOptions.stream`. */\r\n    stream?: ConcatOptions[\"stream\"];\r\n    /** Seconds per chunk; by default from the timeline's length and the lane count. */\r\n    chunkSeconds?: number;\r\n    /** Handed to every lane in its spec, for what only the host knows (see `serveExportLane`). */\r\n    host?: unknown;\r\n    /** How many lanes are rendering, each time that changes. */\r\n    onLanes?: (active: number) => void;\r\n}\r\n\r\nconst EMPTY_MANIFEST: AssetManifest = { image: {}, video: {}, audio: {}, font: {} };\r\nconst DEFAULT_SUPERSAMPLE = 2;\r\n/** The share of progress drawing takes; finishing the file is the rest. */\r\nconst DRAWN = 0.97;\r\n\r\n/**\r\n * {@link exportVideo}, rendered in chunks across `lanes` and joined into one\r\n * file without re-encoding.\r\n *\r\n * Each chunk is a frame range of the **whole** project, so layered and gapped\r\n * timelines split like any other. Every chunk is encoded with one pinned\r\n * configuration, the audio is mixed once over the whole timeline while the frames\r\n * render (joined AAC would click at every seam), and each chunk is muxed the\r\n * moment it and the ones before it are done. Progress is frames drawn across\r\n * every lane, so it climbs smoothly and never goes back.\r\n */\r\nexport async function exportVideoParallel(params: ParallelExportParams): Promise<Uint8Array> {\r\n    const {\r\n        registry = new Registry(), scale = 1, format = \"mp4\", manifest = EMPTY_MANIFEST,\r\n        includeAudio = true, audio = {}, signal, onProgress, supersample = DEFAULT_SUPERSAMPLE,\r\n    } = params;\r\n    if (formatSpec(format).kind !== \"video\") {\r\n        throw new RangeError(`exportVideoParallel writes video; \"${format}\" is audio, which exportAudio writes.`);\r\n    }\r\n    const project = resolveProjectDocument(params.document, params, DEFAULT_OUTPUT);\r\n    if (project.tracks.length === 0) throw new Error(\"exportVideoParallel: the project has no tracks.\");\r\n    signal?.throwIfAborted();\r\n    const fps = project.fps!;\r\n    const totalFrames = totalFramesOf(placeTracks(project.tracks, fps));\r\n\r\n    const { output } = exportGeometry(project.viewport!, scale, supersample);\r\n    const encoding = plainVideoEncoding(await resolveVideoEncoding(params.video, format, output, fps), output);\r\n    const spec: SegmentSpec = {\r\n        project, manifest, theme: params.theme, scale, supersample, format, encoding, host: params.host,\r\n    };\r\n    const chunks = planChunks(totalFrames, {\r\n        fps, keyFrameInterval: encoding.keyFrameInterval, lanes: params.lanes.length, chunkSeconds: params.chunkSeconds,\r\n    });\r\n\r\n    // Started now so it is ready by the first join; failures surface there.\r\n    const mixed = includeAudio\r\n        ? mixTimelineAudio({\r\n            document: project, registry, manifest, sampleRate: audio.sampleRate,\r\n            rendererWasmUrl: params.rendererWasmUrl,\r\n        })\r\n        : Promise.resolve(null);\r\n    mixed.catch(() => {});\r\n\r\n    let reported = 0;\r\n    const seenIssues = new Set<string>();\r\n    const report = (p: number) => {\r\n        if (p <= reported) return;\r\n        reported = p;\r\n        onProgress?.(p);\r\n    };\r\n\r\n    // One signal for both ways a run ends early: the caller cancelling, and the join failing.\r\n    const run = new AbortController();\r\n    const abortRun = () => run.abort(signal?.reason);\r\n    if (signal?.aborted) abortRun();\r\n    signal?.addEventListener(\"abort\", abortRun, { once: true });\r\n\r\n    // Keyed by first frame: a merged range spans several planned chunks.\r\n    const ready = new Map<number, { end: number; bytes: Uint8Array }>();\r\n    let joinedTo = 0;\r\n    let joining: Promise<void> = Promise.resolve();\r\n    let joiner: ReturnType<typeof createSegmentJoiner> | null = null;\r\n    const pump = () => {\r\n        joining = joining.then(async () => {\r\n            while (ready.has(joinedTo)) {\r\n                joiner ??= createSegmentJoiner({ stream: params.stream, audio: await mixed, audioBitrate: audio.bitrate });\r\n                const { end, bytes } = ready.get(joinedTo)!;\r\n                ready.delete(joinedTo);\r\n                joinedTo = end;\r\n                await joiner.append(bytes);\r\n            }\r\n        });\r\n        return joining;\r\n    };\r\n\r\n    try {\r\n        await runLanes({\r\n            lanes: params.lanes, spec, chunks, signal: run.signal,\r\n            onIssue: (issue) => {\r\n                const key = renderIssueKey(issue);\r\n                if (seenIssues.has(key)) return;\r\n                seenIssues.add(key);\r\n                params.onIssue?.(issue);\r\n            },\r\n            onFrames: (frames) => report(DRAWN * Math.min(1, frames / totalFrames)),\r\n            onActive: params.onLanes,\r\n            onChunk: (chunk, bytes) => {\r\n                ready.set(chunk.start, { end: chunk.end, bytes });\r\n                pump().catch((error: unknown) => run.abort(error));\r\n            },\r\n        });\r\n        await pump();\r\n        if (joinedTo !== totalFrames) throw new Error(`exportVideoParallel: joined ${joinedTo} of ${totalFrames} frames.`);\r\n        const bytes = await joiner!.finish();\r\n        report(1);\r\n        return bytes;\r\n    } catch (error) {\r\n        await joining.catch(() => {});\r\n        await (joiner as ReturnType<typeof createSegmentJoiner> | null)?.cancel().catch(() => {});\r\n        throw error;\r\n    } finally {\r\n        signal?.removeEventListener(\"abort\", abortRun);\r\n    }\r\n}\r\n"]}

package/dist/parallel/governor.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Decides how many lanes render at once, from what the run itself measures.
+ *
+ * Lanes do not add throughput for free. Every lane's encoder, and on a WebGPU
+ * canvas its frame capture, run in the browser's one GPU process, so once a lane
+ * spends its time waiting on the encoder rather than drawing, a second lane only
+ * splits the same encoder between two sessions and the export gets slower. The
+ * governor starts with one lane, adds the next only while lanes are mostly
+ * drawing, keeps it only if total throughput rose, and then settles.
+ */
+export interface GovernorOptions {
+    /** Lanes available, the first being the one every run starts with. */
+    lanes: number;
+    /** How long a configuration is measured before it is judged, in ms. */
+    windowMs?: number;
+    /** Frames a window needs before it is judged. */
+    minFrames?: number;
+    /** Above this share of time waiting on the encoder, another lane cannot help. */
+    maxWaitShare?: number;
+    /** A lane is kept only if it raises throughput by at least this factor. */
+    minGain?: number;
+    /** How long the newest lane draws before it is measured: its first frames wait on loads and a cold encoder. */
+    warmupMs?: number;
+}
+export interface FrameSample {
+    lane: number;
+    frames: number;
+    busyMs: number;
+    waitMs: number;
+    at: number;
+}
+export declare class LaneGovernor {
+    private readonly _options;
+    private _active;
+    private _settled;
+    private _window;
+    private _previousFps;
+    private _newestFirstAt;
+    private readonly _windowMs;
+    private readonly _minFrames;
+    private readonly _maxWaitShare;
+    private readonly _minGain;
+    private readonly _warmupMs;
+    constructor(_options: GovernorOptions);
+    /** Lanes `0..active-1` may take chunks. */
+    get active(): number;
+    get settled(): boolean;
+    /** Stop measuring once a lane dies: the run continues on at most `alive` lanes. */
+    laneLost(alive: number): void;
+    /**
+     * Record frames a lane drew. Returns the new active count when it changed.
+     * A window opens once the newest lane has drawn for `warmupMs`, so its
+     * start-up is not counted against it.
+     */
+    record(sample: FrameSample): number | null;
+}
+//# sourceMappingURL=governor.d.ts.map

package/dist/parallel/governor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"governor.d.ts","sourceRoot":"","sources":["../../src/parallel/governor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,WAAW,eAAe;IAC5B,sEAAsE;IACtE,KAAK,EAAE,MAAM,CAAC;IACd,uEAAuE;IACvE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,iDAAiD;IACjD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iFAAiF;IACjF,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,2EAA2E;IAC3E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,+GAA+G;IAC/G,QAAQ,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,WAAW;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,EAAE,EAAE,MAAM,CAAC;CACd;AASD,qBAAa,YAAY;IAYT,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAXrC,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,QAAQ,CAAU;IAC1B,OAAO,CAAC,OAAO,CAAyB;IACxC,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,cAAc,CAAuB;IAC7C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;gBAEN,QAAQ,EAAE,eAAe;IAStD,2CAA2C;IAC3C,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,IAAI,OAAO,IAAI,OAAO,CAErB;IAED,mFAAmF;IACnF,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAK7B;;;;OAIG;IACH,MAAM,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,GAAG,IAAI;CA+B7C"}

package/dist/parallel/governor.js

@@ -0,0 +1,79 @@
+export class LaneGovernor {
+    _options;
+    _active = 1;
+    _settled;
+    _window = emptyWindow();
+    _previousFps = 0;
+    _newestFirstAt = null;
+    _windowMs;
+    _minFrames;
+    _maxWaitShare;
+    _minGain;
+    _warmupMs;
+    constructor(_options) {
+        this._options = _options;
+        this._windowMs = _options.windowMs ?? 1500;
+        this._minFrames = _options.minFrames ?? 24;
+        this._maxWaitShare = _options.maxWaitShare ?? 0.45;
+        this._minGain = _options.minGain ?? 1.1;
+        this._warmupMs = _options.warmupMs ?? 300;
+        this._settled = _options.lanes <= 1;
+    }
+    /** Lanes `0..active-1` may take chunks. */
+    get active() {
+        return this._active;
+    }
+    get settled() {
+        return this._settled;
+    }
+    /** Stop measuring once a lane dies: the run continues on at most `alive` lanes. */
+    laneLost(alive) {
+        this._active = Math.max(1, Math.min(this._active, alive));
+        this._settled = true;
+    }
+    /**
+     * Record frames a lane drew. Returns the new active count when it changed.
+     * A window opens once the newest lane has drawn for `warmupMs`, so its
+     * start-up is not counted against it.
+     */
+    record(sample) {
+        if (this._settled || sample.lane >= this._active)
+            return null;
+        const w = this._window;
+        if (w.start === null) {
+            if (sample.lane !== this._active - 1)
+                return null;
+            this._newestFirstAt ??= sample.at;
+            if (sample.at - this._newestFirstAt >= this._warmupMs)
+                w.start = sample.at;
+            return null;
+        }
+        w.frames += sample.frames;
+        w.busyMs += sample.busyMs;
+        w.waitMs += sample.waitMs;
+        const elapsed = sample.at - w.start;
+        if (elapsed < this._windowMs || w.frames < this._minFrames)
+            return null;
+        const fps = (w.frames * 1000) / elapsed;
+        const waitShare = w.waitMs / Math.max(1, w.busyMs + w.waitMs);
+        const before = this._active;
+        if (this._active > 1 && fps < this._previousFps * this._minGain) {
+            this._active -= 1;
+            this._settled = true;
+        }
+        else if (waitShare <= this._maxWaitShare && this._active < this._options.lanes) {
+            this._previousFps = fps;
+            this._active += 1;
+        }
+        else {
+            this._settled = true;
+        }
+        this._window = emptyWindow();
+        this._newestFirstAt = null;
+        return this._active !== before ? this._active : null;
+    }
+}
+function emptyWindow() {
+    return { start: null, frames: 0, busyMs: 0, waitMs: 0 };
+}
+//# sourceMappingURL=governor.js.map

package/dist/parallel/governor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"governor.js","sourceRoot":"","sources":["../../src/parallel/governor.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Decides how many lanes render at once, from what the run itself measures.\n *\n * Lanes do not add throughput for free. Every lane's encoder, and on a WebGPU\n * canvas its frame capture, run in the browser's one GPU process, so once a lane\n * spends its time waiting on the encoder rather than drawing, a second lane only\n * splits the same encoder between two sessions and the export gets slower. The\n * governor starts with one lane, adds the next only while lanes are mostly\n * drawing, keeps it only if total throughput rose, and then settles.\n */\nexport interface GovernorOptions {\n    /** Lanes available, the first being the one every run starts with. */\n    lanes: number;\n    /** How long a configuration is measured before it is judged, in ms. */\n    windowMs?: number;\n    /** Frames a window needs before it is judged. */\n    minFrames?: number;\n    /** Above this share of time waiting on the encoder, another lane cannot help. */\n    maxWaitShare?: number;\n    /** A lane is kept only if it raises throughput by at least this factor. */\n    minGain?: number;\n    /** How long the newest lane draws before it is measured: its first frames wait on loads and a cold encoder. */\n    warmupMs?: number;\n}\n\nexport interface FrameSample {\n    lane: number;\n    frames: number;\n    busyMs: number;\n    waitMs: number;\n    at: number;\n}\n\ninterface Window {\n    start: number | null;\n    frames: number;\n    busyMs: number;\n    waitMs: number;\n}\n\nexport class LaneGovernor {\n    private _active = 1;\n    private _settled: boolean;\n    private _window: Window = emptyWindow();\n    private _previousFps = 0;\n    private _newestFirstAt: number | null = null;\n    private readonly _windowMs: number;\n    private readonly _minFrames: number;\n    private readonly _maxWaitShare: number;\n    private readonly _minGain: number;\n    private readonly _warmupMs: number;\n\n    constructor(private readonly _options: GovernorOptions) {\n        this._windowMs = _options.windowMs ?? 1500;\n        this._minFrames = _options.minFrames ?? 24;\n        this._maxWaitShare = _options.maxWaitShare ?? 0.45;\n        this._minGain = _options.minGain ?? 1.1;\n        this._warmupMs = _options.warmupMs ?? 300;\n        this._settled = _options.lanes <= 1;\n    }\n\n    /** Lanes `0..active-1` may take chunks. */\n    get active(): number {\n        return this._active;\n    }\n\n    get settled(): boolean {\n        return this._settled;\n    }\n\n    /** Stop measuring once a lane dies: the run continues on at most `alive` lanes. */\n    laneLost(alive: number): void {\n        this._active = Math.max(1, Math.min(this._active, alive));\n        this._settled = true;\n    }\n\n    /**\n     * Record frames a lane drew. Returns the new active count when it changed.\n     * A window opens once the newest lane has drawn for `warmupMs`, so its\n     * start-up is not counted against it.\n     */\n    record(sample: FrameSample): number | null {\n        if (this._settled || sample.lane >= this._active) return null;\n        const w = this._window;\n        if (w.start === null) {\n            if (sample.lane !== this._active - 1) return null;\n            this._newestFirstAt ??= sample.at;\n            if (sample.at - this._newestFirstAt >= this._warmupMs) w.start = sample.at;\n            return null;\n        }\n        w.frames += sample.frames;\n        w.busyMs += sample.busyMs;\n        w.waitMs += sample.waitMs;\n        const elapsed = sample.at - w.start;\n        if (elapsed < this._windowMs || w.frames < this._minFrames) return null;\n\n        const fps = (w.frames * 1000) / elapsed;\n        const waitShare = w.waitMs / Math.max(1, w.busyMs + w.waitMs);\n        const before = this._active;\n        if (this._active > 1 && fps < this._previousFps * this._minGain) {\n            this._active -= 1;\n            this._settled = true;\n        } else if (waitShare <= this._maxWaitShare && this._active < this._options.lanes) {\n            this._previousFps = fps;\n            this._active += 1;\n        } else {\n            this._settled = true;\n        }\n        this._window = emptyWindow();\n        this._newestFirstAt = null;\n        return this._active !== before ? this._active : null;\n    }\n}\n\nfunction emptyWindow(): Window {\n    return { start: null, frames: 0, busyMs: 0, waitMs: 0 };\n}\n"]}

package/dist/parallel/lane.d.ts

@@ -0,0 +1,45 @@
+import type { AssetManifest, ProjectDocument, Registry, RenderIssue, Theme } from "@motionscript/core";
+import type { RendererWasmOption } from "../renderer";
+import type { ResolvedVideoEncoding } from "../exporter";
+import type { VideoFormat } from "../formats";
+import type { ExportChunk } from "./plan";
+/**
+ * Everything a lane needs to render chunks of one export. Plain data, so it
+ * crosses a `MessagePort` intact; the encoding is pinned here because segments
+ * encoded differently cannot be joined.
+ */
+export interface SegmentSpec {
+    /** Its fps and viewport resolved. */
+    project: ProjectDocument;
+    manifest: AssetManifest;
+    theme?: Theme;
+    scale: number;
+    supersample: number;
+    format: VideoFormat;
+    encoding: ResolvedVideoEncoding;
+    /** Passed through untouched to a remote lane's `resolve`, for what only its host knows. */
+    host?: unknown;
+}
+/** A chunk's frames so far, and how its time split between drawing and waiting on the encoder. */
+export interface LaneReport {
+    frames: number;
+    busyMs: number;
+    waitMs: number;
+    /** Render issues since the lane's last report. */
+    issues?: RenderIssue[];
+}
+/** One lane, open on one export. */
+export interface LaneSession {
+    /** Render the chunk's frames to a complete, silent segment file. */
+    render(chunk: ExportChunk, onReport: (report: LaneReport) => void, signal: AbortSignal): Promise<Uint8Array>;
+    close(): void;
+}
+/** Something that renders chunks: this window, or another realm across a port. */
+export interface ExportLane {
+    open(spec: SegmentSpec, signal: AbortSignal): Promise<LaneSession>;
+}
+/** What a realm renders with: its own registry, and where its renderer's WASM is served. */
+export interface LaneEnvironment extends RendererWasmOption {
+    registry?: Registry;
+}
+//# sourceMappingURL=lane.d.ts.map

package/dist/parallel/lane.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lane.d.ts","sourceRoot":"","sources":["../../src/parallel/lane.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,QAAQ,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AACvG,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AACzD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAE1C;;;;GAIG;AACH,MAAM,WAAW,WAAW;IACxB,qCAAqC;IACrC,OAAO,EAAE,eAAe,CAAC;IACzB,QAAQ,EAAE,aAAa,CAAC;IACxB,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,WAAW,CAAC;IACpB,QAAQ,EAAE,qBAAqB,CAAC;IAChC,2FAA2F;IAC3F,IAAI,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,kGAAkG;AAClG,MAAM,WAAW,UAAU;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,kDAAkD;IAClD,MAAM,CAAC,EAAE,WAAW,EAAE,CAAC;CAC1B;AAED,oCAAoC;AACpC,MAAM,WAAW,WAAW;IACxB,oEAAoE;IACpE,MAAM,CAAC,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,CAAC,MAAM,EAAE,UAAU,KAAK,IAAI,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IAC7G,KAAK,IAAI,IAAI,CAAC;CACjB;AAED,kFAAkF;AAClF,MAAM,WAAW,UAAU;IACvB,IAAI,CAAC,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;CACtE;AAED,4FAA4F;AAC5F,MAAM,WAAW,eAAgB,SAAQ,kBAAkB;IACvD,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACvB"}

package/dist/parallel/lane.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=lane.js.map

package/dist/parallel/lane.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lane.js","sourceRoot":"","sources":["../../src/parallel/lane.ts"],"names":[],"mappings":"","sourcesContent":["import type { AssetManifest, ProjectDocument, Registry, RenderIssue, Theme } from \"@motionscript/core\";\r\nimport type { RendererWasmOption } from \"../renderer\";\r\nimport type { ResolvedVideoEncoding } from \"../exporter\";\r\nimport type { VideoFormat } from \"../formats\";\r\nimport type { ExportChunk } from \"./plan\";\r\n\r\n/**\r\n * Everything a lane needs to render chunks of one export. Plain data, so it\r\n * crosses a `MessagePort` intact; the encoding is pinned here because segments\r\n * encoded differently cannot be joined.\r\n */\r\nexport interface SegmentSpec {\r\n    /** Its fps and viewport resolved. */\r\n    project: ProjectDocument;\r\n    manifest: AssetManifest;\r\n    theme?: Theme;\r\n    scale: number;\r\n    supersample: number;\r\n    format: VideoFormat;\r\n    encoding: ResolvedVideoEncoding;\r\n    /** Passed through untouched to a remote lane's `resolve`, for what only its host knows. */\r\n    host?: unknown;\r\n}\r\n\r\n/** A chunk's frames so far, and how its time split between drawing and waiting on the encoder. */\r\nexport interface LaneReport {\r\n    frames: number;\r\n    busyMs: number;\r\n    waitMs: number;\r\n    /** Render issues since the lane's last report. */\r\n    issues?: RenderIssue[];\r\n}\r\n\r\n/** One lane, open on one export. */\r\nexport interface LaneSession {\r\n    /** Render the chunk's frames to a complete, silent segment file. */\r\n    render(chunk: ExportChunk, onReport: (report: LaneReport) => void, signal: AbortSignal): Promise<Uint8Array>;\r\n    close(): void;\r\n}\r\n\r\n/** Something that renders chunks: this window, or another realm across a port. */\r\nexport interface ExportLane {\r\n    open(spec: SegmentSpec, signal: AbortSignal): Promise<LaneSession>;\r\n}\r\n\r\n/** What a realm renders with: its own registry, and where its renderer's WASM is served. */\r\nexport interface LaneEnvironment extends RendererWasmOption {\r\n    registry?: Registry;\r\n}\r\n"]}

package/dist/parallel/lanes.d.ts

@@ -0,0 +1,20 @@
+import type { ExportLane, LaneEnvironment, SegmentSpec } from "./lane";
+/** A lane that renders in this realm, with its renderer, registry and warm caches. */
+export declare function localLane(env?: LaneEnvironment): ExportLane;
+export interface MessagePortLaneOptions {
+    /** Settles when the realm behind the port is gone, failing whatever it was doing. */
+    lost?: Promise<unknown>;
+}
+/**
+ * A lane on the far side of `port`, which {@link serveExportLane} answers. The
+ * finished segment comes back as a transferred buffer, never a copy.
+ */
+export declare function messagePortLane(port: MessagePort, options?: MessagePortLaneOptions): ExportLane;
+/**
+ * Answer a {@link messagePortLane} from this realm. `resolve` supplies what the
+ * realm renders with, given the spec (its `host` field carries anything the
+ * coordinator's host wanted this side to know). Returns a function that stops
+ * serving and closes every open session.
+ */
+export declare function serveExportLane(port: MessagePort, resolve: (spec: SegmentSpec) => LaneEnvironment | Promise<LaneEnvironment>): () => void;
+//# sourceMappingURL=lanes.d.ts.map

package/dist/parallel/lanes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lanes.d.ts","sourceRoot":"","sources":["../../src/parallel/lanes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAA2B,WAAW,EAAE,MAAM,QAAQ,CAAC;AAIhG,sFAAsF;AACtF,wBAAgB,SAAS,CAAC,GAAG,GAAE,eAAoB,GAAG,UAAU,CAE/D;AAqBD,MAAM,WAAW,sBAAsB;IACnC,qFAAqF;IACrF,IAAI,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;CAC3B;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,WAAW,EAAE,OAAO,GAAE,sBAA2B,GAAG,UAAU,CA4DnG;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC3B,IAAI,EAAE,WAAW,EACjB,OAAO,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,GAC3E,MAAM,IAAI,CA6DZ"}