framefields 2.9.3 → 2.11.0

package/dist/{renderer-Be5hfwSd.mjs → renderer-Bbxh4N8Y.mjs}

@@ -1,9 +1,9 @@
-import { Bt as getMediaType, In as takeRenderDiagnostics, Nt as frameCount, Rn as updateClockSignals, mt as assertFps, yn as resolveFrameRequest } from "./dist-ByxHoMQI.mjs";
-import { a as registerWebGPURenderer, t as audioRegistry } from "./renderer-DrWeb39d.mjs";
-import { K as mediaDecoderCache, L as getRenderer2D, R as initHeadlessWebGPU, W as lutStore, g as WebGPUAudioProcessor, it as shaderStore, j as ensureDevice, p as SlugFontCache, s as NodeSurfaceProvider, st as textureCache, v as clearAllVideoCache, y as clearHeadlessFonts, z as inputStore } from "./dist-D12-a3-x.mjs";
-import { a as preflightMediaTime, h as preloadCompositionFonts, i as mixAudioTracks, r as drawCompositionTree, t as compositionStateStore } from "./dist-DEUU6sNe.mjs";
+import { Bt as getMediaType, In as takeRenderDiagnostics, Nt as frameCount, Rn as updateClockSignals, mt as assertFps, yn as resolveFrameRequest } from "./dist-Bf2_efYP.mjs";
+import { a as registerWebGPURenderer, t as audioRegistry } from "./renderer-DcvjSolU.mjs";
+import { K as mediaDecoderCache, L as getRenderer2D, R as initHeadlessWebGPU, W as lutStore, g as WebGPUAudioProcessor, it as shaderStore, j as ensureDevice, p as SlugFontCache, s as NodeSurfaceProvider, st as textureCache, v as clearAllVideoCache, y as clearHeadlessFonts, z as inputStore } from "./dist-CWLLnigL.mjs";
+import { a as preflightMediaTime, h as preloadCompositionFonts, i as mixAudioTracks, r as drawCompositionTree, t as compositionStateStore } from "./dist-EQX3TUUl.mjs";
 import { createRequire } from "node:module";
-import { AudioSample, AudioSampleSource, FilePathTarget, Mp3OutputFormat, Mp4OutputFormat, Output, QUALITY_HIGH, QUALITY_LOW, QUALITY_VERY_HIGH, QUALITY_VERY_LOW, VideoSample, VideoSampleSource, WebMOutputFormat } from "mediabunny";
+import { ALL_FORMATS, AudioSample, AudioSampleSource, EncodedAudioPacketSource, EncodedPacketSink, EncodedVideoPacketSource, FilePathSource, FilePathTarget, Input, Mp3OutputFormat, Mp4OutputFormat, Output, QUALITY_HIGH, QUALITY_LOW, QUALITY_VERY_HIGH, QUALITY_VERY_LOW, VideoSample, VideoSampleSource, WebMOutputFormat } from "mediabunny";
 import fs from "node:fs";
 import path from "node:path";
 import { Canvas, Image, loadImage } from "skia-canvas";
@@ -18,7 +18,7 @@ import { exec, spawn } from "node:child_process";
 import sharp from "sharp";
 import { registerMediabunnyServer } from "@mediabunny/server";
 
-//#region ../renderer/dist/headless-webgpu-renderer-zoSy7emo.mjs
+//#region ../renderer/dist/headless-webgpu-renderer-qPWYs6BY.mjs
 const env = typeof process !== "undefined" ? process.env : void 0;
 /**
 * "json" (pino lines, for log collectors) or "text" (one short line each, for
@@ -277,347 +277,347 @@ const BUILTIN_NODE_RENDERERS = [
 	{
 		packageName: "@framefields/node-lut",
 		ops: ["ApplyLUT"],
-		load: () => import("./renderer-D63l6_UC.mjs")
+		load: () => import("./renderer-Dv4u2c14.mjs")
 	},
 	{
 		packageName: "@framefields/node-ascii",
 		ops: ["Ascii"],
-		load: () => import("./renderer-CwVbHki6.mjs")
+		load: () => import("./renderer-BaIJIfJ6.mjs")
 	},
 	{
 		packageName: "@framefields/node-audio-compressor",
 		ops: ["AudioCompressor"],
-		load: () => import("./renderer-CS2zyPyZ.mjs")
+		load: () => import("./renderer-C7Puyst9.mjs")
 	},
 	{
 		packageName: "@framefields/node-audio-delay",
 		ops: ["AudioDelay"],
-		load: () => import("./renderer-BKXM28Mx.mjs")
+		load: () => import("./renderer-CQ1rwjIh.mjs")
 	},
 	{
 		packageName: "@framefields/node-audio-fade",
 		ops: ["AudioFade"],
-		load: () => import("./renderer-DpisVnT2.mjs")
+		load: () => import("./renderer-BIF3Dg3Z.mjs")
 	},
 	{
 		packageName: "@framefields/node-audio-noise-gate",
 		ops: ["AudioNoiseGate"],
-		load: () => import("./renderer-CXnbl_jR.mjs")
+		load: () => import("./renderer-Cb0lszt3.mjs")
 	},
 	{
 		packageName: "@framefields/node-audio-parametric-eq",
 		ops: ["AudioParametricEq"],
-		load: () => import("./renderer-STufNpMx.mjs")
+		load: () => import("./renderer-D6qhcx_C.mjs")
 	},
 	{
 		packageName: "@framefields/node-audio-reverb",
 		ops: ["AudioReverb"],
-		load: () => import("./renderer-129U3pc9.mjs")
+		load: () => import("./renderer-CzolnwCo.mjs")
 	},
 	{
 		packageName: "@framefields/node-audio-signal-extractor",
 		ops: ["AudioSignalExtractor"],
-		load: () => import("./renderer-Bofr6f88.mjs")
+		load: () => import("./renderer-DgIjNANM.mjs")
 	},
 	{
 		packageName: "@framefields/node-blur",
 		ops: ["Blur"],
-		load: () => import("./renderer-DCJqnzER.mjs")
+		load: () => import("./renderer-Bpe4k_x6.mjs")
 	},
 	{
 		packageName: "@framefields/node-camera-parallax-3d",
 		ops: ["CameraParallax3D"],
-		load: () => import("./renderer-DIEmK57T.mjs")
+		load: () => import("./renderer-Co6UFbZB.mjs")
 	},
 	{
 		packageName: "@framefields/node-canvas-generator",
 		ops: ["CanvasGenerator"],
-		load: () => import("./renderer-CUBDxuxh.mjs")
+		load: () => import("./renderer-CAWnCsQc.mjs")
 	},
 	{
 		packageName: "@framefields/node-channel-merger",
 		ops: ["ChannelMerger"],
-		load: () => import("./renderer-BPYIqtNg.mjs")
+		load: () => import("./renderer-50JEMaVo.mjs")
 	},
 	{
 		packageName: "@framefields/node-channel-splitter",
 		ops: ["ChannelSplitter"],
-		load: () => import("./renderer-VhkubIx_.mjs")
+		load: () => import("./renderer-CU8v-LxD.mjs")
 	},
 	{
 		packageName: "@framefields/node-color-balance",
 		ops: ["ColorBalance"],
-		load: () => import("./renderer-F1D9ZJ8I.mjs")
+		load: () => import("./renderer-g_1t2je9.mjs")
 	},
 	{
 		packageName: "@framefields/node-colorkey",
 		ops: ["ColorKey"],
-		load: () => import("./renderer-9muKpDeE.mjs")
+		load: () => import("./renderer-CLnFkXO7.mjs")
 	},
 	{
 		packageName: "@framefields/node-compositor",
 		ops: ["Compositor"],
-		load: () => import("./renderer-Du-GnKLb.mjs")
+		load: () => import("./renderer-TKZCA0B9.mjs")
 	},
 	{
 		packageName: "@framefields/node-contour",
 		ops: ["Contour"],
-		load: () => import("./renderer-eT7Gp7FS.mjs")
+		load: () => import("./renderer-_9gbYS-3.mjs")
 	},
 	{
 		packageName: "@framefields/node-corner-pin",
 		ops: ["CornerPin"],
-		load: () => import("./renderer-DTCUzByS.mjs")
+		load: () => import("./renderer-B-OdV-eq.mjs")
 	},
 	{
 		packageName: "@framefields/node-crop",
 		ops: ["Crop"],
-		load: () => import("./renderer-DhL4nNPk.mjs")
+		load: () => import("./renderer-CtWeRtHK.mjs")
 	},
 	{
 		packageName: "@framefields/node-crt",
 		ops: ["CRT"],
-		load: () => import("./renderer-BG6bkKtY.mjs")
+		load: () => import("./renderer-Bf4-N7k7.mjs")
 	},
 	{
 		packageName: "@framefields/node-curves",
 		ops: ["Curves"],
-		load: () => import("./renderer-BvuBt2aH.mjs")
+		load: () => import("./renderer--Ymc_4XJ.mjs")
 	},
 	{
 		packageName: "@framefields/node-datamosh",
 		ops: ["Datamosh"],
-		load: () => import("./renderer-C_2UDMEG.mjs")
+		load: () => import("./renderer-V4dhrf_h.mjs")
 	},
 	{
 		packageName: "@framefields/node-deflicker",
 		ops: ["TemporalDeflicker", "Deflicker"],
-		load: () => import("./renderer-DFBOR5J3.mjs")
+		load: () => import("./renderer-DDpa8ztp.mjs")
 	},
 	{
 		packageName: "@framefields/node-displacement-map",
 		ops: ["DisplacementMap"],
-		load: () => import("./renderer-DdGahYi1.mjs")
+		load: () => import("./renderer-CT8h0boY.mjs")
 	},
 	{
 		packageName: "@framefields/node-dither",
 		ops: ["Dither"],
-		load: () => import("./renderer-BJQt0RiZ.mjs")
+		load: () => import("./renderer-fwKnV9zs.mjs")
 	},
 	{
 		packageName: "@framefields/node-extract-frame",
 		ops: ["ExtractFrame"],
-		load: () => import("./renderer-Dss7T71q.mjs")
+		load: () => import("./renderer-pNmI-A9o.mjs")
 	},
 	{
 		packageName: "@framefields/node-extract-lut",
 		ops: ["ExtractLUT"],
-		load: () => import("./renderer-CDVb4OfJ.mjs")
+		load: () => import("./renderer-B6Oeahe_.mjs")
 	},
 	{
 		packageName: "@framefields/node-film-grain",
 		ops: ["FilmGrain"],
-		load: () => import("./renderer-BPsjEnnl.mjs")
+		load: () => import("./renderer-IE1yu3lZ.mjs")
 	},
 	{
 		packageName: "@framefields/node-flip",
 		ops: ["Flip"],
-		load: () => import("./renderer-BBUgCS3C.mjs")
+		load: () => import("./renderer-BSwhyVWa.mjs")
 	},
 	{
 		packageName: "@framefields/node-gooey",
 		ops: ["Gooey"],
-		load: () => import("./renderer-D1VsqFf4.mjs")
+		load: () => import("./renderer-DOkbn1ot.mjs")
 	},
 	{
 		packageName: "@framefields/node-gradient-map",
 		ops: ["GradientMap"],
-		load: () => import("./renderer-DEQeONTd.mjs")
+		load: () => import("./renderer-ynFRJh7G.mjs")
 	},
 	{
 		packageName: "@framefields/node-halftone-screen",
 		ops: ["HalftoneScreen"],
-		load: () => import("./renderer-DnAZweRX.mjs")
+		load: () => import("./renderer-C1NjG0CJ.mjs")
 	},
 	{
 		packageName: "@framefields/node-high-pass",
 		ops: ["HighPass"],
-		load: () => import("./renderer-CBjG8rjE.mjs")
+		load: () => import("./renderer-BJUVaIAT.mjs")
 	},
 	{
 		packageName: "@framefields/node-iridescence",
 		ops: ["Iridescence"],
-		load: () => import("./renderer-bbaMOD4I.mjs")
+		load: () => import("./renderer-RvI3qRUI.mjs")
 	},
 	{
 		packageName: "@framefields/node-kaleidoscope",
 		ops: ["Kaleidoscope"],
-		load: () => import("./renderer-BNbMi9CI.mjs")
+		load: () => import("./renderer-jnAIhWn_.mjs")
 	},
 	{
 		packageName: "@framefields/node-kenburns",
 		ops: ["KenBurns"],
-		load: () => import("./renderer-BKqm6xdf.mjs")
+		load: () => import("./renderer-PY_wnEN0.mjs")
 	},
 	{
 		packageName: "@framefields/node-layer-style",
 		ops: ["LayerStyle"],
-		load: () => import("./renderer-BMfMMf0R.mjs")
+		load: () => import("./renderer-CMQIT1Kh.mjs")
 	},
 	{
 		packageName: "@framefields/node-levels",
 		ops: ["Levels"],
-		load: () => import("./renderer-CdjuGRbO.mjs")
+		load: () => import("./renderer-CGA_7320.mjs")
 	},
 	{
 		packageName: "@framefields/node-liquify",
 		ops: ["Liquify"],
-		load: () => import("./renderer-DxZD5B54.mjs")
+		load: () => import("./renderer-DbQBqzmx.mjs")
 	},
 	{
 		packageName: "@framefields/node-mask-math",
 		ops: ["MaskMath"],
-		load: () => import("./renderer-Bz2Rrz60.mjs")
+		load: () => import("./renderer-B9z2AK31.mjs")
 	},
 	{
 		packageName: "@framefields/node-mesh-warp",
 		ops: ["MeshWarp"],
-		load: () => import("./renderer-CoLbxC13.mjs")
+		load: () => import("./renderer-gv24VyzO.mjs")
 	},
 	{
 		packageName: "@framefields/node-modulate",
 		ops: ["Modulate"],
-		load: () => import("./renderer-BqoGcujR.mjs")
+		load: () => import("./renderer-DfUcwMKa.mjs")
 	},
 	{
 		packageName: "@framefields/node-noise-generator",
 		ops: ["NoiseGenerator"],
-		load: () => import("./renderer-B3IRvukr.mjs")
+		load: () => import("./renderer-KKk7myX1.mjs")
 	},
 	{
 		packageName: "@framefields/node-op-art",
 		ops: ["OpArt"],
-		load: () => import("./renderer-BgDLCCuq.mjs")
+		load: () => import("./renderer-DkqZmfm8.mjs")
 	},
 	{
 		packageName: "@framefields/node-paint",
 		ops: ["Paint"],
-		load: () => import("./renderer-2phFTFxQ.mjs")
+		load: () => import("./renderer-nN6lPZf9.mjs")
 	},
 	{
 		packageName: "@framefields/node-painterly",
 		ops: ["Painterly"],
-		load: () => import("./renderer-5qJPGvVL.mjs")
+		load: () => import("./renderer-ByjaseAo.mjs")
 	},
 	{
 		packageName: "@framefields/node-particles",
 		ops: ["Particles"],
-		load: () => import("./renderer-BVql26Ay.mjs")
+		load: () => import("./renderer-BOrMBwQS.mjs")
 	},
 	{
 		packageName: "@framefields/node-patch-heal",
 		ops: ["PatchHeal"],
-		load: () => import("./renderer-C3tVrzyT.mjs")
+		load: () => import("./renderer-D06HxSXO.mjs")
 	},
 	{
 		packageName: "@framefields/node-pixelate",
 		ops: ["Pixelate"],
-		load: () => import("./renderer-g7fF2AYk.mjs")
+		load: () => import("./renderer-B3Dme2es.mjs")
 	},
 	{
 		packageName: "@framefields/node-posterize",
 		ops: ["Posterize"],
-		load: () => import("./renderer-BYqrtBvd.mjs")
+		load: () => import("./renderer-COcKhouz.mjs")
 	},
 	{
 		packageName: "@framefields/node-procedural-vfx",
 		ops: ["ProceduralVFX"],
-		load: () => import("./renderer-CIB5L_C4.mjs")
+		load: () => import("./renderer-4ZUv3X1I.mjs")
 	},
 	{
 		packageName: "@framefields/node-refine-edge",
 		ops: ["RefineEdge"],
-		load: () => import("./renderer-BxTgXHu1.mjs")
+		load: () => import("./renderer-Ci7oLye9.mjs")
 	},
 	{
 		packageName: "@framefields/node-refraction-caustics",
 		ops: ["RefractionCaustics3D"],
-		load: () => import("./renderer-US4GsamT.mjs")
+		load: () => import("./renderer-CR0mDPYY.mjs")
 	},
 	{
 		packageName: "@framefields/node-relight-3d",
 		ops: ["Relight3D"],
-		load: () => import("./renderer-DGAZSzw6.mjs")
+		load: () => import("./renderer-BUqSZn2X.mjs")
 	},
 	{
 		packageName: "@framefields/node-resizer-scaler",
 		ops: ["ResizerScaler"],
-		load: () => import("./renderer-CPTXJs0n.mjs")
+		load: () => import("./renderer-Rw87u1Cr.mjs")
 	},
 	{
 		packageName: "@framefields/node-rgb-split",
 		ops: ["RGBSplit"],
-		load: () => import("./renderer-OsQRvOle.mjs")
+		load: () => import("./renderer-riIFosX6.mjs")
 	},
 	{
 		packageName: "@framefields/node-rotate",
 		ops: ["Rotate"],
-		load: () => import("./renderer-CaF9vod_.mjs")
+		load: () => import("./renderer-CjqXB3CZ.mjs")
 	},
 	{
 		packageName: "@framefields/node-selective-color",
 		ops: ["SelectiveColor"],
-		load: () => import("./renderer-CbSBH3lp.mjs")
+		load: () => import("./renderer-CqTV04zQ.mjs")
 	},
 	{
 		packageName: "@framefields/node-shadows-highlights",
 		ops: ["ShadowsHighlights"],
-		load: () => import("./renderer-B5Dhv6j9.mjs")
+		load: () => import("./renderer-B65fwoA2.mjs")
 	},
 	{
 		packageName: "@framefields/node-shape-generator",
 		ops: ["ShapeGenerator"],
-		load: () => import("./renderer-CcJyD9Q5.mjs")
+		load: () => import("./renderer-BURhYcpA.mjs")
 	},
 	{
 		packageName: "@framefields/node-signal-gate",
 		ops: ["SignalGate"],
-		load: () => import("./renderer-Ds7pAKnE.mjs")
+		load: () => import("./renderer-BbmvjqK9.mjs")
 	},
 	{
 		packageName: "@framefields/node-stereo-panning",
 		ops: ["StereoPanning"],
-		load: () => import("./renderer-DPLGk1Qk.mjs")
+		load: () => import("./renderer-BKRDMbI-.mjs")
 	},
 	{
 		packageName: "@framefields/node-tile-offset",
 		ops: ["TileOffset"],
-		load: () => import("./renderer-PMHOnbnA.mjs")
+		load: () => import("./renderer-DuIwR9GT.mjs")
 	},
 	{
 		packageName: "@framefields/node-toon",
 		ops: ["Toon"],
-		load: () => import("./renderer-BWMzjSgf.mjs")
+		load: () => import("./renderer-DaXQgGg3.mjs")
 	},
 	{
 		packageName: "@framefields/node-trails",
 		ops: ["Trails"],
-		load: () => import("./renderer-BQOeeXTr.mjs")
+		load: () => import("./renderer-Cz-n883J.mjs")
 	},
 	{
 		packageName: "@framefields/node-unsharp-mask",
 		ops: ["UnsharpMask"],
-		load: () => import("./renderer-SdrgfCxH.mjs")
+		load: () => import("./renderer-DDfEf0jt.mjs")
 	},
 	{
 		packageName: "@framefields/node-vignette",
 		ops: ["Vignette"],
-		load: () => import("./renderer-Cr9G0dXB.mjs")
+		load: () => import("./renderer-B92Ahkcv.mjs")
 	},
 	{
 		packageName: "@framefields/node-vision",
 		ops: ["Vision"],
-		load: () => import("./renderer-DkyTbiVz.mjs")
+		load: () => import("./renderer-Dsh6Tgu0.mjs")
 	}
 ];
 /**
@@ -1823,6 +1823,55 @@ async function fileSize(file) {
 		return;
 	}
 }
+/** The frames a render covers, checked against the composition's length. */
+function resolveFrameRange(frames, total) {
+	if (!frames) return {
+		start: 0,
+		end: total,
+		total
+	};
+	const { start, end } = frames;
+	if (!Number.isInteger(start) || !Number.isInteger(end) || start < 0 || end <= start || end > total) throw new Error(`Invalid frames { start: ${start}, end: ${end} }: need integers with 0 <= start < end <= ${total} (the composition's frame count).`);
+	return {
+		start,
+		end,
+		total
+	};
+}
+/**
+* Mixes the composition's whole audio timeline and encodes it into `source`
+* in 100 ms samples. Returns its QA stats when `qaOptions` is set.
+*/
+async function encodeAudioTrack(job) {
+	const { reporter } = job;
+	reporter.stage("audio", "Mixing audio");
+	const { channels, sampleRate } = await mixAudioTracks(job.virtualMedia, job.fps, 48e3, job.device, job.renderId, { onProgress: ({ done, total, source }) => reporter.update(total > 0 ? `${done}/${total} clips${source ? `: ${source}` : ""}` : "no audio clips", total > 0 ? done / total : void 0) });
+	const numChannels = channels.length;
+	if (numChannels === 0) throw new Error("mixAudioTracks returned no channels");
+	const totalSamples = channels[0].length;
+	const chunkSize = Math.round(.1 * sampleRate);
+	reporter.stage("audio-encode", `Encoding ${(totalSamples / sampleRate).toFixed(1)}s of audio (${job.codec})`);
+	for (let offset = 0; offset < totalSamples; offset += chunkSize) {
+		const currentChunk = Math.min(chunkSize, totalSamples - offset);
+		const interleaved = new Float32Array(currentChunk * numChannels);
+		for (let i = 0; i < currentChunk; i++) for (let ch = 0; ch < numChannels; ch++) interleaved[i * numChannels + ch] = channels[ch]?.[offset + i] ?? 0;
+		const sample = new AudioSample({
+			data: interleaved,
+			format: "f32",
+			numberOfChannels: numChannels,
+			sampleRate,
+			timestamp: offset / sampleRate
+		});
+		try {
+			await job.source.add(sample);
+		} finally {
+			sample.close();
+		}
+		const written = offset + currentChunk;
+		reporter.update(`${(written / sampleRate).toFixed(1)}s/${(totalSamples / sampleRate).toFixed(1)}s`, written / totalSamples);
+	}
+	return job.qaOptions ? analyzeAudio(channels, sampleRate, job.qaOptions) : void 0;
+}
 function toEvenDimension(n) {
 	const v = Math.round(n);
 	return v % 2 === 0 ? v : v + 1;
@@ -2063,6 +2112,55 @@ var HeadlessWebGPURenderer = class HeadlessWebGPURenderer$1 {
 		});
 	}
 	/**
+	* Measures what frames cost to render across the timeline, for planning a
+	* split render (`planChunks`). At `samples` evenly spaced points (default
+	* 12) it renders three consecutive frames and times the last two, so
+	* effects that carry state (trails, particles) are caught up and their
+	* replay is not counted. Encoding is not included.
+	*/
+	async probeRender(source, options$1 = {}) {
+		const vm = "toVirtualMedia" in source ? source.toVirtualMedia() : source;
+		const fps = vm.metadata.fps;
+		if (!fps) throw new Error("probeRender: the composition has no fps.");
+		let durationMs = vm.metadata.durationMs;
+		if (!durationMs || durationMs <= 0) {
+			durationMs = await this.resolveMediaDuration(vm, fps);
+			vm.metadata.durationMs = durationMs;
+		}
+		const totalFrames = frameCount(durationMs, fps);
+		const count = Math.max(1, Math.min(Math.floor(options$1.samples ?? 12), totalFrames));
+		const last = Math.max(0, totalFrames - 3);
+		const renderId = `probe-${randomUUID()}`;
+		const render = (frame) => this.renderImage(vm, Math.min(frame, totalFrames - 1), fps, {
+			renderId,
+			format: "rgba"
+		});
+		const samples = [];
+		try {
+			for (let i = 0; i < count; i++) {
+				options$1.signal?.throwIfAborted();
+				const at = count === 1 ? 0 : Math.round(i * last / (count - 1));
+				await render(at);
+				const started = performance.now();
+				await render(at + 1);
+				await render(at + 2);
+				samples.push({
+					frame: Math.min(at + 1, totalFrames - 1),
+					ms: (performance.now() - started) / 2
+				});
+				options$1.onSample?.(i + 1, count);
+			}
+		} finally {
+			mediaDecoderCache.clearNode(renderId);
+		}
+		return {
+			totalFrames,
+			fps,
+			durationMs,
+			samples
+		};
+	}
+	/**
 	* Mixes the composition's full audio timeline (clips, effects, synthesized
 	* tracks) to stereo PCM, exactly as `renderVideo` muxes it.
 	*/
@@ -2236,7 +2334,9 @@ var HeadlessWebGPURenderer = class HeadlessWebGPURenderer$1 {
 			durationMs = await this.resolveMediaDuration(virtualMedia, fps);
 			virtualMedia.metadata.durationMs = durationMs;
 		}
-		const totalFrames = frameCount(durationMs, fps);
+		const range = resolveFrameRange(options$1?.frames, frameCount(durationMs, fps));
+		if (isAudioOnly && (options$1?.frames || options$1?.audio === false)) throw new Error(`An audio-only render (codec "${codecOption}") takes neither \`frames\` nor \`audio: false\`.`);
+		const totalFrames = range.end - range.start;
 		const renderId = `vid-${randomUUID()}`;
 		const qaOptions = options$1?.qa === true ? {} : options$1?.qa ? options$1.qa : void 0;
 		const inspector = qaOptions ? new FrameInspector(qaOptions) : void 0;
@@ -2325,11 +2425,14 @@ var HeadlessWebGPURenderer = class HeadlessWebGPURenderer$1 {
 			});
 			output.addVideoTrack(videoSource);
 		}
-		const audioSource = new AudioSampleSource({
-			codec: audioCodec,
-			bitrate: quality
-		});
-		output.addAudioTrack(audioSource);
+		let audioSource;
+		if (options$1?.audio !== false) {
+			audioSource = new AudioSampleSource({
+				codec: audioCodec,
+				bitrate: quality
+			});
+			output.addAudioTrack(audioSource);
+		}
 		let outputStarted = false;
 		let outputFinalized = false;
 		let surface;
@@ -2381,12 +2484,13 @@ var HeadlessWebGPURenderer = class HeadlessWebGPURenderer$1 {
 					device.queue.submit([preEncoder.finish()]);
 					await lutStore.awaitAllPending(device);
 				};
-				await prePass(0);
-				reporter.stage("render", `Rendering ${totalFrames} frames`);
-				for (let i = 0; i < totalFrames; i++) {
+				updateClockSignals(range.start, fps, durationMs);
+				await prePass(range.start);
+				reporter.stage("render", range.start === 0 && totalFrames === range.total ? `Rendering ${totalFrames} frames` : `Rendering frames ${range.start}–${range.end - 1} of ${range.total}`);
+				for (let i = range.start; i < range.end; i++) {
 					options$1?.signal?.throwIfAborted();
 					if (ctx && surface && renderer && pipeline) {
-						if (i > 0 && (lutStore.hasPending(device) || SlugFontCache.hasPending())) {
+						if (i > range.start && (lutStore.hasPending(device) || SlugFontCache.hasPending())) {
 							updateClockSignals(i, fps, durationMs);
 							await prePass(i);
 						}
@@ -2413,8 +2517,9 @@ var HeadlessWebGPURenderer = class HeadlessWebGPURenderer$1 {
 							containerHeight: height,
 							isVideoMode: virtualMedia.operation?.dataType === "Video"
 						});
-						await pipeline.enqueueFrame(i, targetTexture, encoder);
-						if (i + 1 < totalFrames) reporter.frameDone(i + 1);
+						const done = i - range.start + 1;
+						await pipeline.enqueueFrame(done - 1, targetTexture, encoder);
+						if (done < totalFrames) reporter.frameDone(done);
 					} else throw new Error("Invalid render context state");
 				}
 				if (pipeline) {
@@ -2429,33 +2534,18 @@ var HeadlessWebGPURenderer = class HeadlessWebGPURenderer$1 {
 					}, `[HeadlessWebGPURenderer] All frames rendered and encoded (avg cycle: ${pipelineStats.averageCycleTimeMs.toFixed(2)}ms, throughput: ${pipelineStats.throughputFps.toFixed(1)} fps)`);
 				}
 			}
-			options$1?.signal?.throwIfAborted();
-			reporter.stage("audio", "Mixing audio");
-			const { channels, sampleRate } = await mixAudioTracks(virtualMedia, fps, 48e3, device, renderId, { onProgress: ({ done, total, source }) => reporter.update(total > 0 ? `${done}/${total} clips${source ? `: ${source}` : ""}` : "no audio clips", total > 0 ? done / total : void 0) });
-			const numChannels = channels.length;
-			if (numChannels === 0) throw new Error("mixAudioTracks returned no channels");
-			if (qaOptions) audioQa = analyzeAudio(channels, sampleRate, qaOptions);
-			const totalSamples = channels[0].length;
-			const chunkSize = Math.round(.1 * sampleRate);
-			reporter.stage("audio-encode", `Encoding ${(totalSamples / sampleRate).toFixed(1)}s of audio (${audioCodec})`);
-			for (let offset = 0; offset < totalSamples; offset += chunkSize) {
-				const currentChunk = Math.min(chunkSize, totalSamples - offset);
-				const interleaved = new Float32Array(currentChunk * numChannels);
-				for (let i = 0; i < currentChunk; i++) for (let ch = 0; ch < numChannels; ch++) interleaved[i * numChannels + ch] = channels[ch]?.[offset + i] ?? 0;
-				const sample = new AudioSample({
-					data: interleaved,
-					format: "f32",
-					numberOfChannels: numChannels,
-					sampleRate,
-					timestamp: offset / sampleRate
+			if (audioSource) {
+				options$1?.signal?.throwIfAborted();
+				audioQa = await encodeAudioTrack({
+					virtualMedia,
+					fps,
+					device,
+					renderId,
+					source: audioSource,
+					codec: audioCodec,
+					reporter,
+					qaOptions
 				});
-				try {
-					await audioSource.add(sample);
-				} finally {
-					sample.close();
-				}
-				const written = offset + currentChunk;
-				reporter.update(`${(written / sampleRate).toFixed(1)}s/${(totalSamples / sampleRate).toFixed(1)}s`, written / totalSamples);
 			}
 			options$1?.signal?.throwIfAborted();
 			reporter.stage("mux", `Muxing ${extension}`);
@@ -2539,6 +2629,82 @@ const HeadlessMediaRenderer = HeadlessWebGPURenderer;
 
 //#endregion
 //#region ../renderer/dist/index.mjs
+function planChunks(options$1) {
+	const total = options$1.totalFrames;
+	if (!Number.isInteger(total) || total < 1) throw new Error(`planChunks: totalFrames must be a positive integer, got ${total}.`);
+	const overheadSec = options$1.overheadSec ?? 90;
+	const maxWorkers = Math.max(1, Math.floor(options$1.maxWorkers ?? 10));
+	const minChunkFrames = Math.max(1, Math.floor(options$1.minChunkFrames ?? 60));
+	const cost = frameCosts(total, options$1.samples);
+	const workSec = cost.reduce((sum, ms) => sum + ms, 0) / 1e3;
+	const wanted = workerCount(options$1.workers ?? 1, workSec, overheadSec, options$1.efficiency ?? .85);
+	const chunks = splitByCost(cost, Math.max(1, Math.min(wanted, maxWorkers, Math.floor(total / minChunkFrames))), minChunkFrames);
+	const longest = Math.max(...chunks.map((c) => c.workSec));
+	return {
+		workers: chunks.length,
+		workSec,
+		etaSec: overheadSec + longest,
+		chunks
+	};
+}
+function workerCount(workers, workSec, overheadSec, efficiency) {
+	if (workers !== "auto") {
+		if (!Number.isInteger(workers) || workers < 1) throw new Error(`planChunks: workers must be a positive integer or "auto", got ${workers}.`);
+		return workers;
+	}
+	if (!(efficiency > 0 && efficiency < 1)) throw new Error(`planChunks: efficiency must be between 0 and 1, got ${efficiency}.`);
+	const minChunkSec = overheadSec * efficiency / (1 - efficiency);
+	return minChunkSec > 0 ? Math.max(1, Math.floor(workSec / minChunkSec)) : Number.POSITIVE_INFINITY;
+}
+/** Per-frame cost in ms: linear between samples, flat beyond the first and last. */
+function frameCosts(total, samples) {
+	const sorted = samples.filter((s$1) => Number.isFinite(s$1.frame) && Number.isFinite(s$1.ms) && s$1.ms >= 0).toSorted((a, b) => a.frame - b.frame);
+	if (sorted.length === 0) throw new Error("planChunks: needs at least one frame cost sample.");
+	const cost = new Float64Array(total);
+	let s = 0;
+	for (let f = 0; f < total; f++) {
+		while (s + 1 < sorted.length && sorted[s + 1].frame <= f) s++;
+		const a = sorted[s];
+		const b = sorted[s + 1];
+		cost[f] = !b || f <= a.frame ? a.ms : a.ms + (b.ms - a.ms) * (f - a.frame) / (b.frame - a.frame);
+	}
+	return cost;
+}
+/**
+* Cuts the frames into `count` contiguous chunks of about equal total cost,
+* none shorter than `minFrames` (`count × minFrames` must fit).
+*/
+function splitByCost(cost, count, minFrames) {
+	const total = cost.reduce((sum, ms) => sum + ms, 0);
+	const chunks = [];
+	let start = 0;
+	let acc = 0;
+	let chunkMs = 0;
+	for (let f = 0; f < cost.length; f++) {
+		acc += cost[f];
+		chunkMs += cost[f];
+		const cut = total * (chunks.length + 1) / count;
+		const framesLeft = cost.length - (f + 1);
+		const chunksLeft = count - chunks.length - 1;
+		const long = f + 1 - start >= minFrames;
+		const roomAfter = framesLeft >= minFrames * chunksLeft;
+		if (chunksLeft > 0 && long && (acc >= cut && roomAfter || framesLeft === minFrames * chunksLeft)) {
+			chunks.push({
+				start,
+				end: f + 1,
+				workSec: chunkMs / 1e3
+			});
+			start = f + 1;
+			chunkMs = 0;
+		}
+	}
+	chunks.push({
+		start,
+		end: cost.length,
+		workSec: chunkMs / 1e3
+	});
+	return chunks;
+}
 /**
 * Drops every cache keyed by a file path or URL: media inputs and decoders,
 * textures, LUTs, fonts and downloaded font files. A long-lived worker calls this between jobs,
@@ -2554,6 +2720,150 @@ function resetRenderCaches() {
 	SlugFontCache.destroy();
 	clearHeadlessFonts();
 }
+/**
+* Joins the chunks of one render split across workers. Each chunk is made
+* with `renderVideo({ frames, audio: false })`, starts on a keyframe and
+* timestamps from 0; the stitch copies their encoded frames into one track,
+* shifted to follow each other, and copies in the audio track of a separate
+* audio-only render. Nothing is decoded or re-encoded, so it needs no GPU.
+*/
+async function stitchChunks(options$1) {
+	if (options$1.chunks.length === 0) throw new Error("stitchChunks needs at least one chunk.");
+	const inputs = [];
+	const open = (file) => {
+		const input = new Input({
+			source: new FilePathSource(file),
+			formats: ALL_FORMATS
+		});
+		inputs.push(input);
+		return input;
+	};
+	let output;
+	try {
+		const chunks = await Promise.all(options$1.chunks.map((file) => openVideoChunk(file, open(file))));
+		const [reference] = chunks;
+		for (const chunk of chunks.slice(1)) assertSameEncoding(reference, chunk);
+		const webm = (await reference.input.getMimeType()).includes("webm");
+		await fs$1.mkdir(path.dirname(path.resolve(options$1.outputPath)), { recursive: true });
+		output = new Output({
+			format: webm ? new WebMOutputFormat() : new Mp4OutputFormat(),
+			target: new FilePathTarget(options$1.outputPath)
+		});
+		const video = new EncodedVideoPacketSource(reference.codec);
+		output.addVideoTrack(video);
+		const audio = options$1.audio ? await AudioCopier.open(options$1.audio, open(options$1.audio), output) : void 0;
+		await output.start();
+		const written = await copyVideo(chunks, video, audio, options$1.signal);
+		await audio?.writeUntil(Number.POSITIVE_INFINITY, options$1.signal);
+		await output.finalize();
+		output = void 0;
+		return {
+			filePath: options$1.outputPath,
+			...written
+		};
+	} catch (error) {
+		if (output) {
+			await output.cancel().catch(() => {});
+			await fs$1.rm(options$1.outputPath, { force: true });
+		}
+		throw error;
+	} finally {
+		for (const input of inputs) input.dispose();
+	}
+}
+async function openVideoChunk(file, input) {
+	const track = await input.getPrimaryVideoTrack();
+	if (!track) throw new Error(`Chunk ${file} has no video track.`);
+	const codec = await track.getCodec();
+	const config = await track.getDecoderConfig();
+	if (!codec || !config) throw new Error(`Chunk ${file}: its video codec cannot be read.`);
+	return {
+		file,
+		input,
+		track,
+		codec,
+		config
+	};
+}
+/**
+* Copied frames are decoded with the first chunk's codec configuration, so
+* every chunk must have been encoded with the same one.
+*/
+function assertSameEncoding(reference, chunk) {
+	const a = reference.config;
+	const b = chunk.config;
+	const differs = a.codec !== b.codec ? `codec ${b.codec}, not ${a.codec}` : a.codedWidth !== b.codedWidth || a.codedHeight !== b.codedHeight ? `size ${b.codedWidth}x${b.codedHeight}, not ${a.codedWidth}x${a.codedHeight}` : !sameBytes(a.description, b.description) ? "different encoder parameters (SPS/PPS)" : void 0;
+	if (differs) throw new Error(`Chunk ${chunk.file} has ${differs} than ${reference.file}. Render every chunk with the same framefields version, codec and quality, on the same GPU type.`);
+}
+function sameBytes(a, b) {
+	if (!a || !b) return a === b;
+	const x = toBytes(a);
+	const y = toBytes(b);
+	return x.length === y.length && x.every((v, i) => v === y[i]);
+}
+function toBytes(data) {
+	return ArrayBuffer.isView(data) ? new Uint8Array(data.buffer, data.byteOffset, data.byteLength) : new Uint8Array(data);
+}
+/** Writes every chunk's frames, each chunk starting where the last one ended. */
+async function copyVideo(chunks, video, audio, signal) {
+	let offset = 0;
+	let frames = 0;
+	for (const chunk of chunks) {
+		let first;
+		let end = offset;
+		for await (const packet of new EncodedPacketSink(chunk.track).packets()) {
+			signal?.throwIfAborted();
+			if (first === void 0) {
+				if (packet.type !== "key") throw new Error(`Chunk ${chunk.file} does not start on a keyframe.`);
+				first = packet.timestamp;
+			}
+			const timestamp = offset + packet.timestamp - first;
+			await audio?.writeUntil(timestamp, signal);
+			await video.add(packet.clone({ timestamp }), frames === 0 ? { decoderConfig: chunk.config } : void 0);
+			frames++;
+			end = Math.max(end, timestamp + packet.duration);
+		}
+		if (first === void 0) throw new Error(`Chunk ${chunk.file} has no video frames.`);
+		offset = end;
+	}
+	return {
+		frames,
+		durationSec: offset
+	};
+}
+/** Copies an audio track's packets in timestamp order, as far as asked. */
+var AudioCopier = class AudioCopier$1 {
+	packets;
+	/** The next packet to write; `undefined` until read, `null` at the end. */
+	next;
+	written = 0;
+	constructor(track, config, source) {
+		this.config = config;
+		this.source = source;
+		this.packets = new EncodedPacketSink(track).packets();
+	}
+	static async open(file, input, output) {
+		const track = await input.getPrimaryAudioTrack();
+		if (!track) throw new Error(`Audio file ${file} has no audio track.`);
+		const config = await track.getDecoderConfig();
+		const codec = await track.getCodec();
+		if (!config || !codec) throw new Error(`Audio file ${file}: its codec cannot be read.`);
+		const source = new EncodedAudioPacketSource(codec);
+		output.addAudioTrack(source);
+		return new AudioCopier$1(track, config, source);
+	}
+	async writeUntil(timestamp, signal) {
+		for (;;) {
+			if (this.next === void 0) this.next = (await this.packets.next()).value ?? null;
+			const packet = this.next;
+			if (!packet || packet.timestamp > timestamp) return;
+			signal?.throwIfAborted();
+			await this.source.add(packet, this.written === 0 ? { decoderConfig: this.config } : void 0);
+			this.written++;
+			this.next = void 0;
+		}
+	}
+};
 
 //#endregion
 //#region src/renderer/framegrid.ts
@@ -2733,5 +3043,5 @@ async function renderFrameGrid(target, options$1 = {}) {
 }
 
 //#endregion
-export { HeadlessMediaRenderer as a, renderSemaphore as c, resetRenderCaches as i, renderFrameGrid as n, HeadlessWebGPURenderer as o, resolveSamplePoints as r, formatQaReport as s, computeGridLayout as t };
-//# sourceMappingURL=renderer-Be5hfwSd.mjs.map
+export { resetRenderCaches as a, HeadlessWebGPURenderer as c, planChunks as i, formatQaReport as l, renderFrameGrid as n, stitchChunks as o, resolveSamplePoints as r, HeadlessMediaRenderer as s, computeGridLayout as t, renderSemaphore as u };
+//# sourceMappingURL=renderer-Bbxh4N8Y.mjs.map