framefields 2.1.0 → 2.1.1

package/dist/renderer-DX2qEJTL.mjs

@@ -0,0 +1,2173 @@
+import { Ot as getMediaType, in as takeRenderDiagnostics, on as updateClockSignals } from "./dist-fjKpBYkc.mjs";
+import { i as registerWebGPURenderer, t as audioRegistry } from "./renderer-BSitV56h.mjs";
+import { $ as textureCache, D as ensureDevice, M as getRenderer2D, N as initHeadlessWebGPU, P as inputStore, V as mediaDecoderCache, X as shaderStore, _ as clearAllVideoCache, g as WebGPUAudioProcessor, p as SlugFontCache, s as NodeSurfaceProvider, z as lutStore } from "./dist-DkuDAIrG.mjs";
+import { i as mixAudioTracks, m as preloadCompositionFonts, r as drawCompositionTree, t as compositionStateStore } from "./dist-Bb8BoMiw.mjs";
+import { AudioSample, AudioSampleSource, FilePathTarget, 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";
+import fs$1 from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import os from "node:os";
+import pino from "pino";
+import * as webcodecs from "@napi-rs/webcodecs";
+import { VideoFrame } from "@napi-rs/webcodecs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { registerMediabunnyServer } from "@mediabunny/server";
+import { exec, spawn } from "node:child_process";
+import sharp from "sharp";
+
+//#region ../renderer/dist/bootstrap-mediabunny-CxYBXeAy.mjs
+const rendererLogger = pino({
+	level: typeof process !== "undefined" && process.env?.LOG_LEVEL || "info",
+	timestamp: pino.stdTimeFunctions.isoTime,
+	base: { component: "renderer" }
+});
+/**
+* Preloads only the fonts (and emoji) a VirtualMediaData tree's text uses, so
+* typography renders correctly on Node.js without loading its media. Shared
+* with the browser preview; emoji need a font set with
+* `FontManager.registerEmojiFont()`.
+*/
+async function preloadFonts(media, device = null) {
+	if (!media) return;
+	await preloadCompositionFonts(media, device, (err, what) => rendererLogger.error(err, `[HeadlessMediaRenderer] Failed to preload ${what}`));
+}
+/**
+* Pipelined Asynchronous DMA Staging Ring for WebGPU.
+*
+* Implements double-buffered (or N-buffered) GPU staging buffers to overlap
+* GPU render passes with asynchronous DMA host transfers and WebCodecs hardware encoding.
+* Eliminates GPU stalls by allowing Frame i+1 to execute on the GPU while Frame i
+* is asynchronously mapped and consumed by the hardware video encoder.
+*/
+var DmaStagingRing = class {
+	width;
+	height;
+	capacity;
+	bytesPerRow;
+	unpaddedBytesPerRow;
+	bufferSize;
+	format;
+	device;
+	slots;
+	isDestroyed = false;
+	constructor(device, options) {
+		this.device = device;
+		this.width = options.width;
+		this.height = options.height;
+		this.capacity = Math.max(2, options.capacity ?? 2);
+		this.format = options.format ?? "rgba8unorm";
+		this.unpaddedBytesPerRow = this.width * 4;
+		const rowAlignment = 256;
+		this.bytesPerRow = Math.ceil(this.unpaddedBytesPerRow / rowAlignment) * rowAlignment;
+		this.bufferSize = this.bytesPerRow * this.height;
+		this.slots = [];
+		for (let i = 0; i < this.capacity; i++) {
+			const buffer = device.createBuffer({
+				size: this.bufferSize,
+				usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST
+			});
+			this.slots.push({
+				index: i,
+				buffer,
+				status: "idle",
+				inFlightFrame: null,
+				mapPromise: null
+			});
+		}
+	}
+	/**
+	* Prepares the staging buffer slot for writing by ensuring any prior mapping
+	* from a previous cycle has been completed and unmapped.
+	*/
+	async prepareSlot(frameIndex) {
+		this.checkDestroyed();
+		const slot = this.slots[frameIndex % this.capacity];
+		if (!slot) return;
+		if (slot.status === "mapping" && slot.mapPromise) await slot.mapPromise;
+		if (slot.status === "mapped") {
+			slot.buffer.unmap();
+			slot.status = "idle";
+			slot.inFlightFrame = null;
+			slot.mapPromise = null;
+		}
+	}
+	/**
+	* Records a GPU-to-buffer DMA copy command into the provided command encoder.
+	*/
+	stageTexture(encoder, texture, frameIndex) {
+		this.checkDestroyed();
+		const slot = this.slots[frameIndex % this.capacity];
+		if (!slot) throw new Error(`Invalid slot index for frame ${frameIndex}`);
+		if (slot.status === "mapped" || slot.status === "mapping") throw new Error(`Staging buffer slot ${slot.index} is busy (status: ${slot.status}) for frame ${frameIndex}. Call prepareSlot() before staging.`);
+		encoder.copyTextureToBuffer({ texture }, {
+			buffer: slot.buffer,
+			bytesPerRow: this.bytesPerRow
+		}, [this.width, this.height]);
+		slot.status = "rendering";
+		slot.inFlightFrame = frameIndex;
+	}
+	/**
+	* Initiates asynchronous DMA mapping on the slot for the specified frame.
+	* Must be called immediately after submitting the command encoder to the device queue.
+	*/
+	scheduleMap(frameIndex) {
+		this.checkDestroyed();
+		const slot = this.slots[frameIndex % this.capacity];
+		if (!slot) throw new Error(`Invalid slot index for frame ${frameIndex}`);
+		slot.status = "mapping";
+		const mapPromise = slot.buffer.mapAsync(GPUMapMode.READ).then(() => {
+			slot.status = "mapped";
+		});
+		slot.mapPromise = mapPromise;
+		return mapPromise;
+	}
+	/**
+	* Awaits asynchronous mapping and extracts pixels into a tightly packed Uint8Array.
+	* The slot remains in the "mapped" state until releaseFrame() is called.
+	*/
+	async readFramePixels(frameIndex) {
+		this.checkDestroyed();
+		const slot = this.slots[frameIndex % this.capacity];
+		if (!slot) throw new Error(`Invalid slot index for frame ${frameIndex}`);
+		if (slot.mapPromise) await slot.mapPromise;
+		if (slot.status !== "mapped") throw new Error(`Staging slot ${slot.index} is not mapped (status: ${slot.status}) for frame ${frameIndex}`);
+		const mappedRange = slot.buffer.getMappedRange();
+		const sourceView = new Uint8Array(mappedRange);
+		const output = new Uint8Array(this.unpaddedBytesPerRow * this.height);
+		if (this.bytesPerRow === this.unpaddedBytesPerRow) output.set(sourceView);
+		else for (let y = 0; y < this.height; y++) {
+			const srcOffset = y * this.bytesPerRow;
+			const dstOffset = y * this.unpaddedBytesPerRow;
+			output.set(sourceView.subarray(srcOffset, srcOffset + this.unpaddedBytesPerRow), dstOffset);
+		}
+		return output;
+	}
+	/**
+	* Awaits asynchronous mapping, extracts pixels, and immediately unmaps the staging buffer,
+	* returning the slot to "idle" state so it can be reused immediately.
+	*/
+	async readAndReleaseFrame(frameIndex) {
+		const pixels = await this.readFramePixels(frameIndex);
+		this.releaseFrame(frameIndex);
+		return pixels;
+	}
+	/**
+	* Directly reads the mapped staging buffer into a WebCodecs VideoFrame,
+	* bypassing redundant intermediate JS allocations when row pitches align,
+	* and immediately unmaps the buffer.
+	*/
+	async readFrameToVideoFrame(frameIndex, timestampUs, colorSpace, inspect) {
+		this.checkDestroyed();
+		const slot = this.slots[frameIndex % this.capacity];
+		if (!slot) throw new Error(`Invalid slot index for frame ${frameIndex}`);
+		if (slot.mapPromise) await slot.mapPromise;
+		if (slot.status !== "mapped") throw new Error(`Staging slot ${slot.index} is not mapped (status: ${slot.status}) for frame ${frameIndex}`);
+		const mappedRange = slot.buffer.getMappedRange();
+		const sourceView = new Uint8Array(mappedRange);
+		let pixelData;
+		if (this.bytesPerRow === this.unpaddedBytesPerRow) pixelData = sourceView;
+		else {
+			pixelData = new Uint8Array(this.unpaddedBytesPerRow * this.height);
+			for (let y = 0; y < this.height; y++) {
+				const srcOffset = y * this.bytesPerRow;
+				const dstOffset = y * this.unpaddedBytesPerRow;
+				pixelData.set(sourceView.subarray(srcOffset, srcOffset + this.unpaddedBytesPerRow), dstOffset);
+			}
+		}
+		inspect?.(pixelData);
+		const vf = new VideoFrame(pixelData, {
+			format: "RGBA",
+			codedWidth: this.width,
+			codedHeight: this.height,
+			timestamp: timestampUs,
+			colorSpace: {
+				primaries: colorSpace?.primaries ?? "bt709",
+				transfer: colorSpace?.transfer ?? "bt709",
+				matrix: colorSpace?.matrix ?? "bt709",
+				fullRange: colorSpace?.fullRange ?? false
+			}
+		});
+		this.releaseFrame(frameIndex);
+		return vf;
+	}
+	/**
+	* Unmaps the staging buffer for the specified frame and marks the slot idle.
+	*/
+	releaseFrame(frameIndex) {
+		const slot = this.slots[frameIndex % this.capacity];
+		if (!slot) return;
+		if (slot.status === "mapped") {
+			try {
+				slot.buffer.unmap();
+			} catch (_) {}
+			slot.status = "idle";
+			slot.inFlightFrame = null;
+			slot.mapPromise = null;
+		}
+	}
+	/**
+	* Returns current status info for each slot in the ring.
+	*/
+	getSlotInfos() {
+		return this.slots.map((slot) => ({
+			index: slot.index,
+			status: slot.status,
+			inFlightFrame: slot.inFlightFrame
+		}));
+	}
+	/**
+	* Destroys all staging buffers and releases resources.
+	*/
+	destroy() {
+		if (this.isDestroyed) return;
+		this.isDestroyed = true;
+		for (const slot of this.slots) {
+			if (slot.status === "mapped") try {
+				slot.buffer.unmap();
+			} catch (_) {}
+			slot.status = "idle";
+			slot.inFlightFrame = null;
+			slot.mapPromise = null;
+		}
+		this.slots.length = 0;
+	}
+	checkDestroyed() {
+		if (this.isDestroyed) throw new Error("DmaStagingRing has been destroyed");
+	}
+};
+const BUILTIN_NODE_RENDERERS = [
+	{
+		packageName: "@framefields/node-lut",
+		ops: ["ApplyLUT"],
+		load: () => import("./renderer-CFqhAXkH.mjs")
+	},
+	{
+		packageName: "@framefields/node-audio-compressor",
+		ops: ["AudioCompressor"],
+		load: () => import("./renderer-CbiEBSGx.mjs")
+	},
+	{
+		packageName: "@framefields/node-audio-delay",
+		ops: ["AudioDelay"],
+		load: () => import("./renderer-hY_2WLt3.mjs")
+	},
+	{
+		packageName: "@framefields/node-audio-fade",
+		ops: ["AudioFade"],
+		load: () => import("./renderer-BKEfeg-4.mjs")
+	},
+	{
+		packageName: "@framefields/node-audio-noise-gate",
+		ops: ["AudioNoiseGate"],
+		load: () => import("./renderer-VuXt1hfq.mjs")
+	},
+	{
+		packageName: "@framefields/node-audio-parametric-eq",
+		ops: ["AudioParametricEq"],
+		load: () => import("./renderer-CTVnQAUm.mjs")
+	},
+	{
+		packageName: "@framefields/node-audio-reverb",
+		ops: ["AudioReverb"],
+		load: () => import("./renderer-B_3h5nhy.mjs")
+	},
+	{
+		packageName: "@framefields/node-audio-signal-extractor",
+		ops: ["AudioSignalExtractor"],
+		load: () => import("./renderer-CQPuuoVf.mjs")
+	},
+	{
+		packageName: "@framefields/node-blur",
+		ops: ["Blur"],
+		load: () => import("./renderer-T0LJ4Po3.mjs")
+	},
+	{
+		packageName: "@framefields/node-camera-parallax-3d",
+		ops: ["CameraParallax3D"],
+		load: () => import("./renderer-BKf1qDwL.mjs")
+	},
+	{
+		packageName: "@framefields/node-canvas-generator",
+		ops: ["CanvasGenerator"],
+		load: () => import("./renderer-DYIPWN_B.mjs")
+	},
+	{
+		packageName: "@framefields/node-channel-merger",
+		ops: ["ChannelMerger"],
+		load: () => import("./renderer-DoYdfDEA.mjs")
+	},
+	{
+		packageName: "@framefields/node-channel-splitter",
+		ops: ["ChannelSplitter"],
+		load: () => import("./renderer-Bg7647VN.mjs")
+	},
+	{
+		packageName: "@framefields/node-color-balance",
+		ops: ["ColorBalance"],
+		load: () => import("./renderer-9L0p8IT3.mjs")
+	},
+	{
+		packageName: "@framefields/node-colorkey",
+		ops: ["ColorKey"],
+		load: () => import("./renderer-B-cxK24t.mjs")
+	},
+	{
+		packageName: "@framefields/node-compositor",
+		ops: ["Compositor"],
+		load: () => import("./renderer-_1xGBbxn.mjs")
+	},
+	{
+		packageName: "@framefields/node-corner-pin",
+		ops: ["CornerPin"],
+		load: () => import("./renderer-DOmA6IKc.mjs")
+	},
+	{
+		packageName: "@framefields/node-crop",
+		ops: ["Crop"],
+		load: () => import("./renderer-C14mKYCw.mjs")
+	},
+	{
+		packageName: "@framefields/node-curves",
+		ops: ["Curves"],
+		load: () => import("./renderer-B8BdNjaN.mjs")
+	},
+	{
+		packageName: "@framefields/node-deflicker",
+		ops: ["TemporalDeflicker", "Deflicker"],
+		load: () => import("./renderer-CvIGa0mE.mjs")
+	},
+	{
+		packageName: "@framefields/node-displacement-map",
+		ops: ["DisplacementMap"],
+		load: () => import("./renderer-COwa6xlF.mjs")
+	},
+	{
+		packageName: "@framefields/node-extract-frame",
+		ops: ["ExtractFrame"],
+		load: () => import("./renderer-qsg-JMuN.mjs")
+	},
+	{
+		packageName: "@framefields/node-extract-lut",
+		ops: ["ExtractLUT"],
+		load: () => import("./renderer-Dy-DBU0X.mjs")
+	},
+	{
+		packageName: "@framefields/node-film-grain",
+		ops: ["FilmGrain"],
+		load: () => import("./renderer-CK-spD4j.mjs")
+	},
+	{
+		packageName: "@framefields/node-flip",
+		ops: ["Flip"],
+		load: () => import("./renderer-1VSi7Vum.mjs")
+	},
+	{
+		packageName: "@framefields/node-gradient-map",
+		ops: ["GradientMap"],
+		load: () => import("./renderer-BhhSyHKF.mjs")
+	},
+	{
+		packageName: "@framefields/node-halftone-screen",
+		ops: ["HalftoneScreen"],
+		load: () => import("./renderer-Q75RC5Uz.mjs")
+	},
+	{
+		packageName: "@framefields/node-high-pass",
+		ops: ["HighPass"],
+		load: () => import("./renderer-DmCWc4JL.mjs")
+	},
+	{
+		packageName: "@framefields/node-kenburns",
+		ops: ["KenBurns"],
+		load: () => import("./renderer-4BlpUHQT.mjs")
+	},
+	{
+		packageName: "@framefields/node-layer-style",
+		ops: ["LayerStyle"],
+		load: () => import("./renderer-CRd-cDqZ.mjs")
+	},
+	{
+		packageName: "@framefields/node-levels",
+		ops: ["Levels"],
+		load: () => import("./renderer-AzSX2-mZ.mjs")
+	},
+	{
+		packageName: "@framefields/node-liquify",
+		ops: ["Liquify"],
+		load: () => import("./renderer-BaZjoFYK.mjs")
+	},
+	{
+		packageName: "@framefields/node-mask-math",
+		ops: ["MaskMath"],
+		load: () => import("./renderer-CLLzQTIk.mjs")
+	},
+	{
+		packageName: "@framefields/node-mesh-warp",
+		ops: ["MeshWarp"],
+		load: () => import("./renderer-BLLOkeFB.mjs")
+	},
+	{
+		packageName: "@framefields/node-modulate",
+		ops: ["Modulate"],
+		load: () => import("./renderer-BcApaCVe.mjs")
+	},
+	{
+		packageName: "@framefields/node-noise-generator",
+		ops: ["NoiseGenerator"],
+		load: () => import("./renderer-timEC0Gl.mjs")
+	},
+	{
+		packageName: "@framefields/node-paint",
+		ops: ["Paint"],
+		load: () => import("./renderer-DOHbhGPu.mjs")
+	},
+	{
+		packageName: "@framefields/node-patch-heal",
+		ops: ["PatchHeal"],
+		load: () => import("./renderer-c4AorKyw.mjs")
+	},
+	{
+		packageName: "@framefields/node-refine-edge",
+		ops: ["RefineEdge"],
+		load: () => import("./renderer-CmuGGUDR.mjs")
+	},
+	{
+		packageName: "@framefields/node-refraction-caustics",
+		ops: ["RefractionCaustics3D"],
+		load: () => import("./renderer-DGtBOdst.mjs")
+	},
+	{
+		packageName: "@framefields/node-relight-3d",
+		ops: ["Relight3D"],
+		load: () => import("./renderer-y4EqE06a.mjs")
+	},
+	{
+		packageName: "@framefields/node-resizer-scaler",
+		ops: ["ResizerScaler"],
+		load: () => import("./renderer-CzBQgGD2.mjs")
+	},
+	{
+		packageName: "@framefields/node-rotate",
+		ops: ["Rotate"],
+		load: () => import("./renderer-Cl7PruQ1.mjs")
+	},
+	{
+		packageName: "@framefields/node-selective-color",
+		ops: ["SelectiveColor"],
+		load: () => import("./renderer-B5d5oM_D.mjs")
+	},
+	{
+		packageName: "@framefields/node-shadows-highlights",
+		ops: ["ShadowsHighlights"],
+		load: () => import("./renderer-CoNRrfqx.mjs")
+	},
+	{
+		packageName: "@framefields/node-shape-generator",
+		ops: ["ShapeGenerator"],
+		load: () => import("./renderer-Da06_9FZ.mjs")
+	},
+	{
+		packageName: "@framefields/node-signal-gate",
+		ops: ["SignalGate"],
+		load: () => import("./renderer-DuuOlYIG.mjs")
+	},
+	{
+		packageName: "@framefields/node-stereo-panning",
+		ops: ["StereoPanning"],
+		load: () => import("./renderer-CwMDPv0p.mjs")
+	},
+	{
+		packageName: "@framefields/node-tile-offset",
+		ops: ["TileOffset"],
+		load: () => import("./renderer-BVun05IK.mjs")
+	},
+	{
+		packageName: "@framefields/node-unsharp-mask",
+		ops: ["UnsharpMask"],
+		load: () => import("./renderer-OLaYikwi.mjs")
+	},
+	{
+		packageName: "@framefields/node-vignette",
+		ops: ["Vignette"],
+		load: () => import("./renderer-BTvov1NH.mjs")
+	},
+	{
+		packageName: "@framefields/node-vision",
+		ops: ["Vision"],
+		load: () => import("./renderer-GSFP7v2z.mjs")
+	}
+];
+/**
+* The `framefields` block of a node package's `package.json`.
+*
+* This is the single declaration of a node's op: renderer discovery, the
+* effects generator (`scripts/generate-effects.ts`) and the skill catalog all
+* read it from here. There is deliberately no fallback that derives an op from
+* the package name. See `spec/sync-node.md` §5.1.
+*/
+const NODE_KINDS = [
+	"effect",
+	"audio",
+	"source",
+	"signal",
+	"utility"
+];
+const IDENTIFIER = /^[A-Za-z][A-Za-z0-9]*$/;
+var NodeManifestError = class extends Error {
+	constructor(problems) {
+		super(`Invalid node manifest(s):\n${problems.map((p) => `  - ${p}`).join("\n")}`);
+		this.problems = problems;
+		this.name = "NodeManifestError";
+	}
+};
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Validates one parsed `package.json`. Returns the manifest, or the list of
+* problems that make it unusable. Never throws.
+*/
+function parseNodeManifest(pkg, dir, nodePath = dir) {
+	const problems = [];
+	if (!isRecord(pkg)) return { problems: [`${dir}: package.json is not an object`] };
+	const block = pkg.framefields;
+	if (!isRecord(block)) return { problems: [`${dir}: package.json has no "framefields" block (expected { "type": "<Op>", "kind": "<kind>" })`] };
+	const { type, kind, aliases, schema, className, factory, custom } = block;
+	if (typeof type !== "string" || !IDENTIFIER.test(type)) problems.push(`${dir}: framefields.type must be an op identifier`);
+	if (typeof kind !== "string" || !NODE_KINDS.includes(kind)) problems.push(`${dir}: framefields.kind must be one of ${NODE_KINDS.join(", ")}`);
+	if (aliases !== void 0 && !(Array.isArray(aliases) && aliases.every((a) => typeof a === "string" && IDENTIFIER.test(a)))) problems.push(`${dir}: framefields.aliases must be an array of op identifiers`);
+	for (const [key, value] of Object.entries({
+		schema,
+		className,
+		factory
+	})) if (value !== void 0 && (typeof value !== "string" || !IDENTIFIER.test(value))) problems.push(`${dir}: framefields.${key} must be an identifier`);
+	if (custom !== void 0 && typeof custom !== "boolean") problems.push(`${dir}: framefields.custom must be a boolean`);
+	if (problems.length > 0) return { problems };
+	const exportsField = isRecord(pkg.exports) ? pkg.exports["./renderer"] : null;
+	const legacy = isRecord(pkg.gatewai) ? pkg.gatewai : {};
+	return {
+		problems,
+		manifest: {
+			dir,
+			path: nodePath,
+			packageName: typeof pkg.name === "string" ? pkg.name : dir,
+			type,
+			kind,
+			aliases: aliases ?? [],
+			schema,
+			className,
+			factory,
+			custom: custom === true,
+			enabled: legacy.enabled !== false,
+			rendererExports: isRecord(exportsField) ? exportsField : void 0
+		}
+	};
+}
+/**
+* Reads every `nodes/node-*` package and returns its manifest, sorted by
+* directory name. Throws a single {@link NodeManifestError} listing every
+* problem: a missing or malformed block, or an op/alias claimed twice.
+*/
+function loadNodeManifests(nodesDir) {
+	const problems = [];
+	const manifests = [];
+	const dirs = fs.readdirSync(nodesDir).filter((d) => d.startsWith("node-") && fs.existsSync(path.join(nodesDir, d, "package.json"))).sort();
+	for (const dir of dirs) {
+		const nodePath = path.join(nodesDir, dir);
+		let pkg;
+		try {
+			pkg = JSON.parse(fs.readFileSync(path.join(nodePath, "package.json"), "utf-8"));
+		} catch (err) {
+			problems.push(`${dir}: package.json is not valid JSON (${String(err)})`);
+			continue;
+		}
+		const parsed = parseNodeManifest(pkg, dir, nodePath);
+		problems.push(...parsed.problems);
+		if (parsed.manifest) manifests.push(parsed.manifest);
+	}
+	const owners = /* @__PURE__ */ new Map();
+	for (const manifest of manifests) for (const op of [manifest.type, ...manifest.aliases]) {
+		const owner = owners.get(op);
+		if (owner) problems.push(`${manifest.dir}: op "${op}" is already declared by ${owner}`);
+		else owners.set(op, manifest.dir);
+	}
+	if (problems.length > 0) throw new NodeManifestError(problems);
+	return manifests;
+}
+let __filename = "";
+let __dirname = "";
+if (typeof process !== "undefined" && !!process.versions?.node) {
+	__filename = fileURLToPath(import.meta.url);
+	__dirname = path.dirname(__filename);
+}
+/**
+* Picks the renderer entry file: development source in dev/vitest, otherwise
+* the bundled dist, falling back to source when dist has not been built.
+*/
+function resolveRendererEntry(nodePath, rendererExports) {
+	const exists = (rel) => !!rel && fs.existsSync(path.join(nodePath, rel));
+	if ((process.env.NODE_ENV !== "production" || Boolean(process.env.VITEST)) && exists(rendererExports.development)) return rendererExports.development;
+	const bundled = rendererExports.import || rendererExports.default;
+	if (exists(bundled)) return bundled;
+	if (exists(rendererExports.development)) return rendererExports.development;
+}
+async function registerNode(manifest) {
+	if (!manifest.rendererExports) return;
+	const entry = resolveRendererEntry(manifest.path, manifest.rendererExports);
+	if (!entry) return;
+	const mod = await import(pathToFileURL(path.join(manifest.path, entry)).href);
+	registerPlugin([manifest.type, ...manifest.aliases], mod?.default);
+}
+function registerPlugin(ops, rendererPlugin) {
+	if (!rendererPlugin) return;
+	if (rendererPlugin.WebGPURenderer) for (const op of ops) registerWebGPURenderer(op, rendererPlugin.WebGPURenderer);
+	if (rendererPlugin.audioProcessor) for (const op of ops) audioRegistry.register(op, rendererPlugin.audioProcessor);
+}
+/**
+* Registers the renderers bundled with this package. They are imported by
+* package name, so they resolve from `node_modules` (or the published bundle)
+* and never depend on a `nodes/` directory on disk.
+*/
+async function registerBuiltinNodeRenderers() {
+	const failed = [];
+	await Promise.all(BUILTIN_NODE_RENDERERS.map(async ({ packageName, ops, load }) => {
+		try {
+			registerPlugin(ops, (await load()).default);
+		} catch (err) {
+			failed.push(packageName);
+			console.error(`[HeadlessWebGPURenderer] Failed to load renderer ${packageName}:`, err);
+		}
+	}));
+	if (failed.length === BUILTIN_NODE_RENDERERS.length) throw new Error("[HeadlessWebGPURenderer] No built-in node renderers could be loaded.");
+}
+/**
+* Registers the built-in node renderers, then any extra nodes found in the
+* directory named by `FRAMEFIELDS_NODES_DIR` (local node development). A node in
+* that directory overrides the built-in renderer for the same op.
+*/
+async function discoverAndRegisterNodeRenderers() {
+	if (typeof process === "undefined" || !process.versions?.node) return;
+	await registerBuiltinNodeRenderers();
+	const extraDir = process.env.FRAMEFIELDS_NODES_DIR;
+	if (!extraDir) return;
+	const nodesDir = path.resolve(extraDir);
+	if (!fs.existsSync(nodesDir)) {
+		console.warn(`[HeadlessWebGPURenderer] FRAMEFIELDS_NODES_DIR does not exist: ${nodesDir}`);
+		return;
+	}
+	rendererLogger.debug(`[HeadlessWebGPURenderer] Discovering node renderers in: ${nodesDir}`);
+	const manifests = loadNodeManifests(nodesDir);
+	for (const manifest of manifests) {
+		if (!manifest.enabled) continue;
+		try {
+			await registerNode(manifest);
+		} catch (err) {
+			console.error(`[HeadlessWebGPURenderer] Failed to discover renderer for node ${manifest.dir}:`, err);
+		}
+	}
+}
+const isAMD = () => {
+	if (process.platform !== "linux") return false;
+	try {
+		if (fs.existsSync("/sys/module/amdgpu") || fs.existsSync("/dev/kfd")) return true;
+		const drmDir = "/sys/class/drm";
+		if (fs.existsSync(drmDir)) {
+			const files = fs.readdirSync(drmDir);
+			for (const file of files) {
+				const vendorPath = `${drmDir}/${file}/device/vendor`;
+				if (fs.existsSync(vendorPath)) {
+					if (fs.readFileSync(vendorPath, "utf8").trim() === "0x1002") return true;
+				}
+			}
+		}
+	} catch {}
+	return false;
+};
+const bootstrapMediabunny = () => {
+	const getHardwareContextOption = () => {
+		if (isAMD()) return { hardwareContext: null };
+		return {};
+	};
+	registerMediabunnyServer(getHardwareContextOption());
+	for (const key of Object.keys(webcodecs)) if (typeof globalThis[key] === "undefined") globalThis[key] = webcodecs[key];
+};
+
+//#endregion
+//#region ../renderer/dist/headless-webgpu-renderer-D4Uc6ba-.mjs
+const DEFAULTS = {
+	blackPixelThreshold: .1,
+	blackFrameRatio: .98,
+	minBlackSec: .5,
+	minFrozenSec: 2,
+	silenceDbfs: -60,
+	minSilenceSec: 2,
+	lufsTolerance: 1
+};
+const SAMPLE_STEP = 4;
+const FROZEN_DIFF = .25;
+/** Measures frames handed to it in order, as RGBA bytes. */
+var FrameInspector = class {
+	blackLuma;
+	blackRatio;
+	black = [];
+	sameAsPrevious = [];
+	lumaSum = 0;
+	previous = null;
+	constructor(options = {}) {
+		this.blackLuma = (options.blackPixelThreshold ?? DEFAULTS.blackPixelThreshold) * 255;
+		this.blackRatio = options.blackFrameRatio ?? DEFAULTS.blackFrameRatio;
+	}
+	get frameCount() {
+		return this.black.length;
+	}
+	inspect(rgba, width, height) {
+		const cols = Math.ceil(width / SAMPLE_STEP);
+		const rows = Math.ceil(height / SAMPLE_STEP);
+		const luma = new Uint8Array(cols * rows);
+		let blackCount = 0;
+		let sum = 0;
+		let k = 0;
+		for (let y = 0; y < height; y += SAMPLE_STEP) {
+			let p = y * width * 4;
+			for (let x = 0; x < width; x += SAMPLE_STEP, p += SAMPLE_STEP * 4) {
+				const l = .2126 * rgba[p] + .7152 * rgba[p + 1] + .0722 * rgba[p + 2];
+				luma[k++] = l;
+				sum += l;
+				if (l <= this.blackLuma) blackCount++;
+			}
+		}
+		const n = luma.length;
+		this.lumaSum += sum / n / 255;
+		this.black.push(blackCount / n >= this.blackRatio);
+		let same = false;
+		if (this.previous && this.previous.length === n) {
+			let diff = 0;
+			for (let i = 0; i < n; i++) diff += Math.abs(luma[i] - this.previous[i]);
+			same = diff / n < FROZEN_DIFF;
+		}
+		this.sameAsPrevious.push(same);
+		this.previous = luma;
+	}
+	stats(expectedFrames, encodedFrames, fps, width, height, options = {}) {
+		const minBlack = Math.max(1, Math.round((options.minBlackSec ?? DEFAULTS.minBlackSec) * fps));
+		const minFrozen = Math.max(2, Math.round((options.minFrozenSec ?? DEFAULTS.minFrozenSec) * fps));
+		const blackSegments = runs(this.black, minBlack).map(([a, b]) => ({
+			startSec: a / fps,
+			endSec: b / fps
+		}));
+		const frozenSegments = runs(this.sameAsPrevious, minFrozen - 1).map(([a, b]) => ({
+			startSec: (a - 1) / fps,
+			endSec: b / fps
+		}));
+		return {
+			expectedFrames,
+			encodedFrames,
+			fps,
+			width,
+			height,
+			meanLuma: this.frameCount > 0 ? this.lumaSum / this.frameCount : 0,
+			blackSegments,
+			frozenSegments
+		};
+	}
+};
+/** [start, end) index ranges where flags hold for at least minLength in a row. */
+function runs(flags, minLength) {
+	const out = [];
+	let start = -1;
+	for (let i = 0; i <= flags.length; i++) if (i < flags.length && flags[i]) {
+		if (start < 0) start = i;
+	} else if (start >= 0) {
+		if (i - start >= minLength) out.push([start, i]);
+		start = -1;
+	}
+	return out;
+}
+const toDb = (power) => power > 0 ? 10 * Math.log10(power) : -Infinity;
+/** Measures a mixed audio track (one Float32Array per channel). */
+function analyzeAudio(channels, sampleRate, options = {}) {
+	const length = channels[0]?.length ?? 0;
+	let peak = 0;
+	let sumSquares = 0;
+	let clipped = 0;
+	for (const ch of channels) for (let i = 0; i < length; i++) {
+		const v = Math.abs(ch[i]);
+		if (v > peak) peak = v;
+		if (v >= .9999) clipped++;
+		sumSquares += v * v;
+	}
+	const total = length * Math.max(1, channels.length);
+	const silenceDbfs = options.silenceDbfs ?? DEFAULTS.silenceDbfs;
+	const window = Math.max(1, Math.round(sampleRate * .1));
+	const silent = [];
+	for (let start = 0; start < length; start += window) {
+		const end = Math.min(length, start + window);
+		let s = 0;
+		for (const ch of channels) for (let i = start; i < end; i++) s += ch[i] * ch[i];
+		silent.push(toDb(s / ((end - start) * channels.length)) < silenceDbfs);
+	}
+	const silentSegments = runs(silent, Math.max(1, Math.round((options.minSilenceSec ?? DEFAULTS.minSilenceSec) / .1))).map(([a, b]) => ({
+		startSec: a * window / sampleRate,
+		endSec: Math.min(length, b * window) / sampleRate
+	}));
+	const peakDbfs = 20 * Math.log10(Math.max(peak, 1e-12));
+	return {
+		sampleRate,
+		channels: channels.length,
+		durationSec: length / sampleRate,
+		peakDbfs,
+		rmsDbfs: toDb(sumSquares / Math.max(1, total)),
+		integratedLufs: peakDbfs < silenceDbfs ? null : integratedLoudness(channels, sampleRate),
+		clippedSamples: clipped,
+		silentSegments
+	};
+}
+/** BS.1770 K-weighting stage 1: +4 dB high shelf around 1.5 kHz (the head). */
+function highShelf(sampleRate) {
+	const A = 10 ** (4 / 40);
+	const w0 = 2 * Math.PI * 1500 / sampleRate;
+	const cos = Math.cos(w0);
+	const alpha = Math.sin(w0) / (2 / Math.SQRT2);
+	const sq = 2 * Math.sqrt(A) * alpha;
+	const a0 = A + 1 - (A - 1) * cos + sq;
+	return {
+		b0: A * (A + 1 + (A - 1) * cos + sq) / a0,
+		b1: -2 * A * (A - 1 + (A + 1) * cos) / a0,
+		b2: A * (A + 1 + (A - 1) * cos - sq) / a0,
+		a1: 2 * (A - 1 - (A + 1) * cos) / a0,
+		a2: (A + 1 - (A - 1) * cos - sq) / a0
+	};
+}
+/** BS.1770 K-weighting stage 2: 38 Hz high pass, Q 0.5 (the RLB curve). */
+function highPass(sampleRate) {
+	const w0 = 2 * Math.PI * 38 / sampleRate;
+	const cos = Math.cos(w0);
+	const alpha = Math.sin(w0) / (2 * .5);
+	const a0 = 1 + alpha;
+	return {
+		b0: (1 + cos) / 2 / a0,
+		b1: -(1 + cos) / a0,
+		b2: (1 + cos) / 2 / a0,
+		a1: -2 * cos / a0,
+		a2: (1 - alpha) / a0
+	};
+}
+function filter(input, f) {
+	const out = new Float32Array(input.length);
+	let x1 = 0;
+	let x2 = 0;
+	let y1 = 0;
+	let y2 = 0;
+	for (let i = 0; i < input.length; i++) {
+		const x = input[i];
+		const y = f.b0 * x + f.b1 * x1 + f.b2 * x2 - f.a1 * y1 - f.a2 * y2;
+		out[i] = y;
+		x2 = x1;
+		x1 = x;
+		y2 = y1;
+		y1 = y;
+	}
+	return out;
+}
+/**
+* ITU-R BS.1770-4 integrated loudness (LUFS): K-weighted mean square in
+* 400 ms blocks with 75% overlap, gated at -70 LUFS and then at 10 LU below
+* the mean of what passed. Channels weigh 1 (stereo and mono layouts).
+*/
+function integratedLoudness(channels, sampleRate) {
+	const shelf = highShelf(sampleRate);
+	const hp = highPass(sampleRate);
+	const weighted = channels.map((ch) => filter(filter(ch, shelf), hp));
+	const length = weighted[0]?.length ?? 0;
+	const block = Math.round(.4 * sampleRate);
+	const hop = Math.round(.1 * sampleRate);
+	if (length < block) return null;
+	const blockPower = [];
+	for (let start = 0; start + block <= length; start += hop) {
+		let power = 0;
+		for (const ch of weighted) {
+			let s = 0;
+			for (let i = start; i < start + block; i++) s += ch[i] * ch[i];
+			power += s / block;
+		}
+		blockPower.push(power);
+	}
+	const lufs = (power) => -.691 + toDb(power);
+	const mean = (xs) => xs.reduce((a, b) => a + b, 0) / xs.length;
+	const absolute = blockPower.filter((p) => lufs(p) > -70);
+	if (absolute.length === 0) return null;
+	const relativeGate = lufs(mean(absolute)) - 10;
+	const gated = absolute.filter((p) => lufs(p) > relativeGate);
+	return gated.length > 0 ? lufs(mean(gated)) : null;
+}
+/** Turn measurements and document diagnostics into a report with issues. */
+function buildQaReport(parts) {
+	const { video, audio, options = {} } = parts;
+	const issues = [];
+	const at = (s) => `${s.startSec.toFixed(2)}–${s.endSec.toFixed(2)} s`;
+	if (video) {
+		if (video.encodedFrames !== video.expectedFrames) issues.push({
+			severity: "error",
+			code: "frames_missing",
+			message: `${video.encodedFrames} of ${video.expectedFrames} frames were encoded`
+		});
+		for (const s of video.blackSegments) issues.push({
+			severity: "warning",
+			code: "black_frames",
+			message: `Black frames at ${at(s)}`,
+			...s
+		});
+		for (const s of video.frozenSegments) issues.push({
+			severity: "info",
+			code: "frozen_video",
+			message: `Picture does not change at ${at(s)}`,
+			...s
+		});
+	}
+	if (audio) if (audio.integratedLufs === null) issues.push({
+		severity: "info",
+		code: "audio_silent",
+		message: "The audio track is silent"
+	});
+	else {
+		if (audio.clippedSamples > 0) issues.push({
+			severity: "warning",
+			code: "audio_clipping",
+			message: `${audio.clippedSamples} audio sample(s) at or beyond full scale (peak ${audio.peakDbfs.toFixed(1)} dBFS)`
+		});
+		for (const s of audio.silentSegments) issues.push({
+			severity: "info",
+			code: "audio_silence",
+			message: `Silence at ${at(s)}`,
+			...s
+		});
+		if (options.targetLufs !== void 0) {
+			const off = audio.integratedLufs - options.targetLufs;
+			const tolerance = options.lufsTolerance ?? DEFAULTS.lufsTolerance;
+			if (Math.abs(off) > tolerance) issues.push({
+				severity: "warning",
+				code: "loudness_off_target",
+				message: `Integrated loudness ${audio.integratedLufs.toFixed(1)} LUFS is ${Math.abs(off).toFixed(1)} LU ${off > 0 ? "above" : "below"} the ${options.targetLufs} LUFS target`
+			});
+		}
+	}
+	for (const d of parts.diagnostics ?? []) issues.push({
+		severity: d.severity,
+		code: d.code,
+		message: d.message,
+		...d.layerId !== void 0 && { layerId: d.layerId }
+	});
+	return {
+		passed: !issues.some((i) => i.severity !== "info"),
+		...video && { video },
+		...audio && { audio },
+		issues
+	};
+}
+/** A short human- and agent-readable summary of a report. */
+function formatQaReport(report) {
+	const lines = [`QA ${report.passed ? "passed" : "FAILED"}`];
+	const v = report.video;
+	if (v) lines.push(`  video: ${v.encodedFrames}/${v.expectedFrames} frames, ${v.width}x${v.height} @ ${v.fps} fps, mean luma ${v.meanLuma.toFixed(2)}`);
+	const a = report.audio;
+	if (a) {
+		const lufs = a.integratedLufs === null ? "silent" : `${a.integratedLufs.toFixed(1)} LUFS`;
+		lines.push(`  audio: ${a.durationSec.toFixed(2)} s, ${lufs}, peak ${a.peakDbfs.toFixed(1)} dBFS, rms ${a.rmsDbfs.toFixed(1)} dBFS`);
+	}
+	for (const i of report.issues) lines.push(`  ${i.severity.padEnd(7)} ${i.code}: ${i.message}`);
+	return lines.join("\n");
+}
+/**
+* High-performance hardware video encoding pipeline integrating WebGPU textures with WebCodecs.
+*
+* Provides:
+* 1. Direct hardware acceleration when running with WebCodecs / OffscreenCanvas.
+* 2. Pipelined asynchronous double-buffered DMA staging ring for headless Node.js (Dawn native),
+*    allowing GPU Frame i+1 rendering to overlap concurrently with Frame i hardware encoding.
+*/
+var ZeroCopyWebCodecsPipeline = class {
+	width;
+	height;
+	fps;
+	ringCapacity;
+	device;
+	videoSource;
+	stagingRing;
+	colorSpace;
+	directCanvasSource;
+	onFrame;
+	inFlightFrames = [];
+	cycleStartTimes = /* @__PURE__ */ new Map();
+	totalFramesEnqueued = 0;
+	totalFramesEncoded = 0;
+	totalGpuSubmitTimeMs = 0;
+	totalEncodeTimeMs = 0;
+	totalCycleTimeMs = 0;
+	maxCycleTimeMs = 0;
+	minCycleTimeMs = Number.POSITIVE_INFINITY;
+	pipelineStartTime = 0;
+	constructor(device, options) {
+		this.device = device;
+		this.width = options.width;
+		this.height = options.height;
+		this.fps = options.fps;
+		this.videoSource = options.videoSource;
+		this.ringCapacity = Math.max(2, options.ringCapacity ?? 2);
+		this.colorSpace = options.colorSpace;
+		this.directCanvasSource = options.directCanvasSource;
+		this.onFrame = options.onFrame;
+		this.stagingRing = new DmaStagingRing(device, {
+			width: this.width,
+			height: this.height,
+			capacity: this.ringCapacity
+		});
+		this.pipelineStartTime = performance.now();
+	}
+	/**
+	* Returns true if direct zero-copy from an OffscreenCanvas or texture is active.
+	*/
+	canDirectZeroCopy() {
+		return this.directCanvasSource !== void 0 && this.directCanvasSource !== null;
+	}
+	/**
+	* Enqueues a rendered GPU texture frame into the pipeline.
+	*
+	* Uses double-buffered DMA staging: if the staging ring has reached capacity,
+	* the oldest in-flight frame is asynchronously consumed and added to the video encoder
+	* before staging the new frame, guaranteeing constant bounded VRAM usage and zero GPU stalls.
+	*/
+	async enqueueFrame(frameIndex, targetTexture, encoder) {
+		const cycleStartTime = performance.now();
+		if (this.inFlightFrames.length >= this.ringCapacity) {
+			const oldestFrame = this.inFlightFrames.shift();
+			if (oldestFrame !== void 0) await this.consumeAndEncode(oldestFrame);
+		}
+		if (this.canDirectZeroCopy()) {
+			const gpuStart = performance.now();
+			this.device.queue.submit([encoder.finish()]);
+			this.totalGpuSubmitTimeMs += performance.now() - gpuStart;
+			this.cycleStartTimes.set(frameIndex, cycleStartTime);
+			this.totalFramesEnqueued++;
+			await this.consumeAndEncode(frameIndex);
+		} else {
+			await this.stagingRing.prepareSlot(frameIndex);
+			this.stagingRing.stageTexture(encoder, targetTexture, frameIndex);
+			const gpuStart = performance.now();
+			this.device.queue.submit([encoder.finish()]);
+			this.totalGpuSubmitTimeMs += performance.now() - gpuStart;
+			this.stagingRing.scheduleMap(frameIndex);
+			this.inFlightFrames.push(frameIndex);
+			this.cycleStartTimes.set(frameIndex, cycleStartTime);
+			this.totalFramesEnqueued++;
+		}
+	}
+	/**
+	* Drains all remaining in-flight frames in the pipeline, ensuring every enqueued
+	* frame has been encoded and added to the video sample source.
+	*/
+	async drain() {
+		while (this.inFlightFrames.length > 0) {
+			const frameIndex = this.inFlightFrames.shift();
+			if (frameIndex !== void 0) await this.consumeAndEncode(frameIndex);
+		}
+	}
+	/**
+	* Returns runtime throughput, latency, and pipeline statistics.
+	*/
+	getStats() {
+		const totalElapsedMs = performance.now() - this.pipelineStartTime;
+		const throughputFps = totalElapsedMs > 0 ? this.totalFramesEncoded / totalElapsedMs * 1e3 : 0;
+		const avgSubmit = this.totalFramesEnqueued > 0 ? this.totalGpuSubmitTimeMs / this.totalFramesEnqueued : 0;
+		const avgEncode = this.totalFramesEncoded > 0 ? this.totalEncodeTimeMs / this.totalFramesEncoded : 0;
+		const avgCycle = this.totalFramesEncoded > 0 ? this.totalCycleTimeMs / this.totalFramesEncoded : 0;
+		return {
+			totalFramesEnqueued: this.totalFramesEnqueued,
+			totalFramesEncoded: this.totalFramesEncoded,
+			averageGpuSubmitTimeMs: avgSubmit,
+			averageEncodeTimeMs: avgEncode,
+			averageCycleTimeMs: avgCycle,
+			maxCycleTimeMs: this.maxCycleTimeMs,
+			minCycleTimeMs: Number.isFinite(this.minCycleTimeMs) ? this.minCycleTimeMs : 0,
+			throughputFps,
+			ringCapacity: this.ringCapacity,
+			isDirectZeroCopy: this.canDirectZeroCopy()
+		};
+	}
+	/**
+	* Destroys the pipeline and releases all staging buffers.
+	*/
+	destroy() {
+		this.inFlightFrames.length = 0;
+		this.cycleStartTimes.clear();
+		this.stagingRing.destroy();
+	}
+	async consumeAndEncode(frameIndex) {
+		const encodeStart = performance.now();
+		const timestampUs = frameIndex / this.fps * 1e6;
+		if (this.canDirectZeroCopy()) {
+			const sample = new VideoSample(this.directCanvasSource, {
+				duration: 1 / this.fps,
+				timestamp: frameIndex / this.fps
+			});
+			try {
+				await this.videoSource.add(sample);
+			} finally {
+				sample.close();
+			}
+		} else {
+			const onFrame = this.onFrame;
+			const vf = await this.stagingRing.readFrameToVideoFrame(frameIndex, timestampUs, this.colorSpace, onFrame && ((rgba) => onFrame(rgba, frameIndex)));
+			try {
+				const sample = new VideoSample(vf, {
+					duration: 1 / this.fps,
+					timestamp: frameIndex / this.fps
+				});
+				try {
+					await this.videoSource.add(sample);
+				} finally {
+					sample.close();
+				}
+			} finally {
+				vf.close();
+			}
+		}
+		const now = performance.now();
+		this.totalEncodeTimeMs += now - encodeStart;
+		this.totalFramesEncoded++;
+		const cycleStart = this.cycleStartTimes.get(frameIndex);
+		if (cycleStart !== void 0) {
+			const cycleDuration = now - cycleStart;
+			this.cycleStartTimes.delete(frameIndex);
+			this.totalCycleTimeMs += cycleDuration;
+			if (cycleDuration > this.maxCycleTimeMs) this.maxCycleTimeMs = cycleDuration;
+			if (cycleDuration < this.minCycleTimeMs) this.minCycleTimeMs = cycleDuration;
+		}
+	}
+};
+async function convertMp4ToGif(inputMp4Path, outputGifPath) {
+	return new Promise((resolve$1, reject) => {
+		const ffmpeg = spawn("ffmpeg", [
+			"-i",
+			inputMp4Path,
+			"-vf",
+			"split[s0][s1];[s0]palettegen[p];[s1][p]paletteuse",
+			"-y",
+			outputGifPath
+		]);
+		let errorOutput = "";
+		ffmpeg.stderr.on("data", (data) => {
+			errorOutput += data.toString();
+		});
+		ffmpeg.on("close", async (code) => {
+			if (code === 0) resolve$1();
+			else {
+				rendererLogger.error({
+					code,
+					err: errorOutput
+				}, "[convertMp4ToGif] ffmpeg conversion failed");
+				reject(/* @__PURE__ */ new Error(`ffmpeg exited with code ${code}: ${errorOutput}`));
+			}
+		});
+		ffmpeg.on("error", (err) => {
+			rendererLogger.error({ err }, "[convertMp4ToGif] ffmpeg spawn error");
+			reject(err);
+		});
+	});
+}
+bootstrapMediabunny();
+const globalObj = globalThis;
+if (typeof globalThis !== "undefined") {
+	globalObj.__IS_HEADLESS_RENDERER__ = true;
+	globalObj.__GATEWAI_DELAYS__ ??= /* @__PURE__ */ new Set();
+}
+if (typeof globalThis.requestAnimationFrame === "undefined") {
+	globalObj.requestAnimationFrame = (cb) => setTimeout(cb, 0);
+	globalObj.cancelAnimationFrame = (id) => clearTimeout(id);
+}
+const dummyDomElement = {
+	clientWidth: 1920,
+	clientHeight: 1080,
+	getBoundingClientRect: () => ({
+		x: 0,
+		y: 0,
+		left: 0,
+		top: 0,
+		right: 1920,
+		bottom: 1080,
+		width: 1920,
+		height: 1080
+	}),
+	style: {},
+	appendChild: () => {},
+	removeChild: () => {},
+	addEventListener: () => {},
+	removeEventListener: () => {},
+	getAttribute: () => null
+};
+if (typeof globalThis.OffscreenCanvas === "undefined") globalObj.OffscreenCanvas = Canvas;
+if (typeof globalThis.HTMLCanvasElement === "undefined") globalObj.HTMLCanvasElement = Canvas;
+if (typeof globalThis.Image === "undefined") globalObj.Image = Image;
+if (typeof globalThis.window === "undefined") globalObj.window = globalThis;
+if (!globalThis.location) globalObj.location = new URL("http://localhost");
+if (typeof globalThis.IntersectionObserver === "undefined") globalObj.IntersectionObserver = class IntersectionObserver {
+	observe() {}
+	unobserve() {}
+	disconnect() {}
+};
+if (typeof globalThis.document === "undefined") globalObj.document = {
+	createElement: (tag) => {
+		if (tag === "canvas") return new Canvas(1, 1);
+		return { ...dummyDomElement };
+	},
+	getElementsByTagName: () => [],
+	documentElement: dummyDomElement,
+	body: dummyDomElement
+};
+else {
+	const docObj = globalThis.document;
+	if (typeof docObj.getElementsByTagName === "undefined") docObj.getElementsByTagName = () => [];
+	docObj.documentElement ??= dummyDomElement;
+	docObj.body ??= dummyDomElement;
+}
+const skiaProto = Canvas.prototype;
+if (typeof skiaProto.getBoundingClientRect === "undefined") skiaProto.getBoundingClientRect = function() {
+	const width = this.width || 512;
+	const height = this.height || 512;
+	return {
+		x: 0,
+		y: 0,
+		left: 0,
+		top: 0,
+		right: width,
+		bottom: height,
+		width,
+		height
+	};
+};
+if (!("style" in skiaProto)) Object.defineProperty(skiaProto, "style", {
+	get() {
+		this._style ??= {};
+		return this._style;
+	},
+	configurable: true
+});
+if (!("clientWidth" in skiaProto)) Object.defineProperty(skiaProto, "clientWidth", {
+	get() {
+		return this.width || 512;
+	},
+	configurable: true
+});
+if (!("clientHeight" in skiaProto)) Object.defineProperty(skiaProto, "clientHeight", {
+	get() {
+		return this.height || 512;
+	},
+	configurable: true
+});
+if (!("parentElement" in skiaProto)) Object.defineProperty(skiaProto, "parentElement", {
+	get() {
+		return dummyDomElement;
+	},
+	configurable: true
+});
+if (typeof skiaProto.addEventListener === "undefined") skiaProto.addEventListener = () => {};
+if (typeof skiaProto.removeEventListener === "undefined") skiaProto.removeEventListener = () => {};
+if (typeof skiaProto.getAttribute === "undefined") skiaProto.getAttribute = () => null;
+const CPU_COUNT = os.cpus().length;
+const TOTAL_WORKER_BUDGET = Math.max(1, CPU_COUNT - 3);
+const MAX_CONCURRENT_RENDERS = Math.max(1, Math.min(3, Math.floor(TOTAL_WORKER_BUDGET / 3)));
+const QUEUE_TIMEOUT_MS = 120 * 6e4;
+var RenderSemaphore = class {
+	_running = 0;
+	_max;
+	_queue = [];
+	constructor(max) {
+		this._max = max;
+	}
+	acquire(timeoutMs = QUEUE_TIMEOUT_MS) {
+		if (this._running < this._max) {
+			this._running++;
+			return Promise.resolve();
+		}
+		return new Promise((resolve$1, reject) => {
+			const timer = setTimeout(() => {
+				const idx = this._queue.findIndex((e) => e.resolve === resolve$1);
+				if (idx !== -1) this._queue.splice(idx, 1);
+				reject(/* @__PURE__ */ new Error(`Render queue timeout after ${timeoutMs}ms (${this._queue.length} queued, ${this._running}/${this._max} active)`));
+			}, timeoutMs);
+			this._queue.push({
+				resolve: resolve$1,
+				reject,
+				timer
+			});
+		});
+	}
+	release() {
+		if (this._queue.length > 0) {
+			const next = this._queue.shift();
+			clearTimeout(next.timer);
+			next.resolve();
+		} else this._running--;
+	}
+	get stats() {
+		return {
+			active: this._running,
+			queued: this._queue.length,
+			max: this._max
+		};
+	}
+};
+const renderSemaphore = new RenderSemaphore(MAX_CONCURRENT_RENDERS);
+function toEvenDimension(n) {
+	const v = Math.round(n);
+	return v % 2 === 0 ? v : v + 1;
+}
+function resolveQuality(quality) {
+	switch (quality) {
+		case "very_low": return QUALITY_VERY_LOW;
+		case "low": return QUALITY_LOW;
+		case "high": return QUALITY_HIGH;
+		case "very_high": return QUALITY_VERY_HIGH;
+		default: return QUALITY_VERY_HIGH;
+	}
+}
+let cachedVramUsage = "N/A";
+let vramProbeInFlight = false;
+function refreshVramUsage() {
+	if (vramProbeInFlight) return;
+	vramProbeInFlight = true;
+	exec("nvidia-smi --query-gpu=memory.used,memory.total --format=csv,noheader,nounits", {
+		encoding: "utf-8",
+		timeout: 2e3
+	}, (err, stdout) => {
+		vramProbeInFlight = false;
+		if (err || !stdout) return;
+		const [used, total] = stdout.trim().split(",").map((s) => s.trim());
+		if (used && total) cachedVramUsage = `${used}MB / ${total}MB`;
+	});
+}
+function getVramUsage() {
+	return cachedVramUsage;
+}
+const DEFAULT_RING_CAPACITY = 2;
+const MIN_RING_CAPACITY = 2;
+const MAX_RING_CAPACITY = 8;
+function resolveRingCapacity(explicit) {
+	const fromEnv = Number(process.env.FRAMEFIELDS_RING_CAPACITY);
+	const requested = explicit ?? (Number.isFinite(fromEnv) && fromEnv > 0 ? fromEnv : NaN);
+	if (!Number.isFinite(requested) || requested <= 0) return DEFAULT_RING_CAPACITY;
+	return Math.max(MIN_RING_CAPACITY, Math.min(MAX_RING_CAPACITY, Math.floor(requested)));
+}
+var NodeSurfacePool = class {
+	idle = [];
+	maxIdle = 2;
+	acquire(device, width, height) {
+		const index = this.idle.findIndex((entry) => entry.device === device && entry.surface.width === width && entry.surface.height === height);
+		if (index >= 0) {
+			const [entry] = this.idle.splice(index, 1);
+			if (entry) return entry.surface;
+		}
+		for (let i = this.idle.length - 1; i >= 0; i--) {
+			const entry = this.idle[i];
+			if (entry && entry.device !== device) {
+				this.idle.splice(i, 1);
+				try {
+					entry.surface.destroy();
+				} catch {}
+			}
+		}
+		return new NodeSurfaceProvider(device, width, height);
+	}
+	release(device, surface) {
+		if (this.idle.length >= this.maxIdle) {
+			try {
+				surface.destroy();
+			} catch {}
+			return;
+		}
+		this.idle.push({
+			device,
+			surface
+		});
+	}
+	destroy() {
+		for (const entry of this.idle.splice(0)) try {
+			entry.surface.destroy();
+		} catch {}
+	}
+};
+const nodeSurfacePool = new NodeSurfacePool();
+function formatLutAsCube(lut) {
+	const lines = [
+		"# Created by Gatewai",
+		lut.type === "3D" ? `LUT_3D_SIZE ${lut.size}` : `LUT_1D_SIZE ${lut.size}`,
+		""
+	];
+	for (const p of lut.points) lines.push(`${p[0].toFixed(6)} ${p[1].toFixed(6)} ${p[2].toFixed(6)}`);
+	return lines.join("\n");
+}
+var HeadlessWebGPURenderer = class HeadlessWebGPURenderer$1 {
+	static isInitialized = false;
+	static initPromise = null;
+	static initFailureCount = 0;
+	static MAX_INIT_FAILURES = 3;
+	static nextRetryAt = 0;
+	static initialize() {
+		if (HeadlessWebGPURenderer$1.isInitialized) return Promise.resolve();
+		if (HeadlessWebGPURenderer$1.initFailureCount >= HeadlessWebGPURenderer$1.MAX_INIT_FAILURES) return Promise.reject(/* @__PURE__ */ new Error("GPU initialization permanently failed — circuit breaker open"));
+		if (Date.now() < HeadlessWebGPURenderer$1.nextRetryAt) return Promise.reject(/* @__PURE__ */ new Error("GPU initialization in backoff period"));
+		if (HeadlessWebGPURenderer$1.initPromise) return HeadlessWebGPURenderer$1.initPromise;
+		HeadlessWebGPURenderer$1.initPromise = (async () => {
+			try {
+				rendererLogger.debug("[HeadlessWebGPURenderer] Initializing headless WebGPU…");
+				await initHeadlessWebGPU();
+				rendererLogger.debug("[HeadlessWebGPURenderer] Scanning node renderers…");
+				await discoverAndRegisterNodeRenderers();
+				HeadlessWebGPURenderer$1.isInitialized = true;
+				HeadlessWebGPURenderer$1.initPromise = null;
+				HeadlessWebGPURenderer$1.initFailureCount = 0;
+				HeadlessWebGPURenderer$1.nextRetryAt = 0;
+				rendererLogger.debug("[HeadlessWebGPURenderer] Initialization complete.");
+			} catch (error) {
+				HeadlessWebGPURenderer$1.initFailureCount++;
+				HeadlessWebGPURenderer$1.nextRetryAt = Date.now() + 5e3 * 2 ** HeadlessWebGPURenderer$1.initFailureCount;
+				HeadlessWebGPURenderer$1.initPromise = null;
+				rendererLogger.error({
+					err: error instanceof Error ? error.message : String(error),
+					failureCount: HeadlessWebGPURenderer$1.initFailureCount,
+					nextRetryAt: new Date(HeadlessWebGPURenderer$1.nextRetryAt).toISOString()
+				}, "[HeadlessWebGPURenderer] Initialization failed");
+				throw error;
+			}
+		})();
+		return HeadlessWebGPURenderer$1.initPromise;
+	}
+	async renderImage(virtualMedia, frame = 0, fps = 24, options = {}) {
+		await HeadlessWebGPURenderer$1.initialize();
+		const width = toEvenDimension(virtualMedia.metadata.width ?? 0);
+		const height = toEvenDimension(virtualMedia.metadata.height ?? 0);
+		if (!width || !height) throw new Error(`Invalid dimensions: ${width}x${height}`);
+		const renderId = options.renderId ?? `img-${randomUUID()}`;
+		rendererLogger.debug({
+			renderId,
+			frame,
+			...renderSemaphore.stats
+		}, "[HeadlessWebGPURenderer] Acquiring slot for image render");
+		await renderSemaphore.acquire();
+		let surface;
+		let renderer;
+		const device = await ensureDevice();
+		try {
+			await preloadFonts(virtualMedia, device);
+			surface = nodeSurfacePool.acquire(device, width, height);
+			renderer = getRenderer2D(device, surface.colorFormat);
+			const ctx = {
+				device,
+				renderer,
+				surface
+			};
+			updateClockSignals(frame, fps, virtualMedia.metadata.durationMs ?? void 0);
+			if (frame === 0 || lutStore.hasPending(device) || SlugFontCache.hasPending()) {
+				const preEncoder = device.createCommandEncoder();
+				const dummyTex = renderer.getTemporaryTexture(width, height);
+				const dummyView = dummyTex.createView();
+				renderer.beginFrame(preEncoder, dummyView, {
+					r: 0,
+					g: 0,
+					b: 0,
+					a: 0
+				}, width, height, "clear").end();
+				await drawCompositionTree(ctx, preEncoder, dummyView, dummyTex, width, height, virtualMedia, {
+					frame,
+					compositionFrame: frame,
+					fps,
+					isHeadless: true,
+					renderId,
+					virtualMedia,
+					containerWidth: width,
+					containerHeight: height,
+					isVideoMode: virtualMedia.operation?.dataType === "Video"
+				});
+				device.queue.submit([preEncoder.finish()]);
+				await lutStore.awaitAllPending(device);
+			}
+			compositionStateStore.setState(renderId, frame, fps, true);
+			const encoder = device.createCommandEncoder();
+			const targetView = surface.getCurrentTextureView();
+			const targetTexture = surface.getCurrentTexture();
+			renderer.beginFrame(encoder, targetView, {
+				r: 0,
+				g: 0,
+				b: 0,
+				a: 0
+			}, width, height, "clear").end();
+			await drawCompositionTree(ctx, encoder, targetView, targetTexture, width, height, virtualMedia, {
+				frame,
+				compositionFrame: frame,
+				fps,
+				isHeadless: true,
+				renderId,
+				virtualMedia,
+				containerWidth: width,
+				containerHeight: height,
+				isVideoMode: virtualMedia.operation?.dataType === "Video"
+			});
+			device.queue.submit([encoder.finish()]);
+			const pixels = await surface.readPixels();
+			const pixelsArr = new Uint8Array(pixels.buffer, pixels.byteOffset, pixels.byteLength);
+			if (options.format === "rgba") return Buffer.from(pixelsArr);
+			return await sharp(Buffer.from(pixelsArr), { raw: {
+				width,
+				height,
+				channels: 4
+			} }).png().toBuffer();
+		} finally {
+			try {
+				clearAllVideoCache();
+			} catch {}
+			try {
+				shaderStore.clear(renderId);
+			} catch {}
+			if (surface) nodeSurfacePool.release(device, surface);
+			try {
+				textureCache.destroy();
+			} catch {}
+			renderSemaphore.release();
+			rendererLogger.debug({
+				renderId,
+				...renderSemaphore.stats
+			}, "[HeadlessWebGPURenderer] Image render slot released");
+		}
+	}
+	/**
+	* Renders a single frame to a PNG buffer at a specified timestamp in milliseconds or frame index.
+	*/
+	async renderFrame(source, options = {}) {
+		const vm = typeof source === "object" && source !== null && "toVirtualMedia" in source ? source.toVirtualMedia() : source;
+		const fps = options.fps ?? (vm.metadata?.fps || 30);
+		const frame = options.atMs !== void 0 ? Math.round(options.atMs / 1e3 * fps) : options.frame ?? 0;
+		return this.renderImage(vm, frame, fps, {
+			renderId: options.renderId,
+			format: options.format
+		});
+	}
+	/**
+	* Mixes the composition's full audio timeline (clips, effects, synthesized
+	* tracks) to stereo PCM, exactly as `renderVideo` muxes it.
+	*/
+	async renderAudio(virtualMedia, options = {}) {
+		await HeadlessWebGPURenderer$1.initialize();
+		const fps = options.fps ?? (virtualMedia.metadata?.fps || 30);
+		await renderSemaphore.acquire();
+		try {
+			const device = await ensureDevice();
+			return await mixAudioTracks(virtualMedia, fps, options.sampleRate ?? 48e3, device, `aud-${randomUUID()}`);
+		} finally {
+			renderSemaphore.release();
+		}
+	}
+	async renderLut(virtualMedia, frame = 0, fps = 24) {
+		await HeadlessWebGPURenderer$1.initialize();
+		const width = 32;
+		const height = 32;
+		const renderId = `lut-${randomUUID()}`;
+		rendererLogger.debug({
+			renderId,
+			frame,
+			...renderSemaphore.stats
+		}, "[HeadlessWebGPURenderer] Acquiring slot for LUT render");
+		await renderSemaphore.acquire();
+		let surface;
+		let renderer;
+		const device = await ensureDevice();
+		let lutData = null;
+		const lutSub = lutStore.onChange((key) => {
+			const raw = lutStore.getRawData(key);
+			if (raw) lutData = raw;
+		});
+		try {
+			await preloadFonts(virtualMedia, device);
+			surface = new NodeSurfaceProvider(device, width, height);
+			renderer = getRenderer2D(device, surface.colorFormat);
+			const ctx = {
+				device,
+				renderer,
+				surface
+			};
+			if (frame === 0 || lutStore.hasPending(device) || SlugFontCache.hasPending()) {
+				const preEncoder = device.createCommandEncoder();
+				const dummyTex = renderer.getTemporaryTexture(width, height);
+				const dummyView = dummyTex.createView();
+				renderer.beginFrame(preEncoder, dummyView, {
+					r: 0,
+					g: 0,
+					b: 0,
+					a: 0
+				}, width, height, "clear").end();
+				await drawCompositionTree(ctx, preEncoder, dummyView, dummyTex, width, height, virtualMedia, {
+					frame,
+					compositionFrame: frame,
+					fps,
+					isHeadless: true,
+					renderId,
+					virtualMedia,
+					containerWidth: width,
+					containerHeight: height,
+					isVideoMode: virtualMedia.operation?.dataType === "Video"
+				});
+				device.queue.submit([preEncoder.finish()]);
+				await lutStore.awaitAllPending(device);
+			}
+			compositionStateStore.setState(renderId, frame, fps, true);
+			const encoder = device.createCommandEncoder();
+			const targetView = surface.getCurrentTextureView();
+			const targetTexture = surface.getCurrentTexture();
+			renderer.beginFrame(encoder, targetView, {
+				r: 0,
+				g: 0,
+				b: 0,
+				a: 0
+			}, width, height, "clear").end();
+			await drawCompositionTree(ctx, encoder, targetView, targetTexture, width, height, virtualMedia, {
+				frame,
+				compositionFrame: frame,
+				fps,
+				isHeadless: true,
+				renderId,
+				virtualMedia,
+				containerWidth: width,
+				containerHeight: height,
+				isVideoMode: virtualMedia.operation?.dataType === "Video"
+			});
+			device.queue.submit([encoder.finish()]);
+			await lutStore.awaitAllPending(device);
+			if (!lutData) lutData = lutStore.getAnyRawData();
+			if (!lutData) throw new Error("No LUT data generated during rendering");
+			const cubeContent = formatLutAsCube(lutData);
+			return Buffer.from(cubeContent, "utf-8");
+		} finally {
+			try {
+				lutSub();
+			} catch {}
+			try {
+				mediaDecoderCache.destroy();
+				clearAllVideoCache();
+			} catch {}
+			try {
+				shaderStore.clear(renderId);
+			} catch {}
+			try {
+				surface?.destroy();
+			} catch {}
+			try {
+				textureCache.destroy();
+			} catch {}
+			renderSemaphore.release();
+			rendererLogger.debug({
+				renderId,
+				...renderSemaphore.stats
+			}, "[HeadlessWebGPURenderer] LUT render slot released");
+		}
+	}
+	async resolveMediaDuration(virtualMedia, fps) {
+		let maxDurationMs = 0;
+		const queue = [virtualMedia];
+		const sources = /* @__PURE__ */ new Set();
+		while (queue.length > 0) {
+			const current = queue.shift();
+			if (current.metadata?.durationMs && current.metadata.durationMs > maxDurationMs) maxDurationMs = current.metadata.durationMs;
+			const op = current.operation;
+			if (op) {
+				if (typeof op.source === "string") sources.add(op.source);
+				if (typeof op.url === "string") sources.add(op.url);
+				if (typeof op.inputHandleId === "string") sources.add(op.inputHandleId);
+				if (Array.isArray(op.layout)) for (const node of op.layout) {
+					if (node.inputHandleId) sources.add(node.inputHandleId);
+					if (node.src) sources.add(node.src);
+					if (typeof node.durationFrames === "number") {
+						const durMs = ((typeof node.startFrame === "number" ? node.startFrame : 0) + node.durationFrames) / fps * 1e3;
+						if (durMs > maxDurationMs) maxDurationMs = durMs;
+					}
+				}
+			}
+			if (current.children) queue.push(...current.children);
+		}
+		for (const src of sources) try {
+			const sec = await (await inputStore.acquire(src)).computeDuration();
+			if (Number.isFinite(sec) && sec > 0) {
+				const ms = Math.round(sec * 1e3);
+				if (ms > maxDurationMs) maxDurationMs = ms;
+			}
+		} catch (_) {}
+		return maxDurationMs > 0 ? maxDurationMs : 1e3;
+	}
+	async renderVideo(virtualMedia, options) {
+		await HeadlessWebGPURenderer$1.initialize();
+		const codecOption = options?.codec ?? "h264";
+		const isMp3 = codecOption === "mp3";
+		const isWebM = codecOption === "vp8" || codecOption === "vp9" || codecOption === "opus";
+		const mediaType = getMediaType(virtualMedia);
+		const isLut = mediaType === "LUT" || virtualMedia.operation?.dataType === "LUT";
+		const isAudioOnly = isMp3 || codecOption === "aac" || codecOption === "opus" || mediaType === "Audio";
+		const fps = virtualMedia.metadata.fps ?? (isAudioOnly || isLut ? 24 : void 0);
+		if (!fps) {
+			const dataType = mediaType ?? virtualMedia.dataType ?? "Unknown";
+			const op = virtualMedia.operation?.op ?? virtualMedia.op ?? "Unknown";
+			throw new Error(`FPS is missing from virtualMedia metadata (dataType: "${dataType}", operation: "${op}")`);
+		}
+		const width = toEvenDimension(virtualMedia.metadata.width ?? (isAudioOnly ? 1280 : 0));
+		const height = toEvenDimension(virtualMedia.metadata.height ?? (isAudioOnly ? 720 : 0));
+		if (!width || !height) throw new Error(`Invalid dimensions: ${width}x${height}`);
+		let durationMs = virtualMedia.metadata.durationMs;
+		if (!durationMs || durationMs <= 0) {
+			durationMs = await this.resolveMediaDuration(virtualMedia, fps);
+			virtualMedia.metadata.durationMs = durationMs;
+		}
+		const totalFrames = Math.max(1, Math.round(durationMs / 1e3 * fps));
+		const renderId = `vid-${randomUUID()}`;
+		const qaOptions = options?.qa === true ? {} : options?.qa ? options.qa : void 0;
+		const inspector = qaOptions ? new FrameInspector(qaOptions) : void 0;
+		let videoQa;
+		let audioQa;
+		const videoCodec = codecOption === "vp9" ? "vp9" : codecOption === "vp8" ? "vp8" : "avc";
+		const audioCodec = options?.audioCodec ?? (isMp3 ? "mp3" : isWebM ? "opus" : "aac");
+		const quality = resolveQuality(options?.quality);
+		rendererLogger.debug({
+			renderId,
+			totalFrames,
+			fps,
+			width,
+			height,
+			codec: codecOption,
+			...renderSemaphore.stats
+		}, "[HeadlessWebGPURenderer] Acquiring slot for video render (inline)");
+		await renderSemaphore.acquire();
+		let lastCpuUsage = process.cpuUsage();
+		let lastCpuTime = process.hrtime.bigint();
+		const getCpuUsage = () => {
+			const curCpuUsage = process.cpuUsage();
+			const curCpuTime = process.hrtime.bigint();
+			const userDiff = curCpuUsage.user - lastCpuUsage.user;
+			const sysDiff = curCpuUsage.system - lastCpuUsage.system;
+			const timeDiff = Number(curCpuTime - lastCpuTime) / 1e3;
+			lastCpuUsage = curCpuUsage;
+			lastCpuTime = curCpuTime;
+			if (timeDiff === 0) return "0.0%";
+			const cpus = os.cpus().length || 1;
+			return `${((userDiff + sysDiff) / timeDiff * 100 / cpus).toFixed(1)}%`;
+		};
+		const getRamUsage = () => {
+			const mem = process.memoryUsage();
+			const freeMem = os.freemem();
+			const totalMem = os.totalmem();
+			const usedMem = totalMem - freeMem;
+			const heapUsedMb = Math.round(mem.heapUsed / 1024 / 1024);
+			const heapTotalMb = Math.round(mem.heapTotal / 1024 / 1024);
+			return `Process: ${Math.round(mem.rss / 1024 / 1024)}MB RSS (${heapUsedMb}MB/${heapTotalMb}MB Heap), System: ${Math.round(usedMem / 1024 / 1024)}MB/${Math.round(totalMem / 1024 / 1024)}MB`;
+		};
+		let statsInterval;
+		if (process.env.NODE_ENV === "production") statsInterval = setInterval(() => {
+			refreshVramUsage();
+			rendererLogger.info({
+				renderId,
+				cpu: getCpuUsage(),
+				ram: getRamUsage(),
+				vram: getVramUsage(),
+				renderQueue: renderSemaphore.stats
+			}, "[HeadlessWebGPURenderer] Performance Stats");
+		}, 5e3);
+		const tempDir = os.tmpdir();
+		const extension = isMp3 ? "mp3" : isWebM ? "webm" : "mp4";
+		const tempFilePath = path.join(tempDir, `render-${renderId}.${extension}`);
+		const tempGifPath = path.join(tempDir, `render-${renderId}.gif`);
+		const target = new FilePathTarget(tempFilePath);
+		const output = new Output({
+			format: isMp3 ? new Mp3OutputFormat() : isWebM ? new WebMOutputFormat() : new Mp4OutputFormat(),
+			target
+		});
+		let videoSource;
+		if (!isAudioOnly) {
+			videoSource = new VideoSampleSource({
+				codec: videoCodec,
+				bitrate: quality,
+				latencyMode: "realtime",
+				hardwareAcceleration: isAMD() ? "prefer-software" : "prefer-hardware"
+			});
+			output.addVideoTrack(videoSource);
+		}
+		const audioSource = new AudioSampleSource({
+			codec: audioCodec,
+			bitrate: quality
+		});
+		output.addAudioTrack(audioSource);
+		let outputStarted = false;
+		let outputFinalized = false;
+		const device = await ensureDevice();
+		let surface;
+		let renderer;
+		let pipeline;
+		try {
+			await output.start();
+			outputStarted = true;
+			await preloadFonts(virtualMedia, device);
+			if (!isAudioOnly && videoSource) {
+				surface = new NodeSurfaceProvider(device, width, height);
+				renderer = getRenderer2D(device, surface.colorFormat);
+				pipeline = new ZeroCopyWebCodecsPipeline(device, {
+					width,
+					height,
+					fps,
+					videoSource,
+					ringCapacity: resolveRingCapacity(options?.ringCapacity),
+					onFrame: inspector ? (rgba) => inspector.inspect(rgba, width, height) : void 0
+				});
+				const ctx = surface && renderer ? {
+					device,
+					renderer,
+					surface
+				} : null;
+				const prePass = async (frame) => {
+					if (!ctx || !renderer) return;
+					const preEncoder = device.createCommandEncoder();
+					const dummyTex = renderer.getTemporaryTexture(width, height);
+					const dummyView = dummyTex.createView();
+					renderer.beginFrame(preEncoder, dummyView, {
+						r: 0,
+						g: 0,
+						b: 0,
+						a: 0
+					}, width, height, "clear").end();
+					await drawCompositionTree(ctx, preEncoder, dummyView, dummyTex, width, height, virtualMedia, {
+						frame,
+						compositionFrame: frame,
+						fps,
+						isHeadless: true,
+						renderId,
+						virtualMedia,
+						containerWidth: width,
+						containerHeight: height,
+						isVideoMode: virtualMedia.operation?.dataType === "Video"
+					});
+					device.queue.submit([preEncoder.finish()]);
+					await lutStore.awaitAllPending(device);
+				};
+				await prePass(0);
+				for (let i = 0; i < totalFrames; i++) {
+					if (i % 10 === 0) rendererLogger.info({
+						renderId,
+						frame: i,
+						totalFrames
+					}, `[HeadlessWebGPURenderer] Rendering frame ${i}/${totalFrames}`);
+					if (ctx && surface && renderer && pipeline) {
+						if (i > 0 && (lutStore.hasPending(device) || SlugFontCache.hasPending())) {
+							updateClockSignals(i, fps, durationMs);
+							await prePass(i);
+						}
+						compositionStateStore.setState(renderId, i, fps, true);
+						updateClockSignals(i, fps, durationMs);
+						const encoder = device.createCommandEncoder();
+						const targetView = surface.getCurrentTextureView();
+						const targetTexture = surface.getCurrentTexture();
+						renderer.beginFrame(encoder, targetView, {
+							r: 0,
+							g: 0,
+							b: 0,
+							a: 0
+						}, width, height, "clear").end();
+						await drawCompositionTree(ctx, encoder, targetView, targetTexture, width, height, virtualMedia, {
+							frame: i,
+							compositionFrame: i,
+							fps,
+							isHeadless: true,
+							renderId,
+							virtualMedia,
+							containerWidth: width,
+							containerHeight: height,
+							isVideoMode: virtualMedia.operation?.dataType === "Video"
+						});
+						await pipeline.enqueueFrame(i, targetTexture, encoder);
+					} else throw new Error("Invalid render context state");
+				}
+				if (pipeline) {
+					await pipeline.drain();
+					const pipelineStats = pipeline.getStats();
+					if (inspector && qaOptions) videoQa = inspector.stats(totalFrames, pipelineStats.totalFramesEncoded, fps, width, height, qaOptions);
+					rendererLogger.debug({
+						renderId,
+						totalFrames,
+						...pipelineStats
+					}, `[HeadlessWebGPURenderer] All frames rendered and encoded (avg cycle: ${pipelineStats.averageCycleTimeMs.toFixed(2)}ms, throughput: ${pipelineStats.throughputFps.toFixed(1)} fps)`);
+				}
+			}
+			const { channels, sampleRate } = await mixAudioTracks(virtualMedia, fps, 48e3, device, renderId);
+			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);
+			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 audioSource.add(sample);
+				} finally {
+					sample.close();
+				}
+			}
+			await output.finalize();
+			outputFinalized = true;
+			const qa = qaOptions ? buildQaReport({
+				video: videoQa,
+				audio: audioQa,
+				diagnostics: takeRenderDiagnostics(renderId),
+				options: qaOptions
+			}) : void 0;
+			const cleanup = async () => {
+				try {
+					await fs$1.unlink(tempFilePath).catch(() => {});
+					if (codecOption === "gif") await fs$1.unlink(tempGifPath).catch(() => {});
+				} catch {}
+			};
+			if (codecOption === "gif") {
+				rendererLogger.debug("[HeadlessWebGPURenderer] Converting rendered MP4 to high-quality GIF...");
+				await convertMp4ToGif(tempFilePath, tempGifPath);
+				return {
+					filePath: tempGifPath,
+					cleanup,
+					...qa && { qa }
+				};
+			}
+			return {
+				filePath: tempFilePath,
+				cleanup,
+				...qa && { qa }
+			};
+		} catch (error) {
+			if (outputStarted && !outputFinalized) try {
+				await output.finalize();
+			} catch {}
+			try {
+				await fs$1.unlink(tempFilePath).catch(() => {});
+				if (codecOption === "gif") await fs$1.unlink(tempGifPath).catch(() => {});
+			} catch {}
+			throw error;
+		} finally {
+			if (statsInterval) clearInterval(statsInterval);
+			try {
+				renderer?.destroy();
+			} catch {}
+			try {
+				pipeline?.destroy();
+			} catch {}
+			try {
+				surface?.destroy();
+			} catch {}
+			try {
+				mediaDecoderCache.destroy();
+			} catch {}
+			try {
+				clearAllVideoCache();
+			} catch {}
+			try {
+				textureCache.destroy();
+			} catch {}
+			try {
+				WebGPUAudioProcessor.clearCache(renderId);
+			} catch {}
+			try {
+				shaderStore.clear(renderId);
+			} catch {}
+			takeRenderDiagnostics(renderId);
+			renderSemaphore.release();
+			rendererLogger.debug({
+				renderId,
+				...renderSemaphore.stats
+			}, "[HeadlessWebGPURenderer] Video render slot released");
+		}
+	}
+};
+const HeadlessMediaRenderer = HeadlessWebGPURenderer;
+
+//#endregion
+//#region src/renderer/framegrid.ts
+/**
+* Resolves and validates the list of sample points from the provided options.
+*/
+function resolveSamplePoints(options, defaultFps = 24, durationMs) {
+	const fps = options.fps ?? defaultFps;
+	if (fps <= 0) throw new Error(`[FrameGrid] Invalid fps: ${fps}. Must be > 0.`);
+	const samples = [];
+	if (Array.isArray(options.frames) && options.frames.length > 0) for (const f of options.frames) {
+		if (typeof f !== "number" || f < 0 || !Number.isFinite(f)) throw new Error(`[FrameGrid] Invalid frame index in frames list: ${f}`);
+		samples.push({
+			frame: Math.round(f),
+			timeMs: Math.round(f / fps * 1e3)
+		});
+	}
+	else if (Array.isArray(options.timesMs) && options.timesMs.length > 0) for (const ms of options.timesMs) {
+		if (typeof ms !== "number" || ms < 0 || !Number.isFinite(ms)) throw new Error(`[FrameGrid] Invalid timestamp in timesMs list: ${ms}`);
+		samples.push({
+			frame: Math.round(ms / 1e3 * fps),
+			timeMs: Math.round(ms)
+		});
+	}
+	else if (options.startMs !== void 0 || options.endMs !== void 0 || options.stepMs !== void 0) {
+		const startMs = options.startMs ?? 0;
+		const endMs = options.endMs ?? durationMs ?? startMs + 1e3;
+		const stepMs = options.stepMs ?? Math.round(5 / fps * 1e3);
+		if (startMs < 0 || endMs < startMs) throw new Error(`[FrameGrid] Invalid millisecond range: startMs=${startMs}, endMs=${endMs}. startMs must be <= endMs.`);
+		if (stepMs <= 0) throw new Error(`[FrameGrid] Invalid stepMs: ${stepMs}. Must be > 0.`);
+		for (let ms = startMs; ms <= endMs; ms += stepMs) samples.push({
+			frame: Math.round(ms / 1e3 * fps),
+			timeMs: Math.round(ms)
+		});
+	} else {
+		const startFrame = options.startFrame ?? 0;
+		const endFrame = options.endFrame ?? (durationMs ? Math.min(startFrame + 30, Math.floor(durationMs / 1e3 * fps)) : startFrame + 30);
+		const stepFrames = options.stepFrames ?? 5;
+		if (startFrame < 0 || endFrame < startFrame) throw new Error(`[FrameGrid] Invalid frame range: startFrame=${startFrame}, endFrame=${endFrame}. startFrame must be <= endFrame.`);
+		if (stepFrames <= 0) throw new Error(`[FrameGrid] Invalid stepFrames: ${stepFrames}. Must be > 0.`);
+		for (let f = startFrame; f <= endFrame; f += stepFrames) samples.push({
+			frame: Math.round(f),
+			timeMs: Math.round(f / fps * 1e3)
+		});
+	}
+	const maxFramesLimit = Math.min(options.maxFrames ?? 64, 120);
+	if (samples.length > maxFramesLimit) throw new Error(`[FrameGrid] Requested ${samples.length} frames exceeds the safety threshold of ${maxFramesLimit}. Increase stepFrames/stepMs or narrow the start/end range to prevent oversized images.`);
+	if (samples.length === 0) throw new Error("[FrameGrid] Zero frames were resolved for sampling.");
+	return {
+		samples,
+		fps
+	};
+}
+/**
+* Computes grid layout dimensions, ensuring resulting canvas does not exceed size limits.
+*/
+function computeGridLayout(numSamples, aspectRatio, options) {
+	const gap = options.gap ?? 12;
+	const padding = options.padding ?? 16;
+	const headerHeight = options.showHeader ?? true ? 54 : 0;
+	const maxGridWidth = options.maxGridWidth ?? 4096;
+	const maxGridHeight = options.maxGridHeight ?? 4096;
+	let columns = options.columns;
+	if (!columns || columns <= 0) if (numSamples <= 4) columns = numSamples;
+	else if (numSamples <= 9) columns = 3;
+	else if (numSamples <= 16) columns = 4;
+	else if (numSamples <= 25) columns = 5;
+	else columns = 6;
+	columns = Math.min(columns, numSamples);
+	const rows = Math.ceil(numSamples / columns);
+	let cellWidth = Math.max(120, Math.min(options.cellWidth ?? 320, 960));
+	let cellHeight = options.cellHeight ?? Math.round(cellWidth / (aspectRatio > 0 ? aspectRatio : 16 / 9));
+	let totalWidth = columns * cellWidth + (columns - 1) * gap + padding * 2;
+	let totalHeight = rows * cellHeight + (rows - 1) * gap + padding * 2 + headerHeight;
+	if (totalWidth > maxGridWidth || totalHeight > maxGridHeight) {
+		const scaleFactor = Math.min((maxGridWidth - (columns - 1) * gap - padding * 2) / (columns * cellWidth), (maxGridHeight - (rows - 1) * gap - padding * 2 - headerHeight) / (rows * cellHeight));
+		if (scaleFactor < .25) throw new Error(`[FrameGrid] Cannot fit ${numSamples} cells (${columns}x${rows}) into max dimensions [${maxGridWidth}x${maxGridHeight}]. Reduce cell count or decrease cellWidth.`);
+		cellWidth = Math.max(100, Math.floor(cellWidth * scaleFactor));
+		cellHeight = Math.round(cellWidth / (aspectRatio > 0 ? aspectRatio : 16 / 9));
+		totalWidth = columns * cellWidth + (columns - 1) * gap + padding * 2;
+		totalHeight = rows * cellHeight + (rows - 1) * gap + padding * 2 + headerHeight;
+	}
+	return {
+		columns,
+		rows,
+		cellWidth,
+		cellHeight,
+		totalWidth,
+		totalHeight,
+		headerHeight,
+		gap,
+		padding
+	};
+}
+/**
+* Renders a sequence of frames from a Composition or Media pipeline into a unified image grid (contact sheet).
+* Ideal for visual inspection of kinetic motion, transitions, easing, and layout stability.
+*/
+async function renderFrameGrid(target, options = {}) {
+	const defaultFps = target.fps ?? 24;
+	const durationMs = target.durationMs;
+	const { samples, fps } = resolveSamplePoints(options, defaultFps, durationMs);
+	const compWidth = target.width ?? 1920;
+	const compHeight = target.height ?? 1080;
+	const aspectRatio = compWidth > 0 && compHeight > 0 ? compWidth / compHeight : 16 / 9;
+	const layout = computeGridLayout(samples.length, aspectRatio, options);
+	const renderer = options.renderer ?? new HeadlessMediaRenderer();
+	const frameBuffers = [];
+	for (const sample of samples) {
+		const buf = await target.renderFrame({
+			frame: sample.frame,
+			atMs: sample.timeMs,
+			fps,
+			renderer
+		});
+		frameBuffers.push(buf);
+	}
+	const canvas = new Canvas(layout.totalWidth, layout.totalHeight);
+	const ctx = canvas.getContext("2d");
+	ctx.fillStyle = options.backgroundColor ?? "#090a0f";
+	ctx.fillRect(0, 0, layout.totalWidth, layout.totalHeight);
+	if (options.showHeader !== false && layout.headerHeight > 0) {
+		const title = options.headerText ?? `FrameGrid Conformance Review | Frames ${samples[0].frame}–${samples[samples.length - 1].frame} (Count: ${samples.length})`;
+		const subtitle = `${compWidth}×${compHeight} @ ${fps} FPS | Cell: ${layout.cellWidth}×${layout.cellHeight}px | Step: ${options.stepFrames ? `${options.stepFrames}f` : options.stepMs ? `${options.stepMs}ms` : "Custom"}`;
+		ctx.fillStyle = "#f8fafc";
+		ctx.font = "bold 15px sans-serif";
+		ctx.fillText(title, layout.padding, layout.padding + 18);
+		ctx.fillStyle = "#94a3b8";
+		ctx.font = "12px sans-serif";
+		ctx.fillText(subtitle, layout.padding, layout.padding + 36);
+		ctx.strokeStyle = "#1e2433";
+		ctx.lineWidth = 1;
+		ctx.beginPath();
+		ctx.moveTo(layout.padding, layout.padding + 46);
+		ctx.lineTo(layout.totalWidth - layout.padding, layout.padding + 46);
+		ctx.stroke();
+	}
+	const showLabels = options.showLabels ?? true;
+	for (let i = 0; i < samples.length; i++) {
+		const sample = samples[i];
+		const col = i % layout.columns;
+		const row = Math.floor(i / layout.columns);
+		const x = layout.padding + col * (layout.cellWidth + layout.gap);
+		const y = layout.padding + layout.headerHeight + row * (layout.cellHeight + layout.gap);
+		const img = await loadImage(frameBuffers[i]);
+		ctx.drawImage(img, x, y, layout.cellWidth, layout.cellHeight);
+		ctx.strokeStyle = "#262b3d";
+		ctx.lineWidth = 1;
+		ctx.strokeRect(x, y, layout.cellWidth, layout.cellHeight);
+		if (showLabels) {
+			const label = `F:${sample.frame} • ${sample.timeMs}ms`;
+			ctx.font = "bold 11px sans-serif";
+			const badgeW = ctx.measureText(label).width + 14;
+			const badgeH = 20;
+			const badgeX = x + 6;
+			const badgeY = y + 6;
+			ctx.fillStyle = "#090a0fee";
+			ctx.beginPath();
+			ctx.roundRect(badgeX, badgeY, badgeW, badgeH, 4);
+			ctx.fill();
+			ctx.strokeStyle = "#6366f155";
+			ctx.lineWidth = 1;
+			ctx.stroke();
+			ctx.fillStyle = "#e2e8f0";
+			ctx.fillText(label, badgeX + 7, badgeY + 14);
+		}
+	}
+	const gridBuffer = await canvas.toBuffer("png");
+	if (options.outputPath) await fs$1.writeFile(options.outputPath, gridBuffer);
+	return gridBuffer;
+}
+
+//#endregion
+export { HeadlessWebGPURenderer as a, HeadlessMediaRenderer as i, renderFrameGrid as n, formatQaReport as o, resolveSamplePoints as r, renderSemaphore as s, computeGridLayout as t };
+//# sourceMappingURL=renderer-DX2qEJTL.mjs.map