framefields 2.1.3 → 2.2.0-beta.1

package/dist/{renderer-B6x_Mmpf.mjs → renderer-DzDZlez7.mjs}

@@ -1,7 +1,8 @@
 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-Cog5jyVI.mjs";
-import { i as mixAudioTracks, m as preloadCompositionFonts, r as drawCompositionTree, t as compositionStateStore } from "./dist-BgFYDCoL.mjs";
+import { B as lutStore, F as inputStore, H as mediaDecoderCache, N as getRenderer2D, O as ensureDevice, P as initHeadlessWebGPU, Z as shaderStore, _ as clearAllVideoCache, et as textureCache, g as WebGPUAudioProcessor, p as SlugFontCache, s as NodeSurfaceProvider } from "./dist-DQlYw4eG.mjs";
+import { i as mixAudioTracks, m as preloadCompositionFonts, r as drawCompositionTree, t as compositionStateStore } from "./dist-BLbXEC6V.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";
 import path from "node:path";
@@ -17,7 +18,7 @@ import { registerMediabunnyServer } from "@mediabunny/server";
 import { exec, spawn } from "node:child_process";
 import sharp from "sharp";
 
-//#region ../renderer/dist/bootstrap-mediabunny-CxYBXeAy.mjs
+//#region ../renderer/dist/bootstrap-mediabunny--TDh3Bij.mjs
 const rendererLogger = pino({
 	level: typeof process !== "undefined" && process.env?.LOG_LEVEL || "info",
 	timestamp: pino.stdTimeFunctions.isoTime,
@@ -241,232 +242,232 @@ const BUILTIN_NODE_RENDERERS = [
 	{
 		packageName: "@framefields/node-lut",
 		ops: ["ApplyLUT"],
-		load: () => import("./renderer-DTkBPkBu.mjs")
+		load: () => import("./renderer-WrpQEVdv.mjs")
 	},
 	{
 		packageName: "@framefields/node-audio-compressor",
 		ops: ["AudioCompressor"],
-		load: () => import("./renderer-BH4zfzus.mjs")
+		load: () => import("./renderer-SWVUDypd.mjs")
 	},
 	{
 		packageName: "@framefields/node-audio-delay",
 		ops: ["AudioDelay"],
-		load: () => import("./renderer-B5CoE2Cv.mjs")
+		load: () => import("./renderer-BtGNxEay.mjs")
 	},
 	{
 		packageName: "@framefields/node-audio-fade",
 		ops: ["AudioFade"],
-		load: () => import("./renderer-lifu3xIt.mjs")
+		load: () => import("./renderer-BLAkNFx7.mjs")
 	},
 	{
 		packageName: "@framefields/node-audio-noise-gate",
 		ops: ["AudioNoiseGate"],
-		load: () => import("./renderer-C_U225ub.mjs")
+		load: () => import("./renderer-FTKfOejk.mjs")
 	},
 	{
 		packageName: "@framefields/node-audio-parametric-eq",
 		ops: ["AudioParametricEq"],
-		load: () => import("./renderer-D9SJ4Fg9.mjs")
+		load: () => import("./renderer-CV-l8wMq.mjs")
 	},
 	{
 		packageName: "@framefields/node-audio-reverb",
 		ops: ["AudioReverb"],
-		load: () => import("./renderer-B6Au6f82.mjs")
+		load: () => import("./renderer-BjeA7s36.mjs")
 	},
 	{
 		packageName: "@framefields/node-audio-signal-extractor",
 		ops: ["AudioSignalExtractor"],
-		load: () => import("./renderer-BRjW_pgJ.mjs")
+		load: () => import("./renderer-B6iUuWcx.mjs")
 	},
 	{
 		packageName: "@framefields/node-blur",
 		ops: ["Blur"],
-		load: () => import("./renderer-VCnMXWqE.mjs")
+		load: () => import("./renderer-D9x3UE1Y.mjs")
 	},
 	{
 		packageName: "@framefields/node-camera-parallax-3d",
 		ops: ["CameraParallax3D"],
-		load: () => import("./renderer-BaYEXoS3.mjs")
+		load: () => import("./renderer-C2eBC0FB.mjs")
 	},
 	{
 		packageName: "@framefields/node-canvas-generator",
 		ops: ["CanvasGenerator"],
-		load: () => import("./renderer-CMOAtGdC.mjs")
+		load: () => import("./renderer-Dnm_SVy6.mjs")
 	},
 	{
 		packageName: "@framefields/node-channel-merger",
 		ops: ["ChannelMerger"],
-		load: () => import("./renderer-KcV0gCO5.mjs")
+		load: () => import("./renderer-CPW9o3Lc.mjs")
 	},
 	{
 		packageName: "@framefields/node-channel-splitter",
 		ops: ["ChannelSplitter"],
-		load: () => import("./renderer-Ba7Rc8DE.mjs")
+		load: () => import("./renderer-DkGODUgE.mjs")
 	},
 	{
 		packageName: "@framefields/node-color-balance",
 		ops: ["ColorBalance"],
-		load: () => import("./renderer-BJ_GtjUk.mjs")
+		load: () => import("./renderer-CO4theVJ.mjs")
 	},
 	{
 		packageName: "@framefields/node-colorkey",
 		ops: ["ColorKey"],
-		load: () => import("./renderer-Hf1pCqoN.mjs")
+		load: () => import("./renderer-LmbkN82X.mjs")
 	},
 	{
 		packageName: "@framefields/node-compositor",
 		ops: ["Compositor"],
-		load: () => import("./renderer-BPDita2c.mjs")
+		load: () => import("./renderer-FgcNOe1R.mjs")
 	},
 	{
 		packageName: "@framefields/node-corner-pin",
 		ops: ["CornerPin"],
-		load: () => import("./renderer-DsxhQdCp.mjs")
+		load: () => import("./renderer-DjZiO7iA.mjs")
 	},
 	{
 		packageName: "@framefields/node-crop",
 		ops: ["Crop"],
-		load: () => import("./renderer-BH4j4urG.mjs")
+		load: () => import("./renderer-DcCKath2.mjs")
 	},
 	{
 		packageName: "@framefields/node-curves",
 		ops: ["Curves"],
-		load: () => import("./renderer-D9R8QXS7.mjs")
+		load: () => import("./renderer-BVNhv2ft.mjs")
 	},
 	{
 		packageName: "@framefields/node-deflicker",
 		ops: ["TemporalDeflicker", "Deflicker"],
-		load: () => import("./renderer-C07CnYVd.mjs")
+		load: () => import("./renderer-CVR6T6Lp.mjs")
 	},
 	{
 		packageName: "@framefields/node-displacement-map",
 		ops: ["DisplacementMap"],
-		load: () => import("./renderer-B2-LQreV.mjs")
+		load: () => import("./renderer-CLW6tUUn.mjs")
 	},
 	{
 		packageName: "@framefields/node-extract-frame",
 		ops: ["ExtractFrame"],
-		load: () => import("./renderer-CZ7-42SE.mjs")
+		load: () => import("./renderer-B4cnT3ce.mjs")
 	},
 	{
 		packageName: "@framefields/node-extract-lut",
 		ops: ["ExtractLUT"],
-		load: () => import("./renderer-BXZo84vM.mjs")
+		load: () => import("./renderer-DU6i7shO.mjs")
 	},
 	{
 		packageName: "@framefields/node-film-grain",
 		ops: ["FilmGrain"],
-		load: () => import("./renderer-B6qAMLXh.mjs")
+		load: () => import("./renderer-Diq9Z7gZ.mjs")
 	},
 	{
 		packageName: "@framefields/node-flip",
 		ops: ["Flip"],
-		load: () => import("./renderer-Ceb06HuN.mjs")
+		load: () => import("./renderer-BaXTEIe0.mjs")
 	},
 	{
 		packageName: "@framefields/node-gradient-map",
 		ops: ["GradientMap"],
-		load: () => import("./renderer-hIbXvzPu.mjs")
+		load: () => import("./renderer-ClWgdN2v.mjs")
 	},
 	{
 		packageName: "@framefields/node-halftone-screen",
 		ops: ["HalftoneScreen"],
-		load: () => import("./renderer-D3P5SLcx.mjs")
+		load: () => import("./renderer-DAEXqa2Q.mjs")
 	},
 	{
 		packageName: "@framefields/node-high-pass",
 		ops: ["HighPass"],
-		load: () => import("./renderer-CWK41ajp.mjs")
+		load: () => import("./renderer-BEGJCxuL.mjs")
 	},
 	{
 		packageName: "@framefields/node-kenburns",
 		ops: ["KenBurns"],
-		load: () => import("./renderer-C31qkFvm.mjs")
+		load: () => import("./renderer-BvZg2RJG.mjs")
 	},
 	{
 		packageName: "@framefields/node-layer-style",
 		ops: ["LayerStyle"],
-		load: () => import("./renderer-BVo6W_BO.mjs")
+		load: () => import("./renderer-CUQtKECw.mjs")
 	},
 	{
 		packageName: "@framefields/node-levels",
 		ops: ["Levels"],
-		load: () => import("./renderer-BEfvyxL_.mjs")
+		load: () => import("./renderer-WhpTBwDM.mjs")
 	},
 	{
 		packageName: "@framefields/node-liquify",
 		ops: ["Liquify"],
-		load: () => import("./renderer-3MuT2oZO.mjs")
+		load: () => import("./renderer-DiBphLzn.mjs")
 	},
 	{
 		packageName: "@framefields/node-mask-math",
 		ops: ["MaskMath"],
-		load: () => import("./renderer-C2Z3vJCu.mjs")
+		load: () => import("./renderer-CtUF95UW.mjs")
 	},
 	{
 		packageName: "@framefields/node-mesh-warp",
 		ops: ["MeshWarp"],
-		load: () => import("./renderer-DGAypVNj.mjs")
+		load: () => import("./renderer-CV7_ALA5.mjs")
 	},
 	{
 		packageName: "@framefields/node-modulate",
 		ops: ["Modulate"],
-		load: () => import("./renderer-B2QhkksW.mjs")
+		load: () => import("./renderer-Dtj6o-74.mjs")
 	},
 	{
 		packageName: "@framefields/node-noise-generator",
 		ops: ["NoiseGenerator"],
-		load: () => import("./renderer-BwBc5xNu.mjs")
+		load: () => import("./renderer-CSfLMXN8.mjs")
 	},
 	{
 		packageName: "@framefields/node-paint",
 		ops: ["Paint"],
-		load: () => import("./renderer-DbaTMTuo.mjs")
+		load: () => import("./renderer-SDspl6p-.mjs")
 	},
 	{
 		packageName: "@framefields/node-patch-heal",
 		ops: ["PatchHeal"],
-		load: () => import("./renderer-B8Wjov5-.mjs")
+		load: () => import("./renderer-Dyh8c41v.mjs")
 	},
 	{
 		packageName: "@framefields/node-refine-edge",
 		ops: ["RefineEdge"],
-		load: () => import("./renderer-V0UuIniZ.mjs")
+		load: () => import("./renderer-B3MVDN_e.mjs")
 	},
 	{
 		packageName: "@framefields/node-refraction-caustics",
 		ops: ["RefractionCaustics3D"],
-		load: () => import("./renderer-D9mf-msP.mjs")
+		load: () => import("./renderer-scbJx-Dx.mjs")
 	},
 	{
 		packageName: "@framefields/node-relight-3d",
 		ops: ["Relight3D"],
-		load: () => import("./renderer-CQXszrAF.mjs")
+		load: () => import("./renderer-r4ney0FZ.mjs")
 	},
 	{
 		packageName: "@framefields/node-resizer-scaler",
 		ops: ["ResizerScaler"],
-		load: () => import("./renderer-Cun5J3z9.mjs")
+		load: () => import("./renderer-DppnY7RT.mjs")
 	},
 	{
 		packageName: "@framefields/node-rotate",
 		ops: ["Rotate"],
-		load: () => import("./renderer-C_nPzKwZ.mjs")
+		load: () => import("./renderer-FHqZe3K1.mjs")
 	},
 	{
 		packageName: "@framefields/node-selective-color",
 		ops: ["SelectiveColor"],
-		load: () => import("./renderer-mPDgLBi4.mjs")
+		load: () => import("./renderer-D8ymQoTB.mjs")
 	},
 	{
 		packageName: "@framefields/node-shadows-highlights",
 		ops: ["ShadowsHighlights"],
-		load: () => import("./renderer-BbxBM7Vh.mjs")
+		load: () => import("./renderer-CS-ojgJk.mjs")
 	},
 	{
 		packageName: "@framefields/node-shape-generator",
 		ops: ["ShapeGenerator"],
-		load: () => import("./renderer-D_2Y_tdA.mjs")
+		load: () => import("./renderer-n2kYIGtb.mjs")
 	},
 	{
 		packageName: "@framefields/node-signal-gate",
@@ -476,27 +477,27 @@ const BUILTIN_NODE_RENDERERS = [
 	{
 		packageName: "@framefields/node-stereo-panning",
 		ops: ["StereoPanning"],
-		load: () => import("./renderer-C3FV8cYm.mjs")
+		load: () => import("./renderer-Duaam6bJ.mjs")
 	},
 	{
 		packageName: "@framefields/node-tile-offset",
 		ops: ["TileOffset"],
-		load: () => import("./renderer-Cd6I_dsC.mjs")
+		load: () => import("./renderer-B8IdU-7S.mjs")
 	},
 	{
 		packageName: "@framefields/node-unsharp-mask",
 		ops: ["UnsharpMask"],
-		load: () => import("./renderer-DLAAfwg0.mjs")
+		load: () => import("./renderer-DDhU9Goq.mjs")
 	},
 	{
 		packageName: "@framefields/node-vignette",
 		ops: ["Vignette"],
-		load: () => import("./renderer-AX_fHrXM.mjs")
+		load: () => import("./renderer-9ETXaINw.mjs")
 	},
 	{
 		packageName: "@framefields/node-vision",
 		ops: ["Vision"],
-		load: () => import("./renderer-GSFP7v2z.mjs")
+		load: () => import("./renderer-CZKFEf_6.mjs")
 	}
 ];
 /**
@@ -668,6 +669,163 @@ async function discoverAndRegisterNodeRenderers() {
 		}
 	}
 }
+let nodeAv;
+/**
+* node-av as @mediabunny/server loads it, with software encoders as the
+* default. The patch and the HardwareContext instances returned to the server
+* must come from that exact module instance, so the file is resolved from the
+* server package and imported natively (a `require()` can be routed through
+* a loader such as tsx and produce a second copy).
+*/
+function loadNodeAv() {
+	nodeAv ??= (async () => {
+		const av = await import(pathToFileURL(createRequire(createRequire(import.meta.url).resolve("@mediabunny/server")).resolve("node-av")).href);
+		preferSoftwareEncoders(av);
+		return av;
+	})();
+	return nodeAv;
+}
+/**
+* Software encoders to use per codec, best first. @mediabunny/server takes
+* `Codec.findEncoder(id)` as its software encoder, which returns whichever
+* encoder FFmpeg registered first. In node-av's linux-arm64 build that is a
+* hardware encoder (h264_rkmpp, hevc_rkmpp), which fails without Rockchip
+* hardware.
+*/
+const SOFTWARE_ENCODERS = {
+	AV_CODEC_ID_H264: ["libx264", "libopenh264"],
+	AV_CODEC_ID_HEVC: ["libx265"],
+	AV_CODEC_ID_VP8: ["libvpx"],
+	AV_CODEC_ID_VP9: ["libvpx-vp9"],
+	AV_CODEC_ID_AV1: [
+		"libsvtav1",
+		"libaom-av1",
+		"libdav1d"
+	]
+};
+let patched = false;
+/** Makes `Codec.findEncoder` return a software encoder when one exists. */
+function preferSoftwareEncoders(av) {
+	if (patched) return;
+	patched = true;
+	const byId = /* @__PURE__ */ new Map();
+	for (const [constant, names] of Object.entries(SOFTWARE_ENCODERS)) {
+		const id = av[constant];
+		if (typeof id === "number") byId.set(id, names);
+	}
+	const findEncoder = av.Codec.findEncoder.bind(av.Codec);
+	av.Codec.findEncoder = ((id) => {
+		for (const name of byId.get(id) ?? []) {
+			const codec = av.Codec.findEncoderByName(name);
+			if (codec) return codec;
+		}
+		return findEncoder(id);
+	});
+}
+/**
+* Opens the encoder with the settings @mediabunny/server uses and encodes one
+* frame. A hardware encoder can be compiled in and still be unusable: no such
+* hardware (rkmpp on a non-Rockchip board), or a GPU without an encoder block
+* (NVIDIA A100/H100 have no NVENC).
+*/
+async function encoderWorks(av, codec) {
+	const ctx = new av.CodecContext();
+	const frame = new av.Frame();
+	const packet = new av.Packet();
+	try {
+		ctx.allocContext3(codec);
+		const formats = codec.pixelFormats;
+		const pixelFormat = !formats || formats.includes(av.AV_PIX_FMT_YUV420P) ? av.AV_PIX_FMT_YUV420P : formats[0];
+		ctx.width = 256;
+		ctx.height = 256;
+		ctx.pixelFormat = pixelFormat;
+		ctx.timeBase = new av.Rational(1, 1e6);
+		ctx.framerate = new av.Rational(30, 1);
+		ctx.gopSize = 60;
+		ctx.bitRate = 1000000n;
+		if (await ctx.open2() < 0) return false;
+		frame.alloc();
+		frame.format = pixelFormat;
+		frame.width = 256;
+		frame.height = 256;
+		if (frame.getBuffer() < 0) return false;
+		frame.pts = 0n;
+		packet.alloc();
+		if (await ctx.sendFrame(frame) < 0) return false;
+		if (await ctx.sendFrame(null) < 0) return false;
+		for (;;) {
+			const ret = await ctx.receivePacket(packet);
+			if (ret >= 0) return true;
+			if (ret !== av.AVERROR_EAGAIN) return false;
+		}
+	} catch {
+		return false;
+	} finally {
+		packet.free();
+		frame.free();
+		ctx.freeContext();
+	}
+}
+/** True when the env turns hardware video encoding/decoding off. */
+function hardwareDisabled() {
+	const value = process.env.FRAMEFIELDS_HW_CODECS?.toLowerCase();
+	return value === "0" || value === "off" || value === "false";
+}
+/**
+* Returns the `hardwareContext` option for registerMediabunnyServer: the
+* platform's hardware context for codecs whose hardware encoder actually
+* works (NVENC, VideoToolbox, ...), and null otherwise, so that codec is
+* encoded in software. Each codec is tested once per process.
+*
+* The server calls this before it picks any encoder (unless the encoder is
+* created with "prefer-software"), so the software default is patched in by
+* then.
+*/
+function hardwareContextResolver(forceSoftware) {
+	let hw;
+	const verdicts = /* @__PURE__ */ new Map();
+	const resolve$1 = async (codecId) => {
+		const av = await loadNodeAv();
+		if (forceSoftware || hardwareDisabled()) return null;
+		if (hw === void 0) hw = av.HardwareContext.auto();
+		if (!hw) return null;
+		const encoder = hw.getEncoderCodec(codecId);
+		if (!encoder) return hw;
+		if (await encoderWorks(av, encoder)) {
+			rendererLogger.info({
+				encoder: encoder.name,
+				device: hw.deviceTypeName
+			}, "[video-encoders] Using hardware video encoder");
+			return hw;
+		}
+		rendererLogger.warn({
+			encoder: encoder.name,
+			device: hw.deviceTypeName
+		}, "[video-encoders] Hardware video encoder unusable; encoding in software");
+		return null;
+	};
+	return (codecId) => {
+		let verdict = verdicts.get(codecId);
+		if (!verdict) {
+			verdict = resolve$1(codecId).catch(async (err) => {
+				await loadNodeAv();
+				rendererLogger.warn({ err: err instanceof Error ? err.message : String(err) }, "[video-encoders] Hardware probe failed; encoding in software");
+				return null;
+			});
+			verdicts.set(codecId, verdict);
+		}
+		return verdict;
+	};
+}
+/**
+* Options for registerMediabunnyServer: hardware video codecs when they work,
+* software (libx264, libx265, libvpx, SVT-AV1) otherwise. `forceSoftware`
+* keeps every codec in software (used on AMD). Create encoders with
+* "prefer-hardware" so this decides; "prefer-software" skips it.
+*/
+function videoCodecServerOptions(forceSoftware) {
+	return { hardwareContext: hardwareContextResolver(forceSoftware) };
+}
 const isAMD = () => {
 	if (process.platform !== "linux") return false;
 	try {
@@ -686,16 +844,12 @@ const isAMD = () => {
 	return false;
 };
 const bootstrapMediabunny = () => {
-	const getHardwareContextOption = () => {
-		if (isAMD()) return { hardwareContext: null };
-		return {};
-	};
-	registerMediabunnyServer(getHardwareContextOption());
+	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-D4Uc6ba-.mjs
+//#region ../renderer/dist/headless-webgpu-renderer-D6E4D0cL.mjs
 const DEFAULTS = {
 	blackPixelThreshold: .1,
 	blackFrameRatio: .98,
@@ -1792,7 +1946,7 @@ var HeadlessWebGPURenderer = class HeadlessWebGPURenderer$1 {
 				codec: videoCodec,
 				bitrate: quality,
 				latencyMode: "realtime",
-				hardwareAcceleration: isAMD() ? "prefer-software" : "prefer-hardware"
+				hardwareAcceleration: "prefer-hardware"
 			});
 			output.addVideoTrack(videoSource);
 		}
@@ -1854,6 +2008,7 @@ var HeadlessWebGPURenderer = class HeadlessWebGPURenderer$1 {
 				};
 				await prePass(0);
 				for (let i = 0; i < totalFrames; i++) {
+					options?.signal?.throwIfAborted();
 					if (i % 10 === 0) rendererLogger.info({
 						renderId,
 						frame: i,
@@ -1887,6 +2042,11 @@ var HeadlessWebGPURenderer = class HeadlessWebGPURenderer$1 {
 							isVideoMode: virtualMedia.operation?.dataType === "Video"
 						});
 						await pipeline.enqueueFrame(i, targetTexture, encoder);
+						options?.onProgress?.({
+							phase: "render",
+							frame: i + 1,
+							totalFrames
+						});
 					} else throw new Error("Invalid render context state");
 				}
 				if (pipeline) {
@@ -1900,6 +2060,12 @@ 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);
 			const numChannels = channels.length;
 			if (numChannels === 0) throw new Error("mixAudioTracks returned no channels");
@@ -1923,6 +2089,7 @@ var HeadlessWebGPURenderer = class HeadlessWebGPURenderer$1 {
 					sample.close();
 				}
 			}
+			options?.signal?.throwIfAborted();
 			await output.finalize();
 			outputFinalized = true;
 			const qa = qaOptions ? buildQaReport({
@@ -1997,6 +2164,23 @@ var HeadlessWebGPURenderer = class HeadlessWebGPURenderer$1 {
 };
 const HeadlessMediaRenderer = HeadlessWebGPURenderer;
 
+//#endregion
+//#region ../renderer/dist/index.mjs
+/**
+* Drops every cache keyed by a file path or URL: media inputs and decoders,
+* textures, LUTs and fonts. A long-lived worker calls this between jobs,
+* because the next checkout may hold different bytes at the same path. The
+* GPU device and compiled pipelines stay warm.
+*/
+function resetRenderCaches() {
+	clearAllVideoCache();
+	mediaDecoderCache.destroy();
+	textureCache.destroy();
+	inputStore.clear();
+	lutStore.destroy();
+	SlugFontCache.destroy();
+}
+
 //#endregion
 //#region src/renderer/framegrid.ts
 /**
@@ -2169,5 +2353,5 @@ async function renderFrameGrid(target, options = {}) {
 }
 
 //#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-B6x_Mmpf.mjs.map
+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-DzDZlez7.mjs.map