framefields 2.4.0 → 2.4.2

package/dist/{renderer-TyZu7nQ2.mjs → renderer-CoWfz-9p.mjs}

@@ -1,7 +1,7 @@
-import { Ot as getMediaType, in as takeRenderDiagnostics, on as updateClockSignals } from "./dist-fjKpBYkc.mjs";
+import { Ot as getMediaType, an as takeRenderDiagnostics, sn as updateClockSignals } from "./dist-ClyC_d66.mjs";
 import { i as registerWebGPURenderer, t as audioRegistry } from "./renderer-BSitV56h.mjs";
-import { A as ensureDevice, F as getRenderer2D, H as lutStore, I as initHeadlessWebGPU, L as inputStore, W as mediaDecoderCache, et as shaderStore, g as WebGPUAudioProcessor, p as SlugFontCache, rt as textureCache, s as NodeSurfaceProvider, v as clearAllVideoCache, y as clearHeadlessFonts } from "./dist-DRB6Vg5u.mjs";
-import { i as mixAudioTracks, m as preloadCompositionFonts, r as drawCompositionTree, t as compositionStateStore } from "./dist-Cl0mvShy.mjs";
+import { A as ensureDevice, F as getRenderer2D, H as lutStore, I as initHeadlessWebGPU, L as inputStore, W as mediaDecoderCache, et as shaderStore, g as WebGPUAudioProcessor, p as SlugFontCache, rt as textureCache, s as NodeSurfaceProvider, v as clearAllVideoCache, y as clearHeadlessFonts } from "./dist-CspOG4V1.mjs";
+import { i as mixAudioTracks, m as preloadCompositionFonts, r as drawCompositionTree, t as compositionStateStore } from "./dist-CxGfrigI.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 fs from "node:fs";
@@ -14,16 +14,51 @@ 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";
+import { registerMediabunnyServer } from "@mediabunny/server";
 
-//#region ../renderer/dist/bootstrap-mediabunny-BgWuVtxx.mjs
-const rendererLogger = pino({
-	level: typeof process !== "undefined" && process.env?.LOG_LEVEL || "info",
+//#region ../renderer/dist/headless-webgpu-renderer-BIYZ_h9V.mjs
+const env = typeof process !== "undefined" ? process.env : void 0;
+/**
+* "json" (pino lines, for log collectors) or "text" (one short line each, for
+* people and agents reading a terminal). `FRAMEFIELDS_LOG_FORMAT` picks one;
+* otherwise production is JSON and everything else text.
+*/
+function resolveLogFormat(vars = env) {
+	const format = vars?.FRAMEFIELDS_LOG_FORMAT?.toLowerCase();
+	if (format === "json" || format === "text") return format;
+	return vars?.NODE_ENV === "production" ? "json" : "text";
+}
+const LEVEL_TAGS = {
+	40: "warn: ",
+	50: "error: ",
+	60: "fatal: "
+};
+/**
+* Turns pino's JSON lines into `[framefields] Rendered 40% (…)`: the message
+* without its `[Component]` prefix, the level only for warnings and errors,
+* and an error's message (its stack reaches the caller with the throw).
+*/
+function textLogStream(write = (line) => process.stderr.write(line)) {
+	return { write(json) {
+		let entry;
+		try {
+			entry = JSON.parse(json);
+		} catch {
+			write(json);
+			return;
+		}
+		const msg = String(entry.msg ?? "").replace(/^\[[^\]]+\]\s*/, "");
+		write(`[framefields] ${LEVEL_TAGS[entry.level ?? 0] ?? ""}${msg}${entry.err?.message ? `: ${entry.err.message}` : ""}\n`);
+	} };
+}
+const options = {
+	level: env?.LOG_LEVEL || "info",
 	timestamp: pino.stdTimeFunctions.isoTime,
 	base: { component: "renderer" }
-});
+};
+const rendererLogger = resolveLogFormat() === "text" ? pino(options, textLogStream()) : pino(options);
 /**
 * Preloads only the fonts (and emoji) a VirtualMediaData tree's text uses, so
 * typography renders correctly on Node.js without loading its media. Shared
@@ -53,12 +88,12 @@ var DmaStagingRing = class {
 	device;
 	slots;
 	isDestroyed = false;
-	constructor(device, options) {
+	constructor(device, options$1) {
 		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.width = options$1.width;
+		this.height = options$1.height;
+		this.capacity = Math.max(2, options$1.capacity ?? 2);
+		this.format = options$1.format ?? "rgba8unorm";
 		this.unpaddedBytesPerRow = this.width * 4;
 		const rowAlignment = 256;
 		this.bytesPerRow = Math.ceil(this.unpaddedBytesPerRow / rowAlignment) * rowAlignment;
@@ -242,237 +277,237 @@ const BUILTIN_NODE_RENDERERS = [
 	{
 		packageName: "@framefields/node-lut",
 		ops: ["ApplyLUT"],
-		load: () => import("./renderer-BHpJ1e15.mjs")
+		load: () => import("./renderer-Cd87JOjP.mjs")
 	},
 	{
 		packageName: "@framefields/node-ascii",
 		ops: ["Ascii"],
-		load: () => import("./renderer-CduDa1qf.mjs")
+		load: () => import("./renderer-B0gPTXhe.mjs")
 	},
 	{
 		packageName: "@framefields/node-audio-compressor",
 		ops: ["AudioCompressor"],
-		load: () => import("./renderer-fdVdNIhL.mjs")
+		load: () => import("./renderer-D2_0g6Oi.mjs")
 	},
 	{
 		packageName: "@framefields/node-audio-delay",
 		ops: ["AudioDelay"],
-		load: () => import("./renderer-Bn-WnRh9.mjs")
+		load: () => import("./renderer-D62FwolD.mjs")
 	},
 	{
 		packageName: "@framefields/node-audio-fade",
 		ops: ["AudioFade"],
-		load: () => import("./renderer-D9bp2jor.mjs")
+		load: () => import("./renderer-DqcUNP8J.mjs")
 	},
 	{
 		packageName: "@framefields/node-audio-noise-gate",
 		ops: ["AudioNoiseGate"],
-		load: () => import("./renderer-Dd1G_VKM.mjs")
+		load: () => import("./renderer-C_B_4Bl0.mjs")
 	},
 	{
 		packageName: "@framefields/node-audio-parametric-eq",
 		ops: ["AudioParametricEq"],
-		load: () => import("./renderer-CuoxvPsX.mjs")
+		load: () => import("./renderer-DDNY9N7I.mjs")
 	},
 	{
 		packageName: "@framefields/node-audio-reverb",
 		ops: ["AudioReverb"],
-		load: () => import("./renderer-yAWv-daq.mjs")
+		load: () => import("./renderer-C7NkSvUz.mjs")
 	},
 	{
 		packageName: "@framefields/node-audio-signal-extractor",
 		ops: ["AudioSignalExtractor"],
-		load: () => import("./renderer-jkL9FU2W.mjs")
+		load: () => import("./renderer-Cev6orIK.mjs")
 	},
 	{
 		packageName: "@framefields/node-blur",
 		ops: ["Blur"],
-		load: () => import("./renderer-BHZie6Pa.mjs")
+		load: () => import("./renderer-BuY5ypB2.mjs")
 	},
 	{
 		packageName: "@framefields/node-camera-parallax-3d",
 		ops: ["CameraParallax3D"],
-		load: () => import("./renderer-BZWiY6Jw.mjs")
+		load: () => import("./renderer-Dwu_zfdL.mjs")
 	},
 	{
 		packageName: "@framefields/node-canvas-generator",
 		ops: ["CanvasGenerator"],
-		load: () => import("./renderer-wFyrVuuj.mjs")
+		load: () => import("./renderer-CDOobs18.mjs")
 	},
 	{
 		packageName: "@framefields/node-channel-merger",
 		ops: ["ChannelMerger"],
-		load: () => import("./renderer-BhZutM8K.mjs")
+		load: () => import("./renderer-Cv4lchUP.mjs")
 	},
 	{
 		packageName: "@framefields/node-channel-splitter",
 		ops: ["ChannelSplitter"],
-		load: () => import("./renderer-Cfto0m0-.mjs")
+		load: () => import("./renderer-Bkrk0M0r.mjs")
 	},
 	{
 		packageName: "@framefields/node-color-balance",
 		ops: ["ColorBalance"],
-		load: () => import("./renderer-DY8fPeH3.mjs")
+		load: () => import("./renderer-CJ4bxCld.mjs")
 	},
 	{
 		packageName: "@framefields/node-colorkey",
 		ops: ["ColorKey"],
-		load: () => import("./renderer-B3EEYpx6.mjs")
+		load: () => import("./renderer-BHAE_dKq.mjs")
 	},
 	{
 		packageName: "@framefields/node-compositor",
 		ops: ["Compositor"],
-		load: () => import("./renderer-B8v8iEkB.mjs")
+		load: () => import("./renderer-BV48PFjX.mjs")
 	},
 	{
 		packageName: "@framefields/node-contour",
 		ops: ["Contour"],
-		load: () => import("./renderer-CNS8LA2_.mjs")
+		load: () => import("./renderer-gRMkQabv.mjs")
 	},
 	{
 		packageName: "@framefields/node-corner-pin",
 		ops: ["CornerPin"],
-		load: () => import("./renderer-DUmTURPu.mjs")
+		load: () => import("./renderer-BAhZeUUn.mjs")
 	},
 	{
 		packageName: "@framefields/node-crop",
 		ops: ["Crop"],
-		load: () => import("./renderer--IHe-yqK.mjs")
+		load: () => import("./renderer-CrdG7trA.mjs")
 	},
 	{
 		packageName: "@framefields/node-crt",
 		ops: ["CRT"],
-		load: () => import("./renderer-DkYiOWPJ.mjs")
+		load: () => import("./renderer-DyyIXLQK.mjs")
 	},
 	{
 		packageName: "@framefields/node-curves",
 		ops: ["Curves"],
-		load: () => import("./renderer-DuD9QRix.mjs")
+		load: () => import("./renderer-GvSRoQje.mjs")
 	},
 	{
 		packageName: "@framefields/node-datamosh",
 		ops: ["Datamosh"],
-		load: () => import("./renderer-BtJ6XYN7.mjs")
+		load: () => import("./renderer-BPixWnmY.mjs")
 	},
 	{
 		packageName: "@framefields/node-deflicker",
 		ops: ["TemporalDeflicker", "Deflicker"],
-		load: () => import("./renderer-C_5nfVce.mjs")
+		load: () => import("./renderer-BfZquJrW.mjs")
 	},
 	{
 		packageName: "@framefields/node-displacement-map",
 		ops: ["DisplacementMap"],
-		load: () => import("./renderer-DXCAgI9m.mjs")
+		load: () => import("./renderer-CY89dTFR.mjs")
 	},
 	{
 		packageName: "@framefields/node-dither",
 		ops: ["Dither"],
-		load: () => import("./renderer-DOZJeWM4.mjs")
+		load: () => import("./renderer-EZp_IIPK.mjs")
 	},
 	{
 		packageName: "@framefields/node-extract-frame",
 		ops: ["ExtractFrame"],
-		load: () => import("./renderer-DA1brg35.mjs")
+		load: () => import("./renderer-ByCX4JYg.mjs")
 	},
 	{
 		packageName: "@framefields/node-extract-lut",
 		ops: ["ExtractLUT"],
-		load: () => import("./renderer-CduL1AOK.mjs")
+		load: () => import("./renderer-DKfwlE4e.mjs")
 	},
 	{
 		packageName: "@framefields/node-film-grain",
 		ops: ["FilmGrain"],
-		load: () => import("./renderer-gBKWL0_E.mjs")
+		load: () => import("./renderer-CKp97tSQ.mjs")
 	},
 	{
 		packageName: "@framefields/node-flip",
 		ops: ["Flip"],
-		load: () => import("./renderer-CxAgpBrJ.mjs")
+		load: () => import("./renderer-BePHurAU.mjs")
 	},
 	{
 		packageName: "@framefields/node-gooey",
 		ops: ["Gooey"],
-		load: () => import("./renderer-BzgnTEvf.mjs")
+		load: () => import("./renderer-X0eKSD7v.mjs")
 	},
 	{
 		packageName: "@framefields/node-gradient-map",
 		ops: ["GradientMap"],
-		load: () => import("./renderer-CG4TmDWH.mjs")
+		load: () => import("./renderer-CCGzT6bX.mjs")
 	},
 	{
 		packageName: "@framefields/node-halftone-screen",
 		ops: ["HalftoneScreen"],
-		load: () => import("./renderer-B3Si5IB4.mjs")
+		load: () => import("./renderer-Cewf6UPh.mjs")
 	},
 	{
 		packageName: "@framefields/node-high-pass",
 		ops: ["HighPass"],
-		load: () => import("./renderer-Dee8079X.mjs")
+		load: () => import("./renderer-B_xSsTuy.mjs")
 	},
 	{
 		packageName: "@framefields/node-iridescence",
 		ops: ["Iridescence"],
-		load: () => import("./renderer-DVaVVz-D.mjs")
+		load: () => import("./renderer-B3e4LSE6.mjs")
 	},
 	{
 		packageName: "@framefields/node-kaleidoscope",
 		ops: ["Kaleidoscope"],
-		load: () => import("./renderer-q971j1BW.mjs")
+		load: () => import("./renderer-apeDrNXM.mjs")
 	},
 	{
 		packageName: "@framefields/node-kenburns",
 		ops: ["KenBurns"],
-		load: () => import("./renderer-BqHvDAUe.mjs")
+		load: () => import("./renderer-DbzrVHEE.mjs")
 	},
 	{
 		packageName: "@framefields/node-layer-style",
 		ops: ["LayerStyle"],
-		load: () => import("./renderer-DEzIOIB7.mjs")
+		load: () => import("./renderer-DqvFhEQj.mjs")
 	},
 	{
 		packageName: "@framefields/node-levels",
 		ops: ["Levels"],
-		load: () => import("./renderer-BH8vZKmX.mjs")
+		load: () => import("./renderer-DF_ONJ3v.mjs")
 	},
 	{
 		packageName: "@framefields/node-liquify",
 		ops: ["Liquify"],
-		load: () => import("./renderer-D6NXn3Ky.mjs")
+		load: () => import("./renderer-BNYZY3FE.mjs")
 	},
 	{
 		packageName: "@framefields/node-mask-math",
 		ops: ["MaskMath"],
-		load: () => import("./renderer-DSSTVulw.mjs")
+		load: () => import("./renderer-Pc8dyNXt.mjs")
 	},
 	{
 		packageName: "@framefields/node-mesh-warp",
 		ops: ["MeshWarp"],
-		load: () => import("./renderer-DZ9j3fQj.mjs")
+		load: () => import("./renderer-B_M_yhTc.mjs")
 	},
 	{
 		packageName: "@framefields/node-modulate",
 		ops: ["Modulate"],
-		load: () => import("./renderer-BPbM_6WR.mjs")
+		load: () => import("./renderer-CuOjhtoo.mjs")
 	},
 	{
 		packageName: "@framefields/node-noise-generator",
 		ops: ["NoiseGenerator"],
-		load: () => import("./renderer-B4JmNa_T.mjs")
+		load: () => import("./renderer-DwVOxdzC.mjs")
 	},
 	{
 		packageName: "@framefields/node-op-art",
 		ops: ["OpArt"],
-		load: () => import("./renderer-CoX23zo_.mjs")
+		load: () => import("./renderer-DaqWTx7s.mjs")
 	},
 	{
 		packageName: "@framefields/node-paint",
 		ops: ["Paint"],
-		load: () => import("./renderer-BPJ79b47.mjs")
+		load: () => import("./renderer-CIuxV2q1.mjs")
 	},
 	{
 		packageName: "@framefields/node-painterly",
 		ops: ["Painterly"],
-		load: () => import("./renderer-DqgduGiO.mjs")
+		load: () => import("./renderer-BwpgDLYO.mjs")
 	},
 	{
 		packageName: "@framefields/node-particles",
@@ -482,67 +517,67 @@ const BUILTIN_NODE_RENDERERS = [
 	{
 		packageName: "@framefields/node-patch-heal",
 		ops: ["PatchHeal"],
-		load: () => import("./renderer-gbBgGPNL.mjs")
+		load: () => import("./renderer-DjwITRvg.mjs")
 	},
 	{
 		packageName: "@framefields/node-pixelate",
 		ops: ["Pixelate"],
-		load: () => import("./renderer-Ai5nZsof.mjs")
+		load: () => import("./renderer-Za4D9hej.mjs")
 	},
 	{
 		packageName: "@framefields/node-posterize",
 		ops: ["Posterize"],
-		load: () => import("./renderer-BZvWlGsa.mjs")
+		load: () => import("./renderer-DTw-W0Yz.mjs")
 	},
 	{
 		packageName: "@framefields/node-procedural-vfx",
 		ops: ["ProceduralVFX"],
-		load: () => import("./renderer-D-e3vDnO.mjs")
+		load: () => import("./renderer-DzSMeQBC.mjs")
 	},
 	{
 		packageName: "@framefields/node-refine-edge",
 		ops: ["RefineEdge"],
-		load: () => import("./renderer-B16iwR0_.mjs")
+		load: () => import("./renderer-KP7Ita9g.mjs")
 	},
 	{
 		packageName: "@framefields/node-refraction-caustics",
 		ops: ["RefractionCaustics3D"],
-		load: () => import("./renderer-Edn9xltT.mjs")
+		load: () => import("./renderer-BjCHW9Jp.mjs")
 	},
 	{
 		packageName: "@framefields/node-relight-3d",
 		ops: ["Relight3D"],
-		load: () => import("./renderer-KtG5p44R.mjs")
+		load: () => import("./renderer-DlYchp1v.mjs")
 	},
 	{
 		packageName: "@framefields/node-resizer-scaler",
 		ops: ["ResizerScaler"],
-		load: () => import("./renderer-BZCLdb8F.mjs")
+		load: () => import("./renderer-BBAbZfBl.mjs")
 	},
 	{
 		packageName: "@framefields/node-rgb-split",
 		ops: ["RGBSplit"],
-		load: () => import("./renderer-CjTxu89O.mjs")
+		load: () => import("./renderer-B1QREs7J.mjs")
 	},
 	{
 		packageName: "@framefields/node-rotate",
 		ops: ["Rotate"],
-		load: () => import("./renderer-CAtXDNsh.mjs")
+		load: () => import("./renderer-CnHsMLIv.mjs")
 	},
 	{
 		packageName: "@framefields/node-selective-color",
 		ops: ["SelectiveColor"],
-		load: () => import("./renderer-D-cWBX0r.mjs")
+		load: () => import("./renderer-h6ev1ogx.mjs")
 	},
 	{
 		packageName: "@framefields/node-shadows-highlights",
 		ops: ["ShadowsHighlights"],
-		load: () => import("./renderer-D0q2VyJR.mjs")
+		load: () => import("./renderer-DxBav2bE.mjs")
 	},
 	{
 		packageName: "@framefields/node-shape-generator",
 		ops: ["ShapeGenerator"],
-		load: () => import("./renderer-C2ZIAhdJ.mjs")
+		load: () => import("./renderer-BkWd4-YO.mjs")
 	},
 	{
 		packageName: "@framefields/node-signal-gate",
@@ -552,37 +587,37 @@ const BUILTIN_NODE_RENDERERS = [
 	{
 		packageName: "@framefields/node-stereo-panning",
 		ops: ["StereoPanning"],
-		load: () => import("./renderer-hmWhsR6C.mjs")
+		load: () => import("./renderer-Cu5MFgbk.mjs")
 	},
 	{
 		packageName: "@framefields/node-tile-offset",
 		ops: ["TileOffset"],
-		load: () => import("./renderer-DgWh5noB.mjs")
+		load: () => import("./renderer-CoxuAr7b.mjs")
 	},
 	{
 		packageName: "@framefields/node-toon",
 		ops: ["Toon"],
-		load: () => import("./renderer-Cz9fzS11.mjs")
+		load: () => import("./renderer-DaSxr9fM.mjs")
 	},
 	{
 		packageName: "@framefields/node-trails",
 		ops: ["Trails"],
-		load: () => import("./renderer-CoO2j8AC.mjs")
+		load: () => import("./renderer-DILUmb-e.mjs")
 	},
 	{
 		packageName: "@framefields/node-unsharp-mask",
 		ops: ["UnsharpMask"],
-		load: () => import("./renderer-Cvd3oIJQ.mjs")
+		load: () => import("./renderer-BvOQgFHo.mjs")
 	},
 	{
 		packageName: "@framefields/node-vignette",
 		ops: ["Vignette"],
-		load: () => import("./renderer-Cie7KKeQ.mjs")
+		load: () => import("./renderer-BSvubMvI.mjs")
 	},
 	{
 		packageName: "@framefields/node-vision",
 		ops: ["Vision"],
-		load: () => import("./renderer-BARst3ZD.mjs")
+		load: () => import("./renderer-ezRCmU09.mjs")
 	}
 ];
 /**
@@ -932,9 +967,217 @@ const bootstrapMediabunny = () => {
 	registerMediabunnyServer(videoCodecServerOptions(isAMD()));
 	for (const key of Object.keys(webcodecs)) if (typeof globalThis[key] === "undefined") globalThis[key] = webcodecs[key];
 };
-
-//#endregion
-//#region ../renderer/dist/headless-webgpu-renderer-1QAxgoPn.mjs
+const LOG_PREFIX = "[HeadlessWebGPURenderer]";
+/** A milestone reached sooner than this after the last line is not logged. */
+const MIN_LOG_GAP_MS = 1e3;
+/**
+* Quiet time before the first "still …" line of a phase. Each one doubles it
+* up to the cap, so a long phase adds a few lines rather than one a minute.
+*/
+const HEARTBEAT_FIRST_MS = 1e4;
+const HEARTBEAT_MAX_MS = 5 * 6e4;
+const ACTIVITY = {
+	prepare: "preparing",
+	render: "rendering",
+	audio: "mixing audio",
+	"audio-encode": "encoding audio",
+	mux: "muxing",
+	convert: "converting to GIF",
+	done: "finishing"
+};
+/**
+* Reports a render's progress to the log and to `onProgress`.
+*
+* The log stays short whatever the length of the film, so it fits an agent's
+* context: one line per phase, frame lines only at percent milestones, and a
+* "still …" line when a phase goes quiet, backing off from 10 s to 5 min.
+* `onProgress` gets every update; the "still …" lines are log-only, so a stall
+* detector fed by `onProgress` still sees a hang.
+*/
+var RenderReporter = class {
+	renderId;
+	totalFrames;
+	onProgress;
+	milestonePercent;
+	log;
+	now;
+	startedAt;
+	phaseMs = /* @__PURE__ */ new Map();
+	phase = "prepare";
+	phaseStartedAt;
+	frame = 0;
+	phaseProgress;
+	detail;
+	lastMilestone = 0;
+	/** Last phase or milestone line; "still …" lines don't count. */
+	lastLogAt;
+	heartbeatMs = HEARTBEAT_FIRST_MS;
+	heartbeat;
+	constructor(options$1) {
+		this.renderId = options$1.renderId;
+		this.totalFrames = options$1.totalFrames;
+		this.onProgress = options$1.onProgress;
+		this.milestonePercent = options$1.milestonePercent ?? 10;
+		this.log = options$1.log ?? rendererLogger;
+		this.now = options$1.now ?? (() => performance.now());
+		this.startedAt = this.now();
+		this.phaseStartedAt = this.startedAt;
+		this.lastLogAt = this.startedAt;
+	}
+	/** Starts a phase: logs `message` and emits a progress event. */
+	stage(phase, message, fields = {}) {
+		this.closePhase();
+		this.phase = phase;
+		this.phaseProgress = void 0;
+		this.detail = void 0;
+		this.heartbeatMs = HEARTBEAT_FIRST_MS;
+		if (phase !== "render" && phase !== "prepare") this.frame = this.totalFrames;
+		this.info(message, fields);
+		this.emit();
+	}
+	/** Records a finished frame; logs at each milestone. */
+	frameDone(frame) {
+		this.frame = frame;
+		const percent = frame / this.totalFrames * 100;
+		const milestone = frame >= this.totalFrames ? 100 : Math.floor(percent / this.milestonePercent) * this.milestonePercent;
+		const { fps, etaSec } = this.rate();
+		if (milestone > this.lastMilestone) {
+			this.lastMilestone = milestone;
+			if (milestone === 100 || this.now() - this.lastLogAt >= MIN_LOG_GAP_MS) {
+				const tail = milestone === 100 ? `in ${formatDuration(this.now() - this.phaseStartedAt)}` : `eta ${formatDuration(etaSec * 1e3)}`;
+				this.info(`Rendered ${milestone}% (${frame}/${this.totalFrames} frames) · ${fps.toFixed(1)} fps · ${tail}`, {
+					fps: round1(fps),
+					etaSec
+				});
+			}
+		}
+		this.emit({
+			fps: round1(fps),
+			etaSec
+		});
+	}
+	/** Updates what the current phase is doing; shown in "still …" lines. */
+	update(detail, phaseProgress) {
+		this.detail = detail;
+		this.phaseProgress = phaseProgress;
+		this.emit();
+	}
+	/** Logs the summary and emits the "done" event. */
+	finish(fields = {}) {
+		this.closePhase();
+		this.phase = "done";
+		this.frame = this.totalFrames;
+		this.stopHeartbeat();
+		const total = this.now() - this.startedAt;
+		const parts = [...this.phaseMs].map(([phase, ms]) => `${phase} ${formatDuration(ms)}`);
+		const size = fields.bytes !== void 0 ? ` (${formatBytes(fields.bytes)})` : "";
+		this.log.info({
+			renderId: this.renderId,
+			phase: "done",
+			elapsedMs: Math.round(total),
+			phaseMs: Object.fromEntries([...this.phaseMs].map(([phase, ms]) => [phase, Math.round(ms)])),
+			...fields
+		}, `${LOG_PREFIX} Done in ${formatDuration(total)}${size}: ${parts.join(" · ")}`);
+		this.emit();
+	}
+	/** Logs which phase the render stopped in. */
+	fail(error, aborted) {
+		this.stopHeartbeat();
+		const elapsed = formatDuration(this.now() - this.startedAt);
+		const fields = {
+			renderId: this.renderId,
+			phase: this.phase,
+			frame: this.frame,
+			totalFrames: this.totalFrames,
+			elapsedMs: Math.round(this.now() - this.startedAt)
+		};
+		if (aborted) this.log.warn(fields, `${LOG_PREFIX} Aborted while ${ACTIVITY[this.phase]} after ${elapsed}`);
+		else this.log.error({
+			...fields,
+			err: error
+		}, `${LOG_PREFIX} Failed while ${ACTIVITY[this.phase]} after ${elapsed}`);
+	}
+	/** Stops the "still …" timer. Safe to call more than once. */
+	dispose() {
+		this.stopHeartbeat();
+	}
+	closePhase() {
+		const now = this.now();
+		this.phaseMs.set(this.phase, (this.phaseMs.get(this.phase) ?? 0) + (now - this.phaseStartedAt));
+		this.phaseStartedAt = now;
+	}
+	rate() {
+		const seconds = Math.max(.001, (this.now() - this.phaseStartedAt) / 1e3);
+		const fps = this.frame / seconds;
+		return {
+			fps,
+			etaSec: Math.round((this.totalFrames - this.frame) / Math.max(fps, .001))
+		};
+	}
+	info(message, fields = {}) {
+		this.log.info({
+			renderId: this.renderId,
+			phase: this.phase,
+			frame: this.frame,
+			totalFrames: this.totalFrames,
+			...fields
+		}, `${LOG_PREFIX} ${message}`);
+		this.lastLogAt = this.now();
+		this.armHeartbeat();
+	}
+	emit(extra = {}) {
+		this.onProgress?.({
+			phase: this.phase,
+			frame: this.frame,
+			totalFrames: this.totalFrames,
+			elapsedMs: Math.round(this.now() - this.startedAt),
+			...this.phaseProgress !== void 0 && { phaseProgress: this.phaseProgress },
+			...this.detail !== void 0 && { detail: this.detail },
+			...extra
+		});
+	}
+	armHeartbeat() {
+		this.stopHeartbeat();
+		this.heartbeat = setTimeout(() => this.beat(), this.heartbeatMs);
+		this.heartbeat.unref?.();
+	}
+	beat() {
+		const inPhase = formatDuration(this.now() - this.phaseStartedAt);
+		let what = "";
+		if (this.phase === "render") what = ` (frame ${this.frame}/${this.totalFrames})`;
+		else if (this.detail || this.phaseProgress !== void 0) what = ` (${[this.phaseProgress !== void 0 ? `${Math.floor(this.phaseProgress * 100)}%` : "", this.detail].filter(Boolean).join(", ")})`;
+		this.log.info({
+			renderId: this.renderId,
+			phase: this.phase,
+			frame: this.frame,
+			totalFrames: this.totalFrames
+		}, `${LOG_PREFIX} Still ${ACTIVITY[this.phase]}${what}, ${inPhase} in this phase`);
+		this.heartbeatMs = Math.min(this.heartbeatMs * 2, HEARTBEAT_MAX_MS);
+		this.armHeartbeat();
+	}
+	stopHeartbeat() {
+		if (this.heartbeat) clearTimeout(this.heartbeat);
+		this.heartbeat = void 0;
+	}
+};
+/** "4.2s", "2m 05s", "1h 02m". */
+function formatDuration(ms) {
+	const s = Math.max(0, ms) / 1e3;
+	if (s < 60) return `${s.toFixed(1)}s`;
+	const total = Math.round(s);
+	const h = Math.floor(total / 3600);
+	const m = Math.floor(total % 3600 / 60);
+	const sec = total % 60;
+	if (h > 0) return `${h}h ${String(m).padStart(2, "0")}m`;
+	return `${m}m ${String(sec).padStart(2, "0")}s`;
+}
+function formatBytes(bytes) {
+	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+	return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}
+function round1(n) {
+	return Math.round(n * 10) / 10;
+}
 const DEFAULTS = {
 	blackPixelThreshold: .1,
 	blackFrameRatio: .98,
@@ -954,9 +1197,9 @@ var FrameInspector = class {
 	sameAsPrevious = [];
 	lumaSum = 0;
 	previous = null;
-	constructor(options = {}) {
-		this.blackLuma = (options.blackPixelThreshold ?? DEFAULTS.blackPixelThreshold) * 255;
-		this.blackRatio = options.blackFrameRatio ?? DEFAULTS.blackFrameRatio;
+	constructor(options$1 = {}) {
+		this.blackLuma = (options$1.blackPixelThreshold ?? DEFAULTS.blackPixelThreshold) * 255;
+		this.blackRatio = options$1.blackFrameRatio ?? DEFAULTS.blackFrameRatio;
 	}
 	get frameCount() {
 		return this.black.length;
@@ -989,9 +1232,9 @@ var FrameInspector = class {
 		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));
+	stats(expectedFrames, encodedFrames, fps, width, height, options$1 = {}) {
+		const minBlack = Math.max(1, Math.round((options$1.minBlackSec ?? DEFAULTS.minBlackSec) * fps));
+		const minFrozen = Math.max(2, Math.round((options$1.minFrozenSec ?? DEFAULTS.minFrozenSec) * fps));
 		const blackSegments = runs(this.black, minBlack).map(([a, b]) => ({
 			startSec: a / fps,
 			endSec: b / fps
@@ -1026,7 +1269,7 @@ function runs(flags, minLength) {
 }
 const toDb = (power) => power > 0 ? 10 * Math.log10(power) : -Infinity;
 /** Measures a mixed audio track (one Float32Array per channel). */
-function analyzeAudio(channels, sampleRate, options = {}) {
+function analyzeAudio(channels, sampleRate, options$1 = {}) {
 	const length = channels[0]?.length ?? 0;
 	let peak = 0;
 	let sumSquares = 0;
@@ -1038,7 +1281,7 @@ function analyzeAudio(channels, sampleRate, options = {}) {
 		sumSquares += v * v;
 	}
 	const total = length * Math.max(1, channels.length);
-	const silenceDbfs = options.silenceDbfs ?? DEFAULTS.silenceDbfs;
+	const silenceDbfs = options$1.silenceDbfs ?? DEFAULTS.silenceDbfs;
 	const window = Math.max(1, Math.round(sampleRate * .1));
 	const silent = [];
 	for (let start = 0; start < length; start += window) {
@@ -1047,7 +1290,7 @@ function analyzeAudio(channels, sampleRate, options = {}) {
 		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]) => ({
+	const silentSegments = runs(silent, Math.max(1, Math.round((options$1.minSilenceSec ?? DEFAULTS.minSilenceSec) / .1))).map(([a, b]) => ({
 		startSec: a * window / sampleRate,
 		endSec: Math.min(length, b * window) / sampleRate
 	}));
@@ -1143,7 +1386,7 @@ function integratedLoudness(channels, sampleRate) {
 }
 /** Turn measurements and document diagnostics into a report with issues. */
 function buildQaReport(parts) {
-	const { video, audio, options = {} } = parts;
+	const { video, audio, options: options$1 = {} } = parts;
 	const issues = [];
 	const at = (s) => `${s.startSec.toFixed(2)}–${s.endSec.toFixed(2)} s`;
 	if (video) {
@@ -1182,13 +1425,13 @@ function buildQaReport(parts) {
 			message: `Silence at ${at(s)}`,
 			...s
 		});
-		if (options.targetLufs !== void 0) {
-			const off = audio.integratedLufs - options.targetLufs;
-			const tolerance = options.lufsTolerance ?? DEFAULTS.lufsTolerance;
+		if (options$1.targetLufs !== void 0) {
+			const off = audio.integratedLufs - options$1.targetLufs;
+			const tolerance = options$1.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`
+				message: `Integrated loudness ${audio.integratedLufs.toFixed(1)} LUFS is ${Math.abs(off).toFixed(1)} LU ${off > 0 ? "above" : "below"} the ${options$1.targetLufs} LUFS target`
 			});
 		}
 	}
@@ -1247,16 +1490,16 @@ var ZeroCopyWebCodecsPipeline = class {
 	maxCycleTimeMs = 0;
 	minCycleTimeMs = Number.POSITIVE_INFINITY;
 	pipelineStartTime = 0;
-	constructor(device, options) {
+	constructor(device, options$1) {
 		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.width = options$1.width;
+		this.height = options$1.height;
+		this.fps = options$1.fps;
+		this.videoSource = options$1.videoSource;
+		this.ringCapacity = Math.max(2, options$1.ringCapacity ?? 2);
+		this.colorSpace = options$1.colorSpace;
+		this.directCanvasSource = options$1.directCanvasSource;
+		this.onFrame = options$1.onFrame;
 		this.stagingRing = new DmaStagingRing(device, {
 			width: this.width,
 			height: this.height,
@@ -1573,6 +1816,13 @@ const takeStillId = () => idleStillIds.pop() ?? `img-${randomUUID()}`;
 const returnStillId = (id) => {
 	idleStillIds.push(id);
 };
+async function fileSize(file) {
+	try {
+		return (await fs$1.stat(file)).size;
+	} catch {
+		return;
+	}
+}
 function toEvenDimension(n) {
 	const v = Math.round(n);
 	return v % 2 === 0 ? v : v + 1;
@@ -1697,13 +1947,13 @@ var HeadlessWebGPURenderer = class HeadlessWebGPURenderer$1 {
 		})();
 		return HeadlessWebGPURenderer$1.initPromise;
 	}
-	async renderImage(virtualMedia, frame = 0, fps = 24, options = {}) {
+	async renderImage(virtualMedia, frame = 0, fps = 24, options$1 = {}) {
 		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 pooledId = options.renderId ? void 0 : takeStillId();
-		const renderId = options.renderId ?? pooledId;
+		const pooledId = options$1.renderId ? void 0 : takeStillId();
+		const renderId = options$1.renderId ?? pooledId;
 		rendererLogger.debug({
 			renderId,
 			frame,
@@ -1771,7 +2021,7 @@ var HeadlessWebGPURenderer = class HeadlessWebGPURenderer$1 {
 			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);
+			if (options$1.format === "rgba") return Buffer.from(pixelsArr);
 			return await sharp(Buffer.from(pixelsArr), { raw: {
 				width,
 				height,
@@ -1802,26 +2052,26 @@ var HeadlessWebGPURenderer = class HeadlessWebGPURenderer$1 {
 	/**
 	* Renders a single frame to a PNG buffer at a specified timestamp in milliseconds or frame index.
 	*/
-	async renderFrame(source, options = {}) {
+	async renderFrame(source, options$1 = {}) {
 		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;
+		const fps = options$1.fps ?? (vm.metadata?.fps || 30);
+		const frame = options$1.atMs !== void 0 ? Math.round(options$1.atMs / 1e3 * fps) : options$1.frame ?? 0;
 		return this.renderImage(vm, frame, fps, {
-			renderId: options.renderId,
-			format: options.format
+			renderId: options$1.renderId,
+			format: options$1.format
 		});
 	}
 	/**
 	* Mixes the composition's full audio timeline (clips, effects, synthesized
 	* tracks) to stereo PCM, exactly as `renderVideo` muxes it.
 	*/
-	async renderAudio(virtualMedia, options = {}) {
+	async renderAudio(virtualMedia, options$1 = {}) {
 		await HeadlessWebGPURenderer$1.initialize();
-		const fps = options.fps ?? (virtualMedia.metadata?.fps || 30);
+		const fps = options$1.fps ?? (virtualMedia.metadata?.fps || 30);
 		await renderSemaphore.acquire();
 		try {
 			const device = await ensureDevice();
-			return await mixAudioTracks(virtualMedia, fps, options.sampleRate ?? 48e3, device, `aud-${randomUUID()}`);
+			return await mixAudioTracks(virtualMedia, fps, options$1.sampleRate ?? 48e3, device, `aud-${randomUUID()}`);
 		} finally {
 			renderSemaphore.release();
 		}
@@ -1961,9 +2211,9 @@ var HeadlessWebGPURenderer = class HeadlessWebGPURenderer$1 {
 		} catch (_) {}
 		return maxDurationMs > 0 ? maxDurationMs : 1e3;
 	}
-	async renderVideo(virtualMedia, options) {
+	async renderVideo(virtualMedia, options$1) {
 		await HeadlessWebGPURenderer$1.initialize();
-		const codecOption = options?.codec ?? "h264";
+		const codecOption = options$1?.codec ?? "h264";
 		const isMp3 = codecOption === "mp3";
 		const isWebM = codecOption === "vp8" || codecOption === "vp9" || codecOption === "opus";
 		const mediaType = getMediaType(virtualMedia);
@@ -1985,13 +2235,13 @@ var HeadlessWebGPURenderer = class HeadlessWebGPURenderer$1 {
 		}
 		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 qaOptions = options$1?.qa === true ? {} : options$1?.qa ? options$1.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);
+		const audioCodec = options$1?.audioCodec ?? (isMp3 ? "mp3" : isWebM ? "opus" : "aac");
+		const quality = resolveQuality(options$1?.quality);
 		rendererLogger.debug({
 			renderId,
 			totalFrames,
@@ -2001,7 +2251,24 @@ var HeadlessWebGPURenderer = class HeadlessWebGPURenderer$1 {
 			codec: codecOption,
 			...renderSemaphore.stats
 		}, "[HeadlessWebGPURenderer] Acquiring slot for video render (inline)");
+		if (renderSemaphore.stats.active >= renderSemaphore.stats.max) rendererLogger.info({
+			renderId,
+			...renderSemaphore.stats
+		}, `[HeadlessWebGPURenderer] Waiting for a render slot (${renderSemaphore.stats.active} running, ${renderSemaphore.stats.queued} queued)`);
 		await renderSemaphore.acquire();
+		const reporter = new RenderReporter({
+			renderId,
+			totalFrames,
+			onProgress: options$1?.onProgress
+		});
+		const seconds = `${(durationMs / 1e3).toFixed(1)}s`;
+		reporter.stage("prepare", isAudioOnly ? `Preparing ${seconds} of audio (${audioCodec})` : `Preparing ${totalFrames} frames (${seconds}) at ${width}x${height}, ${fps} fps, ${codecOption}`, {
+			width,
+			height,
+			fps,
+			durationMs,
+			codec: codecOption
+		});
 		let lastCpuUsage = process.cpuUsage();
 		let lastCpuTime = process.hrtime.bigint();
 		const getCpuUsage = () => {
@@ -2062,11 +2329,11 @@ var HeadlessWebGPURenderer = class HeadlessWebGPURenderer$1 {
 		output.addAudioTrack(audioSource);
 		let outputStarted = false;
 		let outputFinalized = false;
-		const device = await ensureDevice();
 		let surface;
 		let renderer;
 		let pipeline;
 		try {
+			const device = await ensureDevice();
 			await output.start();
 			outputStarted = true;
 			await preloadFonts(virtualMedia, device);
@@ -2078,7 +2345,7 @@ var HeadlessWebGPURenderer = class HeadlessWebGPURenderer$1 {
 					height,
 					fps,
 					videoSource,
-					ringCapacity: resolveRingCapacity(options?.ringCapacity),
+					ringCapacity: resolveRingCapacity(options$1?.ringCapacity),
 					onFrame: inspector ? (rgba) => inspector.inspect(rgba, width, height) : void 0
 				});
 				const ctx = surface && renderer ? {
@@ -2112,13 +2379,9 @@ var HeadlessWebGPURenderer = class HeadlessWebGPURenderer$1 {
 					await lutStore.awaitAllPending(device);
 				};
 				await prePass(0);
+				reporter.stage("render", `Rendering ${totalFrames} frames`);
 				for (let i = 0; i < totalFrames; i++) {
-					options?.signal?.throwIfAborted();
-					if (i % 10 === 0) rendererLogger.info({
-						renderId,
-						frame: i,
-						totalFrames
-					}, `[HeadlessWebGPURenderer] Rendering frame ${i}/${totalFrames}`);
+					options$1?.signal?.throwIfAborted();
 					if (ctx && surface && renderer && pipeline) {
 						if (i > 0 && (lutStore.hasPending(device) || SlugFontCache.hasPending())) {
 							updateClockSignals(i, fps, durationMs);
@@ -2148,15 +2411,12 @@ var HeadlessWebGPURenderer = class HeadlessWebGPURenderer$1 {
 							isVideoMode: virtualMedia.operation?.dataType === "Video"
 						});
 						await pipeline.enqueueFrame(i, targetTexture, encoder);
-						options?.onProgress?.({
-							phase: "render",
-							frame: i + 1,
-							totalFrames
-						});
+						if (i + 1 < totalFrames) reporter.frameDone(i + 1);
 					} else throw new Error("Invalid render context state");
 				}
 				if (pipeline) {
 					await pipeline.drain();
+					reporter.frameDone(totalFrames);
 					const pipelineStats = pipeline.getStats();
 					if (inspector && qaOptions) videoQa = inspector.stats(totalFrames, pipelineStats.totalFramesEncoded, fps, width, height, qaOptions);
 					rendererLogger.debug({
@@ -2166,18 +2426,15 @@ 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?.signal?.throwIfAborted();
-			options?.onProgress?.({
-				phase: "audio",
-				frame: totalFrames,
-				totalFrames
-			});
-			const { channels, sampleRate } = await mixAudioTracks(virtualMedia, fps, 48e3, device, renderId);
+			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);
@@ -2194,8 +2451,11 @@ var HeadlessWebGPURenderer = class HeadlessWebGPURenderer$1 {
 				} finally {
 					sample.close();
 				}
+				const written = offset + currentChunk;
+				reporter.update(`${(written / sampleRate).toFixed(1)}s/${(totalSamples / sampleRate).toFixed(1)}s`, written / totalSamples);
 			}
-			options?.signal?.throwIfAborted();
+			options$1?.signal?.throwIfAborted();
+			reporter.stage("mux", `Muxing ${extension}`);
 			await output.finalize();
 			outputFinalized = true;
 			const qa = qaOptions ? buildQaReport({
@@ -2211,20 +2471,23 @@ var HeadlessWebGPURenderer = class HeadlessWebGPURenderer$1 {
 				} catch {}
 			};
 			if (codecOption === "gif") {
-				rendererLogger.debug("[HeadlessWebGPURenderer] Converting rendered MP4 to high-quality GIF...");
+				reporter.stage("convert", "Converting to GIF (ffmpeg)");
 				await convertMp4ToGif(tempFilePath, tempGifPath);
+				reporter.finish({ bytes: await fileSize(tempGifPath) });
 				return {
 					filePath: tempGifPath,
 					cleanup,
 					...qa && { qa }
 				};
 			}
+			reporter.finish({ bytes: await fileSize(tempFilePath) });
 			return {
 				filePath: tempFilePath,
 				cleanup,
 				...qa && { qa }
 			};
 		} catch (error) {
+			reporter.fail(error, options$1?.signal?.aborted === true);
 			if (outputStarted && !outputFinalized) try {
 				await output.finalize();
 			} catch {}
@@ -2234,6 +2497,7 @@ var HeadlessWebGPURenderer = class HeadlessWebGPURenderer$1 {
 			} catch {}
 			throw error;
 		} finally {
+			reporter.dispose();
 			if (statsInterval) clearInterval(statsInterval);
 			try {
 				renderer?.destroy();
@@ -2293,28 +2557,28 @@ function resetRenderCaches() {
 /**
 * Resolves and validates the list of sample points from the provided options.
 */
-function resolveSamplePoints(options, defaultFps = 24, durationMs) {
-	const fps = options.fps ?? defaultFps;
+function resolveSamplePoints(options$1, defaultFps = 24, durationMs) {
+	const fps = options$1.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 (Array.isArray(options$1.frames) && options$1.frames.length > 0) for (const f of options$1.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) {
+	else if (Array.isArray(options$1.timesMs) && options$1.timesMs.length > 0) for (const ms of options$1.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);
+	else if (options$1.startMs !== void 0 || options$1.endMs !== void 0 || options$1.stepMs !== void 0) {
+		const startMs = options$1.startMs ?? 0;
+		const endMs = options$1.endMs ?? durationMs ?? startMs + 1e3;
+		const stepMs = options$1.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({
@@ -2322,9 +2586,9 @@ function resolveSamplePoints(options, defaultFps = 24, durationMs) {
 			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;
+		const startFrame = options$1.startFrame ?? 0;
+		const endFrame = options$1.endFrame ?? (durationMs ? Math.min(startFrame + 30, Math.floor(durationMs / 1e3 * fps)) : startFrame + 30);
+		const stepFrames = options$1.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({
@@ -2332,7 +2596,7 @@ function resolveSamplePoints(options, defaultFps = 24, durationMs) {
 			timeMs: Math.round(f / fps * 1e3)
 		});
 	}
-	const maxFramesLimit = Math.min(options.maxFrames ?? 64, 120);
+	const maxFramesLimit = Math.min(options$1.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 {
@@ -2343,13 +2607,13 @@ function resolveSamplePoints(options, defaultFps = 24, durationMs) {
 /**
 * 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;
+function computeGridLayout(numSamples, aspectRatio, options$1) {
+	const gap = options$1.gap ?? 12;
+	const padding = options$1.padding ?? 16;
+	const headerHeight = options$1.showHeader ?? true ? 54 : 0;
+	const maxGridWidth = options$1.maxGridWidth ?? 4096;
+	const maxGridHeight = options$1.maxGridHeight ?? 4096;
+	let columns = options$1.columns;
 	if (!columns || columns <= 0) if (numSamples <= 4) columns = numSamples;
 	else if (numSamples <= 9) columns = 3;
 	else if (numSamples <= 16) columns = 4;
@@ -2357,8 +2621,8 @@ function computeGridLayout(numSamples, aspectRatio, options) {
 	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 cellWidth = Math.max(120, Math.min(options$1.cellWidth ?? 320, 960));
+	let cellHeight = options$1.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) {
@@ -2385,15 +2649,15 @@ function computeGridLayout(numSamples, aspectRatio, options) {
 * 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 = {}) {
+async function renderFrameGrid(target, options$1 = {}) {
 	const defaultFps = target.fps ?? 24;
 	const durationMs = target.durationMs;
-	const { samples, fps } = resolveSamplePoints(options, defaultFps, durationMs);
+	const { samples, fps } = resolveSamplePoints(options$1, 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 layout = computeGridLayout(samples.length, aspectRatio, options$1);
+	const renderer = options$1.renderer ?? new HeadlessMediaRenderer();
 	const frameBuffers = [];
 	for (const sample of samples) {
 		const buf = await target.renderFrame({
@@ -2406,11 +2670,11 @@ async function renderFrameGrid(target, options = {}) {
 	}
 	const canvas = new Canvas(layout.totalWidth, layout.totalHeight);
 	const ctx = canvas.getContext("2d");
-	ctx.fillStyle = options.backgroundColor ?? "#090a0f";
+	ctx.fillStyle = options$1.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"}`;
+	if (options$1.showHeader !== false && layout.headerHeight > 0) {
+		const title = options$1.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$1.stepFrames ? `${options$1.stepFrames}f` : options$1.stepMs ? `${options$1.stepMs}ms` : "Custom"}`;
 		ctx.fillStyle = "#f8fafc";
 		ctx.font = "bold 15px sans-serif";
 		ctx.fillText(title, layout.padding, layout.padding + 18);
@@ -2424,7 +2688,7 @@ async function renderFrameGrid(target, options = {}) {
 		ctx.lineTo(layout.totalWidth - layout.padding, layout.padding + 46);
 		ctx.stroke();
 	}
-	const showLabels = options.showLabels ?? true;
+	const showLabels = options$1.showLabels ?? true;
 	for (let i = 0; i < samples.length; i++) {
 		const sample = samples[i];
 		const col = i % layout.columns;
@@ -2455,10 +2719,10 @@ async function renderFrameGrid(target, options = {}) {
 		}
 	}
 	const gridBuffer = await canvas.toBuffer("png");
-	if (options.outputPath) await fs$1.writeFile(options.outputPath, gridBuffer);
+	if (options$1.outputPath) await fs$1.writeFile(options$1.outputPath, gridBuffer);
 	return gridBuffer;
 }
 
 //#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-TyZu7nQ2.mjs.map
+//# sourceMappingURL=renderer-CoWfz-9p.mjs.map