gitframes 1.2.35

package/dist/dist-CMF9eNLB.mjs

@@ -0,0 +1,4062 @@
+import { A as drawCaptionNode, C as SlugGeometry, F as drawParagraphNode, I as drawSignalNode, J as lutStore, L as drawSvgNode, M as drawGifNode, N as drawImageNode, O as clearVideoNodeState, P as drawLottieNode, R as drawVideoNode, S as SlugFontCache, W as inputStore, Y as mediaDecoderCache, at as GetFontAssetUrl, ct as resolveMediaSourceUrl, et as registerHeadlessFont, it as useRenderContext, nt as signalRegistry, st as getEnv, tt as shaderStore } from "./dist-C37594c6.mjs";
+import { nanoid } from "nanoid";
+import z$1, { z } from "zod";
+import { AudioSample, AudioSampleSink, AudioSampleSource, Mp3OutputFormat, Mp4OutputFormat, Output, QUALITY_VERY_HIGH, VideoSample, VideoSampleSource, WebMOutputFormat, canEncodeAudio } from "mediabunny";
+import React, { createContext, memo, useCallback, useContext, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { registerMp3Encoder } from "@mediabunny/mp3-encoder";
+
+//#region ../core/dist/index.mjs
+var ProgrammaticSignal = class ProgrammaticSignal$1 {
+	gpuBinding;
+	label;
+	_evaluator;
+	_samples;
+	_fps;
+	_durationFrames;
+	_cachedFrame = -1;
+	_cachedValue = 0;
+	_seekedFrame = -1;
+	_subscribers = /* @__PURE__ */ new Set();
+	_children = /* @__PURE__ */ new Set();
+	get fps() {
+		return this._fps;
+	}
+	constructor(source, options = {}) {
+		this._fps = options.fps ?? 24;
+		this._durationFrames = options.durationFrames;
+		this.gpuBinding = options.gpuBinding;
+		this.label = options.label;
+		if (typeof source === "number") {
+			const constVal = source;
+			this._evaluator = () => constVal;
+			this._cachedValue = constVal;
+		} else if (typeof source === "function") this._evaluator = source;
+		else if (isSignal(source)) this._evaluator = (ctx) => Number(source.get(ctx)) || 0;
+		else {
+			const arr = source;
+			this._samples = arr instanceof Float32Array ? arr : new Float32Array(Array.from(arr));
+			this._durationFrames = this._samples.length;
+			this._cachedValue = this._samples.length > 0 ? this._samples[0] : 0;
+			this._evaluator = (ctx) => {
+				if (!this._samples || this._samples.length === 0) return 0;
+				const compFps = ctx.fps ?? this._fps;
+				const targetFrame = compFps !== this._fps && compFps > 0 ? ctx.frame / compFps * this._fps : ctx.frame;
+				const idx = Math.max(0, Math.min(this._samples.length - 1, Math.round(targetFrame)));
+				return this._samples[idx];
+			};
+		}
+	}
+	get value() {
+		return this.get();
+	}
+	get(ctx) {
+		registerSignalDependency(this._subscribers);
+		frameSignal.get();
+		const currentFrame = ctx?.frame ?? (this._seekedFrame >= 0 ? this._seekedFrame : frameSignal.value);
+		if (this._cachedFrame === currentFrame) return this._cachedValue;
+		const fps = ctx?.fps ?? this._fps;
+		const time = ctx?.time ?? (fps > 0 ? currentFrame / fps : 0);
+		const duration = ctx?.duration ?? this._durationFrames ?? 100;
+		const resolvedCtx = {
+			frame: currentFrame,
+			fps,
+			time,
+			duration,
+			durationMs: ctx?.durationMs ?? duration / fps * 1e3,
+			progress: duration > 0 ? currentFrame / duration : 0,
+			deltaTime: ctx?.deltaTime ?? (fps > 0 ? 1 / fps : .0416)
+		};
+		this._cachedFrame = currentFrame;
+		this._cachedValue = this._evaluator(resolvedCtx);
+		return this._cachedValue;
+	}
+	peek() {
+		return this._cachedValue;
+	}
+	registerChild(child) {
+		this._children.add(child);
+	}
+	_derive(evaluator, options, other) {
+		const child = new ProgrammaticSignal$1(evaluator, {
+			fps: this._fps,
+			durationFrames: this._durationFrames,
+			...options
+		});
+		this._children.add(child);
+		if (other instanceof ProgrammaticSignal$1) other.registerChild(child);
+		return child;
+	}
+	seekFrame(frame) {
+		this._seekedFrame = frame;
+		this._cachedFrame = -1;
+		for (const sub of this._subscribers) sub.markDirty();
+		for (const child of this._children) child.seekFrame(frame);
+	}
+	invalidate() {
+		this._cachedFrame = -1;
+		for (const sub of this._subscribers) sub.markDirty();
+		for (const child of this._children) child.invalidate();
+	}
+	valueOf() {
+		return this.get();
+	}
+	[Symbol.toPrimitive](hint) {
+		if (hint === "number") return Number(this.get());
+		if (hint === "string") return String(this.get());
+		return this.get();
+	}
+	smooth(windowFrames) {
+		const window$1 = Math.max(1, Math.round(windowFrames));
+		if (window$1 <= 1) return this;
+		return this._derive((ctx) => {
+			let sum = 0;
+			let count = 0;
+			const startF = Math.max(0, ctx.frame - window$1 + 1);
+			for (let f = startF; f <= ctx.frame; f++) {
+				sum += this.get({
+					...ctx,
+					frame: f,
+					time: f / ctx.fps
+				});
+				count++;
+			}
+			return count > 0 ? sum / count : 0;
+		}, { label: `${this.label ?? "sig"}_smoothed(${window$1})` });
+	}
+	remap(inMin, inMax, outMin, outMax, clamp = false) {
+		const inRange = inMax - inMin;
+		const outRange = outMax - outMin;
+		return this._derive((ctx) => {
+			const val = this.get(ctx);
+			const remapped = outMin + (inRange !== 0 ? (val - inMin) / inRange : 0) * outRange;
+			if (clamp) {
+				const lo = Math.min(outMin, outMax);
+				const hi = Math.max(outMin, outMax);
+				return Math.max(lo, Math.min(hi, remapped));
+			}
+			return remapped;
+		}, { label: `${this.label ?? "sig"}_remap` });
+	}
+	clamp(min, max) {
+		const lo = Math.min(min, max);
+		const hi = Math.max(min, max);
+		return this._derive((ctx) => Math.max(lo, Math.min(hi, this.get(ctx))), { label: `${this.label ?? "sig"}_clamped` });
+	}
+	gate(threshold, options = {}) {
+		const mode = options.mode ?? "gate";
+		const debounce = Math.max(1, options.debounceFrames ?? 2);
+		const hold = Math.max(1, options.holdFrames ?? 4);
+		const invert = Boolean(options.invert);
+		return this._derive((ctx) => {
+			const currentF = ctx.frame;
+			let out = 0;
+			if (mode === "gate") out = this.get(ctx) >= threshold ? 1 : 0;
+			else if (mode === "trigger") {
+				let lastTrigger = -Infinity;
+				const startF = Math.max(0, currentF - 120);
+				for (let f = startF; f <= currentF; f++) {
+					const v = this.get({
+						...ctx,
+						frame: f,
+						time: f / ctx.fps
+					});
+					const prev = f > 0 ? this.get({
+						...ctx,
+						frame: f - 1,
+						time: (f - 1) / ctx.fps
+					}) : 0;
+					if (v >= threshold && prev < threshold && f - lastTrigger >= debounce) lastTrigger = f;
+				}
+				out = currentF >= lastTrigger && currentF < lastTrigger + hold ? 1 : 0;
+			} else if (mode === "toggle") {
+				let toggleCount = 0;
+				let lastTrigger = -Infinity;
+				for (let f = 0; f <= currentF; f++) {
+					const v = this.get({
+						...ctx,
+						frame: f,
+						time: f / ctx.fps
+					});
+					const prev = f > 0 ? this.get({
+						...ctx,
+						frame: f - 1,
+						time: (f - 1) / ctx.fps
+					}) : 0;
+					if (v >= threshold && prev < threshold && f - lastTrigger >= debounce) {
+						toggleCount++;
+						lastTrigger = f;
+					}
+				}
+				out = toggleCount % 2 === 1 ? 1 : 0;
+			}
+			return invert ? 1 - out : out;
+		}, { label: `${this.label ?? "sig"}_gate(${threshold})` });
+	}
+	velocity(dt = 1) {
+		const step = Math.max(1, Math.round(dt));
+		return this._derive((ctx) => {
+			const curr = this.get(ctx);
+			const prevF = Math.max(0, ctx.frame - step);
+			const prev = this.get({
+				...ctx,
+				frame: prevF,
+				time: prevF / ctx.fps
+			});
+			const deltaSec = step / ctx.fps;
+			return deltaSec > 0 ? (curr - prev) / deltaSec : curr - prev;
+		}, { label: `${this.label ?? "sig"}_velocity` });
+	}
+	delay(frames) {
+		const shift = Math.max(0, Math.round(frames));
+		return this._derive((ctx) => {
+			const delayedF = Math.max(0, ctx.frame - shift);
+			return this.get({
+				...ctx,
+				frame: delayedF,
+				time: delayedF / ctx.fps
+			});
+		}, { label: `${this.label ?? "sig"}_delay(${shift})` });
+	}
+	spring(stiffness = 150, damping = 12) {
+		return this._derive((ctx) => {
+			const targetFrame = ctx.frame;
+			if (targetFrame <= 0) return this.get(ctx);
+			let pos = this.get({
+				...ctx,
+				frame: 0,
+				time: 0
+			});
+			let vel = 0;
+			const dt = 1 / Math.max(1, ctx.fps);
+			for (let f = 1; f <= targetFrame; f++) {
+				const targetVal = this.get({
+					...ctx,
+					frame: f,
+					time: f / ctx.fps
+				});
+				const displacement = pos - targetVal;
+				const force = -stiffness * displacement - damping * vel;
+				vel += force * dt;
+				pos += vel * dt;
+			}
+			return pos;
+		}, { label: `${this.label ?? "sig"}_spring` });
+	}
+	add(other) {
+		if (typeof other === "number") return this._derive((ctx) => this.get(ctx) + other);
+		return this._derive((ctx) => this.get(ctx) + (Number(other.get(ctx)) || 0), void 0, other);
+	}
+	subtract(other) {
+		if (typeof other === "number") return this._derive((ctx) => this.get(ctx) - other);
+		return this._derive((ctx) => this.get(ctx) - (Number(other.get(ctx)) || 0), void 0, other);
+	}
+	multiply(factor) {
+		if (typeof factor === "number") return this._derive((ctx) => this.get(ctx) * factor);
+		return this._derive((ctx) => this.get(ctx) * (Number(factor.get(ctx)) || 0), void 0, factor);
+	}
+	invert() {
+		return this._derive((ctx) => 1 - this.get(ctx), { label: `${this.label ?? "sig"}_inverted` });
+	}
+	pow(exponent) {
+		return this._derive((ctx) => this.get(ctx) ** exponent);
+	}
+	map(fn) {
+		return this._derive((ctx) => fn(this.get(ctx), ctx));
+	}
+	toFrameArray(totalFrames, fps) {
+		const count = Math.max(1, totalFrames);
+		const f = fps ?? this._fps;
+		const out = new Float32Array(count);
+		for (let i = 0; i < count; i++) out[i] = this.get({
+			frame: i,
+			fps: f,
+			time: i / f,
+			duration: count,
+			durationMs: count / f * 1e3,
+			progress: i / count,
+			deltaTime: 1 / f
+		});
+		return out;
+	}
+};
+function programmaticSignal(source, options) {
+	return new ProgrammaticSignal(source, options);
+}
+let activeComputed = null;
+function registerSignalDependency(subscribers) {
+	if (activeComputed !== null) {
+		subscribers.add(activeComputed);
+		activeComputed.deps.add(subscribers);
+	}
+}
+function isSignal(val) {
+	return val !== null && typeof val === "object" && "get" in val && typeof val.get === "function" && "value" in val;
+}
+var StateSignalImpl = class {
+	_value;
+	_subscribers = /* @__PURE__ */ new Set();
+	constructor(initialValue) {
+		this._value = initialValue;
+	}
+	get value() {
+		return this.get();
+	}
+	set value(nextValue) {
+		this.set(nextValue);
+	}
+	get() {
+		if (activeComputed !== null) {
+			this._subscribers.add(activeComputed);
+			activeComputed.deps.add(this._subscribers);
+		}
+		return this._value;
+	}
+	peek() {
+		return this._value;
+	}
+	set(nextValue) {
+		if (Object.is(this._value, nextValue)) return;
+		this._value = nextValue;
+		this.notifySubscribers();
+	}
+	update(fn) {
+		this.set(fn(this._value));
+	}
+	notifySubscribers() {
+		if (this._subscribers.size === 0) return;
+		const toNotify = Array.from(this._subscribers);
+		for (const sub of toNotify) sub.markDirty();
+	}
+	valueOf() {
+		return this.get();
+	}
+	[Symbol.toPrimitive](hint) {
+		if (hint === "number") return Number(this.get());
+		if (hint === "string") return String(this.get());
+		return this.get();
+	}
+};
+var ComputedImpl = class {
+	_fn;
+	_value;
+	_dirty = true;
+	_evaluating = false;
+	deps = /* @__PURE__ */ new Set();
+	_subscribers = /* @__PURE__ */ new Set();
+	constructor(fn) {
+		this._fn = fn;
+	}
+	get value() {
+		return this.get();
+	}
+	get() {
+		if (activeComputed !== null && activeComputed !== this) {
+			this._subscribers.add(activeComputed);
+			activeComputed.deps.add(this._subscribers);
+		}
+		if (this._dirty) this.compute();
+		return this._value;
+	}
+	peek() {
+		if (this._dirty) this.compute();
+		return this._value;
+	}
+	markDirty() {
+		if (this._dirty) return;
+		this._dirty = true;
+		const toNotify = Array.from(this._subscribers);
+		for (const sub of toNotify) sub.markDirty();
+	}
+	compute() {
+		if (this._evaluating) throw new Error("Cyclic dependency detected in computed signal");
+		for (const depSubSet of this.deps) depSubSet.delete(this);
+		this.deps.clear();
+		const prevActive = activeComputed;
+		activeComputed = this;
+		this._evaluating = true;
+		try {
+			this._value = this._fn();
+			this._dirty = false;
+		} finally {
+			this._evaluating = false;
+			activeComputed = prevActive;
+		}
+	}
+	valueOf() {
+		return this.get();
+	}
+	[Symbol.toPrimitive](hint) {
+		if (hint === "number") return Number(this.get());
+		if (hint === "string") return String(this.get());
+		return this.get();
+	}
+};
+var FrameArraySignalImpl = class {
+	gpuBinding;
+	fps;
+	_samples;
+	_cachedFrame = -1;
+	_cachedValue = 0;
+	_seekedFrame = -1;
+	_subscribers = /* @__PURE__ */ new Set();
+	constructor(samples, fps = 24, gpuBinding) {
+		this._samples = samples;
+		this.fps = fps;
+		this.gpuBinding = gpuBinding;
+		if (samples.length > 0) this._cachedValue = samples[0];
+	}
+	get value() {
+		return this.get();
+	}
+	get(ctx) {
+		if (activeComputed !== null) {
+			this._subscribers.add(activeComputed);
+			activeComputed.deps.add(this._subscribers);
+		}
+		frameSignal.get();
+		const currentFrame = ctx?.frame ?? (this._seekedFrame >= 0 ? this._seekedFrame : frameSignal.value);
+		if (this._cachedFrame === currentFrame) return this._cachedValue;
+		this._cachedFrame = currentFrame;
+		if (!this._samples || this._samples.length === 0) {
+			this._cachedValue = 0;
+			return 0;
+		}
+		const compFps = ctx?.fps ?? this.fps;
+		const targetFrame = compFps !== this.fps && compFps > 0 ? currentFrame / compFps * this.fps : currentFrame;
+		const idx = Math.max(0, Math.min(this._samples.length - 1, Math.round(targetFrame)));
+		this._cachedValue = Number(this._samples[idx]) || 0;
+		return this._cachedValue;
+	}
+	peek() {
+		return this._cachedValue;
+	}
+	seekFrame(frame) {
+		this._seekedFrame = frame;
+		this._cachedFrame = frame;
+		if (!this._samples || this._samples.length === 0) this._cachedValue = 0;
+		else {
+			const idx = Math.max(0, Math.min(this._samples.length - 1, Math.round(frame)));
+			this._cachedValue = Number(this._samples[idx]) || 0;
+		}
+		for (const sub of this._subscribers) sub.markDirty();
+	}
+	valueOf() {
+		return this.get();
+	}
+	[Symbol.toPrimitive](hint) {
+		if (hint === "number") return Number(this.get());
+		if (hint === "string") return String(this.get());
+		return this.get();
+	}
+};
+function signal(initialValue) {
+	return new StateSignalImpl(initialValue);
+}
+function computed(fn) {
+	return new ComputedImpl(fn);
+}
+function frameArraySignal(samples, fps = 24, gpuBinding) {
+	return new FrameArraySignalImpl(samples, fps, gpuBinding);
+}
+const frameSignal = signal(0);
+const timeSignal = signal(0);
+const progressSignal = signal(0);
+function updateClockSignals(frame, fps = 24, durationMs) {
+	frameSignal.set(frame);
+	const timeSec = fps > 0 ? frame / fps : 0;
+	timeSignal.set(timeSec);
+	if (durationMs && durationMs > 0) {
+		const durSec = durationMs / 1e3;
+		progressSignal.set(Math.max(0, Math.min(1, timeSec / durSec)));
+	} else progressSignal.set(0);
+}
+var ProceduralSignalImpl = class {
+	gpuBinding;
+	_config;
+	constructor(config) {
+		this._config = {
+			type: "sine",
+			frequency: 1,
+			amplitude: 1,
+			offset: 0,
+			phase: 0,
+			...config
+		};
+		this.gpuBinding = config.gpuBinding;
+	}
+	get value() {
+		return this.get();
+	}
+	get(ctx) {
+		frameSignal.get();
+		const frame = ctx?.frame ?? frameSignal.value;
+		const fps = ctx?.fps ?? 24;
+		const time = ctx?.time ?? (fps > 0 ? frame / fps : 0);
+		if (this._config.fn) return this._config.fn(ctx ?? {
+			frame,
+			fps,
+			time,
+			duration: 0,
+			durationMs: 0,
+			progress: 0,
+			deltaTime: fps > 0 ? 1 / fps : 0
+		});
+		const freq = this._config.frequency ?? 1;
+		const amp = this._config.amplitude ?? 1;
+		const off = this._config.offset ?? 0;
+		const phase = this._config.phase ?? 0;
+		switch (this._config.type ?? "sine") {
+			case "sine": return off + amp * Math.sin(2 * Math.PI * freq * time + phase);
+			case "triangle": return off + amp * (2 * Math.abs(2 * (time * freq + phase / (2 * Math.PI) - Math.floor(time * freq + phase / (2 * Math.PI) + .5))) - 1);
+			case "sawtooth": return off + amp * (2 * (time * freq + phase / (2 * Math.PI) - Math.floor(time * freq + phase / (2 * Math.PI) + .5)));
+			case "square": return off + (Math.sin(2 * Math.PI * freq * time + phase) >= 0 ? amp : -amp);
+			case "bounce": {
+				const cycle = time * freq % 1;
+				return off + amp * Math.abs(Math.sin(Math.PI * cycle));
+			}
+			default: return off + amp * Math.sin(2 * Math.PI * freq * time + phase);
+		}
+	}
+	peek() {
+		return this.get();
+	}
+	valueOf() {
+		return this.get();
+	}
+	[Symbol.toPrimitive](hint) {
+		if (hint === "number") return Number(this.get());
+		if (hint === "string") return String(this.get());
+		return this.get();
+	}
+};
+function signalBuilder(config) {
+	return new ProceduralSignalImpl(config);
+}
+function sineSignal(options = {}) {
+	const min = options.min;
+	const max = options.max;
+	let amplitude = options.amplitude ?? 1;
+	let offset = options.offset ?? 0;
+	if (min !== void 0 && max !== void 0) {
+		offset = (min + max) / 2;
+		amplitude = (max - min) / 2;
+	} else if (min !== void 0) offset = min + amplitude;
+	else if (max !== void 0) offset = max - amplitude;
+	const period = options.period;
+	const frequency = options.frequency;
+	const phase = options.phase ?? 0;
+	return signalBuilder({
+		type: "custom",
+		fn: (ctx) => {
+			let angle;
+			if (period !== void 0 && period > 0) angle = 2 * Math.PI * ctx.frame / period + phase;
+			else {
+				const freq = frequency ?? 1;
+				angle = 2 * Math.PI * freq * ctx.time + phase;
+			}
+			return offset + amplitude * Math.sin(angle);
+		}
+	});
+}
+function cosineSignal(options = {}) {
+	const min = options.min;
+	const max = options.max;
+	let amplitude = options.amplitude ?? 1;
+	let offset = options.offset ?? 0;
+	if (min !== void 0 && max !== void 0) {
+		offset = (min + max) / 2;
+		amplitude = (max - min) / 2;
+	} else if (min !== void 0) offset = min + amplitude;
+	else if (max !== void 0) offset = max - amplitude;
+	const period = options.period;
+	const frequency = options.frequency;
+	const phase = options.phase ?? 0;
+	return signalBuilder({
+		type: "custom",
+		fn: (ctx) => {
+			let angle;
+			if (period !== void 0 && period > 0) angle = 2 * Math.PI * ctx.frame / period + phase;
+			else {
+				const freq = frequency ?? 1;
+				angle = 2 * Math.PI * freq * ctx.time + phase;
+			}
+			return offset + amplitude * Math.cos(angle);
+		}
+	});
+}
+const Signal = {
+	state: signal,
+	computed,
+	builder: signalBuilder,
+	fromArray: frameArraySignal,
+	programmatic: programmaticSignal,
+	frame: frameSignal,
+	time: timeSignal,
+	progress: progressSignal,
+	sine: sineSignal,
+	cosine: cosineSignal
+};
+var Effect = class {
+	signals;
+	config;
+	_frameHooks = [];
+	constructor(initialConfig) {
+		this.config = { ...initialConfig };
+		this.signals = {};
+		for (const [key, val] of Object.entries(initialConfig)) if (isSignal(val)) this.signals[key] = val;
+		else this.signals[key] = signal(val);
+		return new Proxy(this, {
+			get(target, prop, receiver) {
+				if (typeof prop === "string" && prop in target.signals) {
+					const sig = target.signals[prop];
+					return sig ? sig.value : void 0;
+				}
+				return Reflect.get(target, prop, receiver);
+			},
+			set(target, prop, val, receiver) {
+				if (typeof prop === "string" && prop in target.signals) {
+					const currentSig = target.signals[prop];
+					if (isSignal(val)) {
+						target.signals[prop] = val;
+						target.config[prop] = val;
+					} else if (currentSig && typeof currentSig.set === "function") {
+						currentSig.set(val);
+						target.config[prop] = val;
+					} else {
+						target.signals[prop] = signal(val);
+						target.config[prop] = val;
+					}
+					return true;
+				}
+				return Reflect.set(target, prop, val, receiver);
+			}
+		});
+	}
+	/**
+	* Game-engine per-frame lifecycle hook.
+	* Invoked before rendering each frame so scripts or agents can mutate properties.
+	*/
+	onRequestFrame(callback) {
+		this._frameHooks.push(callback);
+		return this;
+	}
+	notifyFrame(ctx) {
+		for (const hook of this._frameHooks) hook(ctx);
+	}
+	/**
+	* Samples concrete scalar / config values for the current frame.
+	*/
+	resolveUniforms(ctx) {
+		const out = {};
+		for (const [k, sig] of Object.entries(this.signals)) out[k] = sig.get(ctx);
+		return out;
+	}
+	/**
+	* Returns WebGPU texture bindings attached to any property signal.
+	*/
+	resolveTextures() {
+		const out = {};
+		for (const [k, sig] of Object.entries(this.signals)) {
+			const gpu = sig.gpuBinding;
+			if (gpu?.textureView) out[`${k}TextureView`] = gpu.textureView;
+			if (gpu?.texture) out[`${k}Texture`] = gpu.texture;
+		}
+		return out;
+	}
+	/**
+	* Converts the effect into an operation node for the VirtualMediaData AST.
+	*/
+	toOperation() {
+		const opPayload = {
+			op: this.op,
+			effect: this,
+			onRequestFrame: (ctx) => this.notifyFrame(ctx),
+			signals: this.signals,
+			...this.config
+		};
+		for (const [k, sig] of Object.entries(this.signals)) {
+			const orig = this.config[k];
+			if (!isSignal(orig) && (typeof orig === "string" || typeof orig === "boolean")) opPayload[k] = sig.value;
+			else opPayload[k] = sig;
+		}
+		return opPayload;
+	}
+};
+var ModerationError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ModerationError";
+	}
+};
+var ModerationUnrefundableError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ModerationUnrefundableError";
+	}
+};
+/**
+* Generates a unique ID using nanoid.
+* This function is cross-platform compatible (Node.js and Browser).
+*
+* @param size - Optional size of the ID (default is 21)
+* @returns A unique string ID
+*/
+const generateId = (size) => {
+	return nanoid(size);
+};
+const HandleDefinitionSchema = z$1.object({
+	dataTypes: z$1.custom(),
+	label: z$1.string(),
+	required: z$1.boolean().optional(),
+	order: z$1.number(),
+	description: z$1.string().optional()
+});
+const ConfigHandleSchema = z$1.object({
+	configKey: z$1.string(),
+	dataTypes: z$1.custom(),
+	label: z$1.string(),
+	description: z$1.string().optional()
+});
+/**
+* Metadata defining the interface and identity of a node.
+* This is safe to import in any environment.
+*/
+const NodeMetadataSchema = z$1.object({
+	type: z$1.string().min(1),
+	version: z$1.number().int().positive().optional(),
+	baseType: z$1.string().optional(),
+	displayName: z$1.string().min(1),
+	description: z$1.string().optional(),
+	showInQuickAccess: z$1.boolean().optional(),
+	showInSidebar: z$1.boolean().optional(),
+	advanced: z$1.boolean().optional(),
+	category: z$1.string().min(1),
+	subcategory: z$1.string().optional(),
+	defaultDimensions: z$1.object({
+		width: z$1.number().positive().optional(),
+		height: z$1.number().positive().optional()
+	}).optional(),
+	handles: z$1.object({
+		inputs: z$1.array(HandleDefinitionSchema),
+		outputs: z$1.array(HandleDefinitionSchema)
+	}),
+	variableInputs: z$1.discriminatedUnion("enabled", [z$1.object({
+		enabled: z$1.literal(true),
+		dataTypes: z$1.custom()
+	}), z$1.object({
+		enabled: z$1.literal(false),
+		dataTypes: z$1.custom().optional()
+	})]).optional(),
+	variableOutputs: z$1.discriminatedUnion("enabled", [z$1.object({
+		enabled: z$1.literal(true),
+		dataTypes: z$1.custom()
+	}), z$1.object({
+		enabled: z$1.literal(false),
+		dataTypes: z$1.custom().optional()
+	})]).optional(),
+	isTerminal: z$1.boolean().optional(),
+	isTransient: z$1.boolean().optional(),
+	configSchema: z$1.custom().optional(),
+	defaultConfig: z$1.record(z$1.string(), z$1.unknown()).optional(),
+	validation: z$1.any().optional(),
+	resultSchema: z$1.custom().optional(),
+	configHandles: z$1.array(ConfigHandleSchema).optional()
+});
+const DataTypeVal = {
+	Text: "Text",
+	Number: "Number",
+	Boolean: "Boolean",
+	Image: "Image",
+	Video: "Video",
+	Audio: "Audio",
+	SVG: "SVG",
+	Caption: "Caption",
+	Lottie: "Lottie",
+	ThreeD: "ThreeD",
+	GIF: "GIF",
+	Signal: "Signal",
+	LUT: "LUT"
+};
+const DataType = DataTypeVal;
+const DataTypes = Object.values(DataTypeVal);
+const HandleTypeVal = {
+	Input: "Input",
+	Output: "Output"
+};
+const JsonValueSchema = z$1.lazy(() => z$1.union([
+	z$1.string(),
+	z$1.number(),
+	z$1.boolean(),
+	z$1.null(),
+	z$1.array(JsonValueSchema),
+	z$1.record(z$1.string(), JsonValueSchema.optional())
+]));
+/**
+* Zod schema for the FileAsset model
+* Matches the Prisma schema definitions for types and nullability.
+*/
+const FileAssetSchema = z$1.object({
+	id: z$1.cuid2(),
+	name: z$1.string(),
+	createdAt: z$1.coerce.date(),
+	updatedAt: z$1.coerce.date(),
+	userId: z$1.cuid2().nullable(),
+	width: z$1.number().int().nullable(),
+	height: z$1.number().int().nullable(),
+	bucket: z$1.string(),
+	size: z$1.number().int(),
+	mimeType: z$1.string(),
+	key: z$1.string(),
+	isUploaded: z$1.boolean().default(true),
+	duration: z$1.number().int().nullable(),
+	sampleRate: z$1.number().int().nullable().optional(),
+	channels: z$1.number().int().nullable().optional(),
+	bitDepth: z$1.number().int().nullable().optional(),
+	audioCodec: z$1.string().nullable().optional(),
+	audioBitrate: z$1.number().int().nullable().optional(),
+	fps: z$1.number().int().nullable(),
+	fingerprint: z$1.string().nullable()
+});
+const NodeVisualConfigSchema = z$1.object({
+	position: z$1.object({
+		x: z$1.number(),
+		y: z$1.number()
+	}).optional(),
+	width: z$1.number().nullish(),
+	height: z$1.number().nullish(),
+	locked: z$1.boolean().optional().default(false),
+	collapsed: z$1.boolean().optional().default(false)
+}).passthrough();
+const dataTypeColors = {
+	Text: {
+		bg: "bg-blue-500",
+		stroke: "stroke-blue-500",
+		hex: "#3b82f6",
+		text: "text-blue-500",
+		border: "border-blue-500"
+	},
+	Image: {
+		bg: "bg-purple-500",
+		stroke: "stroke-purple-500",
+		hex: "#a855f7",
+		text: "text-purple-500",
+		border: "border-purple-500"
+	},
+	Video: {
+		bg: "bg-teal-500",
+		stroke: "stroke-teal-500",
+		hex: "oklch(60% 0.118 184.704)",
+		text: "text-teal-500",
+		border: "border-teal-500"
+	},
+	Audio: {
+		bg: "bg-orange-500",
+		stroke: "stroke-orange-500",
+		hex: "#f97316",
+		text: "text-orange-500",
+		border: "border-orange-500"
+	},
+	Number: {
+		bg: "bg-green-600",
+		stroke: "stroke-green-600",
+		hex: "#16a34a",
+		text: "text-green-600",
+		border: "border-green-600"
+	},
+	Boolean: {
+		bg: "bg-amber-600",
+		stroke: "stroke-amber-600",
+		hex: "#d97706",
+		text: "text-amber-600",
+		border: "border-amber-600"
+	},
+	SVG: {
+		bg: "bg-lime-600",
+		stroke: "stroke-lime-600",
+		hex: "#65a30d",
+		text: "text-lime-600",
+		border: "border-lime-600"
+	},
+	Caption: {
+		bg: "bg-rose-500",
+		stroke: "stroke-rose-500",
+		hex: "#f43f5e",
+		text: "text-rose-500",
+		border: "border-rose-500"
+	},
+	GIF: {
+		bg: "bg-pink-500",
+		stroke: "stroke-pink-500",
+		hex: "#ec4899",
+		text: "text-pink-500",
+		border: "border-pink-500"
+	},
+	Lottie: {
+		bg: "bg-indigo-500",
+		stroke: "stroke-indigo-500",
+		hex: "#6366f1",
+		text: "text-indigo-500",
+		border: "border-indigo-500"
+	},
+	Signal: {
+		bg: "bg-fuchsia-500",
+		stroke: "stroke-fuchsia-500",
+		hex: "#d946ef",
+		text: "text-fuchsia-500",
+		border: "border-fuchsia-500"
+	},
+	LUT: {
+		bg: "bg-cyan-600",
+		stroke: "stroke-cyan-600",
+		hex: "#0891b2",
+		text: "text-cyan-600",
+		border: "border-cyan-600"
+	}
+};
+const DATA_TYPE_EXTENSIONS = {
+	Image: "png",
+	Video: "mp4",
+	Audio: "mp3",
+	Text: "txt",
+	Number: "txt",
+	Boolean: "txt",
+	SVG: "svg",
+	Caption: "srt",
+	Lottie: "json",
+	ThreeD: "glb",
+	GIF: "gif",
+	Signal: "txt",
+	LUT: "cube"
+};
+const MIME_TYPES = {
+	png: "image/png",
+	jpg: "image/jpeg",
+	jpeg: "image/jpeg",
+	gif: "image/gif",
+	webp: "image/webp",
+	svg: "image/svg+xml",
+	mp4: "video/mp4",
+	webm: "video/webm",
+	mov: "video/quicktime",
+	mp3: "audio/mpeg",
+	wav: "audio/wav",
+	ogg: "audio/ogg",
+	pdf: "application/pdf",
+	json: "application/json",
+	txt: "text/plain",
+	srt: "text/srt",
+	aac: "audio/aac",
+	flac: "audio/flac"
+};
+const COMPOSITE_OPERATIONS$1 = [
+	"source-over",
+	"source-in",
+	"source-out",
+	"source-atop",
+	"destination-over",
+	"destination-in",
+	"destination-out",
+	"destination-atop",
+	"lighter",
+	"copy",
+	"xor",
+	"multiply",
+	"screen",
+	"overlay",
+	"darken",
+	"lighten",
+	"color-dodge",
+	"color-burn",
+	"hard-light",
+	"soft-light",
+	"difference",
+	"exclusion",
+	"hue",
+	"saturation",
+	"color",
+	"luminosity"
+];
+const GlobalCompositeOperation$1 = z.enum(COMPOSITE_OPERATIONS$1);
+var ConfigSchemaRegistry = class ConfigSchemaRegistry$1 {
+	static schemas = /* @__PURE__ */ new Map();
+	static register(type, schema) {
+		ConfigSchemaRegistry$1.schemas.set(type, schema);
+	}
+	static get(type) {
+		return ConfigSchemaRegistry$1.schemas.get(type);
+	}
+	static clear() {
+		ConfigSchemaRegistry$1.schemas.clear();
+	}
+};
+const COMPOSITOR_DEFAULTS = {
+	FONT_FAMILY: "Inter",
+	FONT_SIZE: 64,
+	FILL: "#ffffff",
+	LINE_HEIGHT: 1.1,
+	ALIGN: "left",
+	VERTICAL_ALIGN: "top",
+	LETTER_SPACING: 0,
+	STROKE_WIDTH: 0,
+	STROKE: "#000000",
+	CORNER_RADIUS: 0,
+	PADDING: 0
+};
+const FileDataSchema = z$1.object({ entity: z$1.custom().optional() });
+const SignalStatsSchema = z$1.object({
+	min: z$1.number().optional(),
+	max: z$1.number().optional(),
+	mean: z$1.number().optional(),
+	rms: z$1.number().optional(),
+	peak: z$1.number().optional(),
+	beats: z$1.array(z$1.number()).optional(),
+	tempo: z$1.number().optional()
+});
+const SignalChannelMetaSchema = z$1.object({
+	id: z$1.string(),
+	name: z$1.string(),
+	index: z$1.number(),
+	stats: SignalStatsSchema.optional()
+});
+const GeneratorSignalDataSchema = z$1.object({
+	v: z$1.literal(2).optional(),
+	type: z$1.literal("generator"),
+	nodeId: z$1.string().optional(),
+	baseType: z$1.string().optional(),
+	func: z$1.enum([
+		"sine",
+		"triangle",
+		"sawtooth",
+		"square",
+		"custom"
+	]).or(z$1.string()).default("sine"),
+	frequency: z$1.number().default(1),
+	amplitude: z$1.number().default(1),
+	phase: z$1.number().default(0),
+	offset: z$1.number().default(0),
+	waveform: z$1.string().optional(),
+	bpm: z$1.number().optional(),
+	syncToBpm: z$1.boolean().optional(),
+	fmFrequency: z$1.number().optional(),
+	fmDepth: z$1.number().optional(),
+	envelope: z$1.string().optional(),
+	fnBody: z$1.string().optional(),
+	fnParams: z$1.array(z$1.record(z$1.string(), z$1.unknown())).optional(),
+	customWGSL: z$1.string().optional(),
+	signalFnName: z$1.string().optional(),
+	outputType: z$1.string().optional(),
+	fps: z$1.number().optional(),
+	durationMs: z$1.number().optional(),
+	stats: SignalStatsSchema.optional()
+}).passthrough();
+const AudioExtractorSignalDataSchema = z$1.object({
+	v: z$1.literal(2).optional(),
+	type: z$1.literal("audio_extractor"),
+	nodeId: z$1.string().optional(),
+	sourceUrl: z$1.string().optional(),
+	channel: z$1.enum([
+		"primary",
+		"beat",
+		"bass",
+		"energy",
+		"spectral_flux"
+	]).or(z$1.string()).optional(),
+	channelIndex: z$1.number().optional(),
+	channels: z$1.array(SignalChannelMetaSchema).optional(),
+	extractionMode: z$1.string().optional(),
+	attackMs: z$1.number().optional(),
+	releaseMs: z$1.number().optional(),
+	sensitivity: z$1.number().optional(),
+	noiseFloorDb: z$1.number().optional(),
+	dynamicRangeDb: z$1.number().optional(),
+	autoRange: z$1.boolean().optional(),
+	smoothing: z$1.number().optional(),
+	curve: z$1.string().optional(),
+	beatThreshold: z$1.number().optional(),
+	beatDecayMs: z$1.number().optional(),
+	previewMode: z$1.string().optional(),
+	samples: z$1.union([z$1.array(z$1.number()), z$1.instanceof(Float32Array)]).optional(),
+	fps: z$1.number().optional(),
+	durationMs: z$1.number().optional(),
+	stats: SignalStatsSchema.optional(),
+	state: z$1.enum([
+		"pending",
+		"ready",
+		"failed"
+	]).optional(),
+	error: z$1.string().optional(),
+	virtualMedia: z$1.record(z$1.string(), z$1.unknown()).optional(),
+	signalFnName: z$1.string().optional(),
+	customWGSL: z$1.string().optional()
+}).passthrough();
+const SignalMathDataSchema = z$1.object({
+	v: z$1.literal(2).optional(),
+	type: z$1.literal("signal_math"),
+	nodeId: z$1.string().optional(),
+	op: z$1.string().optional(),
+	operation: z$1.string().optional(),
+	signalA: z$1.unknown().optional(),
+	signalB: z$1.unknown().optional(),
+	bValue: z$1.number().optional(),
+	inMin: z$1.number().optional(),
+	inMax: z$1.number().optional(),
+	outMin: z$1.number().optional(),
+	outMax: z$1.number().optional(),
+	clampMin: z$1.number().optional(),
+	clampMax: z$1.number().optional(),
+	exponent: z$1.number().optional(),
+	edge0: z$1.number().optional(),
+	edge1: z$1.number().optional(),
+	customWGSL: z$1.string().optional(),
+	stats: SignalStatsSchema.optional()
+}).passthrough();
+const SignalGateDataSchema = z$1.object({
+	v: z$1.literal(2).optional(),
+	type: z$1.literal("gate"),
+	nodeId: z$1.string().optional(),
+	sourceSignal: z$1.unknown().optional(),
+	threshold: z$1.number().optional(),
+	debounceMs: z$1.number().optional(),
+	mode: z$1.enum([
+		"gate",
+		"trigger",
+		"toggle"
+	]).optional(),
+	holdFrames: z$1.number().optional(),
+	invert: z$1.boolean().optional(),
+	stats: SignalStatsSchema.optional()
+}).passthrough();
+const SignalDataSchema = z$1.union([
+	GeneratorSignalDataSchema,
+	AudioExtractorSignalDataSchema,
+	SignalMathDataSchema,
+	SignalGateDataSchema,
+	z$1.object({ type: z$1.string() }).passthrough()
+]);
+function serializeSignalData(data) {
+	return JSON.stringify(data, (_key, value) => {
+		if (value instanceof Float32Array) return Array.from(value);
+		return value;
+	});
+}
+function deserializeSignalData(raw) {
+	if (typeof raw === "string") try {
+		return SignalDataSchema.parse(JSON.parse(raw));
+	} catch {
+		return { type: "unknown" };
+	}
+	return SignalDataSchema.parse(raw);
+}
+const OutputItemSchema = z$1.object({
+	type: z$1.custom(),
+	data: z$1.any(),
+	outputHandleId: z$1.string().optional()
+});
+const createOutputItemSchema = (type, dataSchema) => {
+	return z$1.object({
+		type,
+		data: dataSchema,
+		outputHandleId: z$1.string().optional()
+	});
+};
+const SingleOutputGenericSchema = (outputItemSchema) => z$1.object({
+	selectedOutputIndex: z$1.literal(0),
+	outputs: z$1.tuple([z$1.object({ items: z$1.tuple([outputItemSchema]) })])
+});
+const MultiOutputGenericSchema = (outputItemSchema) => z$1.object({
+	selectedOutputIndex: z$1.number(),
+	outputs: z$1.array(z$1.object({ items: z$1.array(outputItemSchema) })),
+	sourceFingerprint: z$1.string().optional()
+});
+const AnyOutputUnionSchema = z$1.object({
+	type: z$1.custom(),
+	data: z$1.any(),
+	outputHandleId: z$1.string().optional()
+});
+const NodeResultSchema = z$1.object({
+	selectedOutputIndex: z$1.number(),
+	outputs: z$1.array(z$1.object({ items: z$1.array(AnyOutputUnionSchema) }))
+});
+const ExportResultSchema = MultiOutputGenericSchema(AnyOutputUnionSchema);
+const AnimationTypeSchema = z.enum([
+	"fade-in",
+	"fade-out",
+	"slide-in-left",
+	"slide-in-right",
+	"slide-in-top",
+	"slide-in-bottom",
+	"zoom-in",
+	"zoom-out",
+	"rotate-cw",
+	"rotate-ccw",
+	"bounce",
+	"shake"
+]);
+const VideoAnimationSchema = z.object({
+	id: z.string(),
+	type: AnimationTypeSchema,
+	value: z.number()
+});
+const VideoSpatialPropsSchema = z.object({
+	x: z.number().default(0),
+	y: z.number().default(0),
+	width: z.number().optional(),
+	height: z.number().optional(),
+	rotation: z.number().default(0),
+	scale: z.number().min(0).default(1),
+	opacity: z.number().min(0).max(1).default(1),
+	zIndex: z.number().int().optional(),
+	blendMode: GlobalCompositeOperation$1.optional()
+});
+const VideoTimingPropsSchema = z.object({
+	startFrame: z.number().int().min(0).default(0),
+	durationInMS: z.number().int().min(1).optional(),
+	trimStart: z.number().int().min(0).optional(),
+	trimEnd: z.number().int().min(0).optional(),
+	speed: z.number().min(.25).max(4).optional()
+});
+const VideoTextPropsSchema = z.object({
+	text: z.string().optional(),
+	fontSize: z.number().optional(),
+	fontFamily: z.string().optional(),
+	fontStyle: z.string().optional(),
+	fontWeight: z.union([z.number(), z.string()]).optional(),
+	fill: z.string().optional(),
+	align: z.string().optional(),
+	verticalAlign: z.string().optional(),
+	letterSpacing: z.number().optional(),
+	lineHeight: z.number().optional(),
+	padding: z.number().optional(),
+	stroke: z.string().optional(),
+	strokeWidth: z.number().optional(),
+	strokeAlign: z.enum([
+		"inside",
+		"center",
+		"outside"
+	]).optional(),
+	textShadow: z.string().optional(),
+	textBackgroundColor: z.string().optional(),
+	shadows: z.array(z.object({
+		color: z.string(),
+		offset: z.object({
+			x: z.number(),
+			y: z.number()
+		}).optional(),
+		blurRadius: z.number().optional()
+	})).optional(),
+	textAnimation: z.any().optional(),
+	bottomPadding: z.number().optional(),
+	maxWidth: z.number().optional()
+});
+const VideoStylePropsSchema = z.object({
+	backgroundColor: z.string().optional(),
+	borderColor: z.string().optional(),
+	borderWidth: z.number().optional(),
+	strokeRadius: z.number().optional(),
+	autoDimensions: z.boolean().optional()
+});
+const VideoLayerTypeSchema = z.enum([
+	"Video",
+	"Image",
+	"Audio",
+	"Text",
+	"Caption",
+	"SVG",
+	"GIF",
+	"Lottie"
+]);
+const BaseVideoLayerPropsSchema = VideoSpatialPropsSchema.merge(VideoTimingPropsSchema).merge(VideoTextPropsSchema).merge(VideoStylePropsSchema).extend({
+	type: VideoLayerTypeSchema.optional(),
+	animations: z.array(VideoAnimationSchema).optional()
+});
+const TransitionTypeSchema = z.enum([
+	"none",
+	"crossfade",
+	"wipe-left",
+	"wipe-right",
+	"slide-up",
+	"slide-down"
+]);
+const TransitionSchema = z.object({
+	type: TransitionTypeSchema,
+	durationFrames: z.number().min(1)
+});
+const MediaSourceSchema = z.object({ entity: FileAssetSchema.optional() });
+const MediaMetadataSchema = z.object({
+	width: z.number().optional().nullable(),
+	height: z.number().optional().nullable(),
+	fps: z.number().optional().nullable(),
+	durationMs: z.number().optional().nullable(),
+	sampleRate: z.number().optional().nullable(),
+	channels: z.number().optional().nullable(),
+	bitDepth: z.number().optional().nullable(),
+	audioCodec: z.string().optional().nullable(),
+	audioBitrate: z.number().optional().nullable()
+});
+const TimelineSegmentSchema = z.object({
+	startSec: z.number(),
+	endSec: z.number().optional()
+});
+const TimelineTransformSchema = z.object({
+	startFrame: z.number().optional(),
+	segments: z.array(TimelineSegmentSchema).optional()
+});
+const BaseMediaOperationPropsSchema = z.object({
+	volume: z.number().optional(),
+	opacity: z.number().optional(),
+	startFrame: z.number().optional(),
+	timeline: TimelineTransformSchema.optional()
+});
+/** Original source file (leaf node) */
+const SourceOperationSchema = BaseMediaOperationPropsSchema.extend({
+	op: z.literal("source"),
+	source: MediaSourceSchema,
+	sourceMeta: MediaMetadataSchema,
+	dataType: z.enum(Object.values(DataTypeVal))
+});
+/** Text content (leaf node) */
+const TextOperationSchema = BaseMediaOperationPropsSchema.extend({
+	op: z.literal("text"),
+	text: z.string(),
+	metadata: MediaMetadataSchema.optional(),
+	dataType: z.enum(Object.values(DataTypeVal))
+}).passthrough();
+const MediaOperationSchema = z.union([
+	SourceOperationSchema,
+	TextOperationSchema,
+	BaseMediaOperationPropsSchema.extend({
+		op: z.string(),
+		metadata: MediaMetadataSchema.optional(),
+		dataType: z.enum(Object.values(DataTypeVal))
+	}).passthrough()
+]);
+const VirtualMediaDataSchema = z.lazy(() => z.object({
+	metadata: MediaMetadataSchema,
+	operation: MediaOperationSchema,
+	children: z.array(VirtualMediaDataSchema).default([])
+}));
+const ExtendedLayerSchema = BaseVideoLayerPropsSchema.extend({
+	id: z.string(),
+	name: z.string().optional(),
+	type: VideoLayerTypeSchema,
+	virtualMedia: VirtualMediaDataSchema.optional(),
+	transitionIn: TransitionSchema.optional(),
+	transitionOut: TransitionSchema.optional(),
+	durationInMS: z.number(),
+	maxDurationInMS: z.number().optional(),
+	src: z.string().optional(),
+	volume: z.number().default(1),
+	inputHandleId: z.string().optional(),
+	isPlaceholder: z.boolean().optional(),
+	lockAspect: z.boolean().optional(),
+	lockRatio: z.boolean().optional(),
+	zIndex: z.number().optional()
+}).strict();
+const DEFAULT_FPS = 60;
+const DEFAULT_DURATION_MS = 3e3;
+const DEFAULT_MEDIA_DIMENSION = 1080;
+/** Default styling applied to new Text layers. */
+const TEXT_LAYER_DEFAULTS = {
+	fontSize: 60,
+	fontFamily: "Inter",
+	fill: "#ffffff",
+	fontStyle: "normal",
+	align: "start",
+	padding: 0
+};
+/** Default styling applied to new Caption layers. */
+const CAPTION_LAYER_DEFAULTS = {
+	fontSize: 48,
+	fontFamily: "Inter",
+	fill: "#ffffff",
+	align: "center",
+	verticalAlign: "bottom",
+	padding: 0,
+	lineHeight: 1.1,
+	textAnimation: {
+		in: "none",
+		out: "none",
+		entranceMs: 0,
+		exitMs: 0,
+		kinetic: "none",
+		applyBy: "word",
+		smoothing: true
+	},
+	bottomPadding: 60
+};
+/**
+* Identify the actual leaf media type (Video, Image, etc) by walking down the tree.
+* This can differ from getMediaType() if an operation (like Ken Burns) upgrades
+* an Image to a Video.
+*/
+function getLeafMediaType(vv) {
+	if (!vv) return void 0;
+	if (vv.operation?.op === "source") return vv.operation.dataType;
+	if (vv.children && vv.children.length > 0) return getLeafMediaType(vv.children[0]);
+	return vv.operation.dataType;
+}
+/**
+* Resolve the MIME type of the leaf source media.
+*/
+function resolveMediaMimeType(vv) {
+	if (!vv) return void 0;
+	if (vv.operation?.op === "source") {
+		const op = vv.operation;
+		if (op.mimeType) return op.mimeType;
+		if (op.sourceMeta?.mimeType) return op.sourceMeta.mimeType;
+		if (op.source?.entity?.mimeType) return op.source.entity.mimeType;
+		const url = typeof op.source === "string" ? op.source : op.url ?? op.source?.url;
+		if (typeof url === "string") {
+			const ext = url.split(".").pop()?.toLowerCase();
+			if (ext === "mp4") return "video/mp4";
+			if (ext === "webm") return "video/webm";
+			if (ext === "mov") return "video/quicktime";
+			if (ext === "png") return "image/png";
+			if (ext === "jpg" || ext === "jpeg") return "image/jpeg";
+			if (ext === "webp") return "image/webp";
+			if (ext === "svg") return "image/svg+xml";
+			if (ext === "mp3") return "audio/mpeg";
+			if (ext === "wav") return "audio/wav";
+			if (ext === "aac") return "audio/aac";
+		}
+	}
+	if (vv.children && vv.children.length > 0) return resolveMediaMimeType(vv.children[0]);
+}
+/**
+* Create a VirtualMediaData from a FileData source or Text.
+* Used by Import, VideoGen, and Text nodes to wrap concrete content.
+*/
+function createVirtualMedia(source, type = "Video") {
+	if (source && typeof source === "object" && "operation" in source && "metadata" in source) return source;
+	if (typeof source === "string") {
+		const url = source;
+		const sourceMeta$1 = {
+			width: void 0,
+			height: void 0,
+			durationMs: type === "Image" || /\.(png|jpg|jpeg|webp|gif|svg)$/i.test(url) ? DEFAULT_DURATION_MS : void 0,
+			fps: void 0
+		};
+		return {
+			metadata: sourceMeta$1,
+			operation: {
+				op: "source",
+				url,
+				source: url,
+				sourceMeta: sourceMeta$1,
+				dataType: type
+			},
+			children: []
+		};
+	}
+	if (typeof source === "object" && source !== null && ("url" in source || "path" in source)) {
+		const desc = source;
+		const url = desc.url ?? desc.path;
+		const isImage = type === "Image" || /\.(png|jpg|jpeg|webp|gif|svg)$/i.test(url);
+		const durationMs = desc.durationMs ?? (isImage ? DEFAULT_DURATION_MS : void 0);
+		const sourceMeta$1 = {
+			width: desc.width,
+			height: desc.height,
+			durationMs,
+			fps: desc.fps,
+			sampleRate: desc.sampleRate,
+			channels: desc.channels,
+			bitDepth: desc.bitDepth,
+			audioCodec: desc.audioCodec,
+			audioBitrate: desc.audioBitrate
+		};
+		return {
+			metadata: sourceMeta$1,
+			operation: {
+				op: "source",
+				url,
+				source: url,
+				sourceMeta: sourceMeta$1,
+				dataType: type
+			},
+			children: []
+		};
+	}
+	const sourceMeta = getFileDataMetadata(source) || {
+		width: void 0,
+		height: void 0,
+		durationMs: void 0,
+		fps: void 0
+	};
+	return {
+		metadata: sourceMeta,
+		operation: {
+			op: "source",
+			source: { entity: source?.entity },
+			sourceMeta,
+			dataType: type
+		},
+		children: []
+	};
+}
+/**
+* Identify if a VirtualMediaData node is intended to be Video, Audio, Image, or Text.
+*/
+function getMediaType(vv) {
+	if (!vv) throw new Error("No media data provided");
+	return vv.operation.dataType;
+}
+/**
+* Append an operation to an existing VirtualMediaData (recursive).
+* This creates a new parent node wrapping the current one as a child.
+*/
+function appendOperation(vv, operation) {
+	return {
+		metadata: computeNextMetadata(getActiveMediaMetadata(vv) ?? {}, operation),
+		operation,
+		children: [vv]
+	};
+}
+/**
+* Helper to compute the metadata of the NEXT node in the operator tree.
+*/
+function computeNextMetadata(baseMeta, op) {
+	let { width, height, durationMs, fps, sampleRate, channels, bitDepth, audioCodec, audioBitrate } = baseMeta;
+	if ("metadata" in op && op.metadata) {
+		width = op.metadata.width ?? width;
+		height = op.metadata.height ?? height;
+		durationMs = op.metadata.durationMs ?? durationMs;
+		fps = op.metadata.fps ?? fps;
+		sampleRate = op.metadata.sampleRate ?? sampleRate;
+		channels = op.metadata.channels ?? channels;
+		bitDepth = op.metadata.bitDepth ?? bitDepth;
+		audioCodec = op.metadata.audioCodec ?? audioCodec;
+		audioBitrate = op.metadata.audioBitrate ?? audioBitrate;
+	}
+	if (op.dataType === "Audio" || op.dataType === "Text" || op.dataType === "Caption") {
+		width = void 0;
+		height = void 0;
+		fps = void 0;
+	}
+	return {
+		width,
+		height,
+		durationMs,
+		fps,
+		sampleRate,
+		channels,
+		bitDepth,
+		audioCodec,
+		audioBitrate
+	};
+}
+function getFileDataMetadata(filedata) {
+	if (!filedata) return null;
+	const { entity } = filedata;
+	const width = entity?.width;
+	const height = entity?.height;
+	let durationMs = entity?.duration;
+	const fps = entity?.fps;
+	const sampleRate = entity?.sampleRate;
+	const channels = entity?.channels;
+	const bitDepth = entity?.bitDepth;
+	const audioCodec = entity?.audioCodec;
+	const audioBitrate = entity?.audioBitrate;
+	if (durationMs === void 0 || durationMs === null) {
+		const mimeType = entity?.mimeType ?? "";
+		if (mimeType.startsWith("image/") || mimeType === "image/svg+xml") durationMs = DEFAULT_DURATION_MS;
+	}
+	if (width === void 0 && height === void 0 && durationMs === void 0 && sampleRate === void 0 && channels === void 0) return null;
+	return {
+		width,
+		height,
+		durationMs: durationMs === 0 ? void 0 : durationMs,
+		fps,
+		sampleRate,
+		channels,
+		bitDepth,
+		audioCodec,
+		audioBitrate
+	};
+}
+/**
+* Get the active metadata from the VirtualMediaData node.
+* Simply returns the metadata property of the node.
+* Supports legacy formats (sourceMeta) and extracts from source if needed.
+*/
+function getActiveMediaMetadata(vv) {
+	if (!vv) return null;
+	let width = vv.metadata?.width;
+	let height = vv.metadata?.height;
+	let durationMs = vv.metadata?.durationMs;
+	let fps = vv.metadata?.fps;
+	let sampleRate = vv.metadata?.sampleRate;
+	let channels = vv.metadata?.channels;
+	let bitDepth = vv.metadata?.bitDepth;
+	let audioCodec = vv.metadata?.audioCodec;
+	let audioBitrate = vv.metadata?.audioBitrate;
+	const op = vv.operation;
+	if (op?.op === "source") {
+		const sm = op.sourceMeta || {};
+		const fdm = op.source ? getFileDataMetadata(op.source) : null;
+		width = width ?? sm.width ?? fdm?.width;
+		height = height ?? sm.height ?? fdm?.height;
+		durationMs = durationMs ?? sm.durationMs ?? fdm?.durationMs;
+		fps = fps ?? sm.fps ?? fdm?.fps;
+		sampleRate = sampleRate ?? sm.sampleRate ?? fdm?.sampleRate;
+		channels = channels ?? sm.channels ?? fdm?.channels;
+		bitDepth = bitDepth ?? sm.bitDepth ?? fdm?.bitDepth;
+		audioCodec = audioCodec ?? sm.audioCodec ?? fdm?.audioCodec;
+		audioBitrate = audioBitrate ?? sm.audioBitrate ?? fdm?.audioBitrate;
+	}
+	if (width === void 0 && height === void 0 && durationMs === void 0 && sampleRate === void 0 && channels === void 0) return null;
+	return {
+		width,
+		height,
+		durationMs: durationMs === 0 ? void 0 : durationMs,
+		fps,
+		sampleRate,
+		channels,
+		bitDepth,
+		audioCodec,
+		audioBitrate
+	};
+}
+/**
+* Compute the dimensions and offsets for rendering a cropped video.
+* Traverses the VirtualMediaData tree to find nested crops and source dimensions.
+*/
+function computeVideoCropRenderProps(virtualMedia) {
+	let totalOffsetX = 0;
+	let totalOffsetY = 0;
+	let hasCrop = false;
+	let sourceMetaFound = null;
+	let currentNode = virtualMedia;
+	while (currentNode) {
+		const op = currentNode.operation;
+		if (op.op === "Crop") {
+			hasCrop = true;
+			const anyOp = op;
+			const inputMeta = currentNode.children[0]?.metadata;
+			const inputW = inputMeta?.width ?? 0;
+			const inputH = inputMeta?.height ?? 0;
+			if (inputW > 0 && inputH > 0) {
+				const cropLeftPx = anyOp.leftPercentage / 100 * inputW;
+				const cropTopPx = anyOp.topPercentage / 100 * inputH;
+				totalOffsetX += cropLeftPx;
+				totalOffsetY += cropTopPx;
+			}
+		}
+		if (op.op === "source") sourceMetaFound = op.sourceMeta ?? currentNode.metadata;
+		currentNode = currentNode.children[0];
+	}
+	if (!hasCrop || !sourceMetaFound) return null;
+	const sourceW = sourceMetaFound.width ?? 1;
+	const sourceH = sourceMetaFound.height ?? 1;
+	return {
+		videoNaturalWidth: sourceW,
+		videoNaturalHeight: sourceH,
+		cropTranslatePercentageX: -(totalOffsetX / sourceW) * 100,
+		cropTranslatePercentageY: -(totalOffsetY / sourceH) * 100
+	};
+}
+/**
+* Performs a deep comparison between two values to determine if they are equivalent.
+* Handles primitives, objects, arrays, Dates, and NaNs.
+*/
+function isEqual(a, b) {
+	if (a === b) return true;
+	if (typeof a === "number" && typeof b === "number" && Number.isNaN(a) && Number.isNaN(b)) return true;
+	if (a && b && typeof a === "object" && typeof b === "object") {
+		if (a.constructor !== b.constructor) return false;
+		if (Array.isArray(a)) {
+			if (a.length !== b.length) return false;
+			for (let i = 0; i < a.length; i++) if (!isEqual(a[i], b[i])) return false;
+			return true;
+		}
+		if (a instanceof Date) return a.getTime() === b.getTime();
+		if (a instanceof RegExp) return a.toString() === b.toString();
+		const keys = Object.keys(a);
+		if (keys.length !== Object.keys(b).length) return false;
+		for (const key of keys) {
+			if (!Object.hasOwn(b, key)) return false;
+			if (!isEqual(a[key], b[key])) return false;
+		}
+		return true;
+	}
+	return false;
+}
+/**
+* Gets a stable object for hashing/fingerprinting by sorting keys and skipping volatile fields.
+*/
+function getStableData(data) {
+	if (typeof data !== "object" || data === null) return data;
+	if (Array.isArray(data)) return data.map(getStableData);
+	const result = {};
+	const keys = Object.keys(data).sort();
+	for (const key of keys) {
+		const val = data[key];
+		if (key === "createdAt" || key === "updatedAt" || key === "dataUrl" || key === "filePath") continue;
+		if (typeof val === "string" && val.startsWith("blob:")) continue;
+		if (key === "entity" && val && typeof val === "object" && val.id) {
+			result.entity = { id: val.id };
+			continue;
+		}
+		result[key] = getStableData(val);
+	}
+	return result;
+}
+/**
+* Generates a fingerprint for the given data.
+*/
+function getFingerprint(data) {
+	const stableData = getStableData(data);
+	const str = JSON.stringify(stableData);
+	if (str.length === 0) return "0";
+	const getHash = (seed) => {
+		let h1 = 3735928559 ^ seed;
+		let h2 = 1103547991 ^ seed;
+		for (let i = 0; i < str.length; i++) {
+			const ch = str.charCodeAt(i);
+			h1 = Math.imul(h1 ^ ch, 2654435761);
+			h2 = Math.imul(h2 ^ ch, 1597334677);
+		}
+		h1 = Math.imul(h1 ^ h1 >>> 16, 2246822519);
+		h1 = Math.imul(h1 ^ h1 >>> 13, 3266489917);
+		h1 = h1 ^ h1 >>> 16;
+		h2 = Math.imul(h2 ^ h2 >>> 16, 2246822519);
+		h2 = Math.imul(h2 ^ h2 >>> 13, 3266489917);
+		h2 = h2 ^ h2 >>> 16;
+		return (h1 >>> 0).toString(36).padStart(7, "0") + (h2 >>> 0).toString(36).padStart(7, "0");
+	};
+	return getHash(0) + getHash(1);
+}
+/**
+* Generates a version-aware fingerprint for render caching.
+* Includes app version so cached renders are invalidated on version bumps.
+*/
+function getRenderFingerprint(data, appVersion, extra) {
+	return getFingerprint({
+		__v: appVersion,
+		data,
+		...extra
+	});
+}
+/**
+* Checks if data is VirtualMediaData.
+*/
+function isVirtualMediaData(data) {
+	return typeof data === "object" && data !== null && "metadata" in data && "operation" in data && "children" in data;
+}
+/**
+* Checks if the virtual media is just a raw source without any significant operations
+* that would require a rendering step (like transformations, trimming, or effects).
+*/
+function hasOnlySingleSource(data) {
+	if (!isVirtualMediaData(data)) return false;
+	if (data.operation.op === "source") {
+		if (data.children && data.children.length > 0) return false;
+		const op = data.operation;
+		return !(op.volume !== void 0 && op.volume !== 1 || op.opacity !== void 0 && op.opacity !== 1 || op.startFrame !== void 0 && op.startFrame !== 0 || op.timeline && (op.timeline.startFrame !== void 0 && op.timeline.startFrame !== 0 || op.timeline.segments && op.timeline.segments.length > 0));
+	}
+	if (data.operation.op === "compose") return false;
+	if (data.operation.op === "layer" && data.children.length === 1) {
+		const op = data.operation;
+		if (!(op.x !== void 0 && op.x !== 0 || op.y !== void 0 && op.y !== 0 || op.rotation !== void 0 && op.rotation !== 0 || op.scale !== void 0 && op.scale !== 1 || op.opacity !== void 0 && op.opacity !== 1 || op.volume !== void 0 && op.volume !== 1 || op.zIndex !== void 0 || op.blendMode !== void 0 || op.filters !== void 0 || op.transitionIn !== void 0 || op.transitionOut !== void 0 || op.animations && op.animations.length > 0 || op.trimStart !== void 0 || op.trimEnd !== void 0 || op.speed !== void 0 || op.backgroundColor !== void 0 || op.borderColor !== void 0 || op.borderWidth !== void 0 || op.strokeRadius !== void 0)) return hasOnlySingleSource(data.children[0]);
+	}
+	return false;
+}
+/**
+* Finds the source asset in a virtual media tree.
+*/
+function findSourceAsset(vm) {
+	if (vm.operation.op === "source") return vm.operation.source;
+	if (vm.children && vm.children.length > 0) return findSourceAsset(vm.children[0]);
+	return null;
+}
+/**
+* Checks if a cached node result can be reused based on source fingerprint.
+* Returns the valid cached result, or null if the cache is stale.
+*/
+function checkNodeResultCache(currentResult, input) {
+	if (!currentResult?.sourceFingerprint) return null;
+	const inputFingerprint = getFingerprint(input);
+	if (currentResult.sourceFingerprint !== inputFingerprint) return null;
+	return currentResult;
+}
+/**
+* Creates a fresh result with a source fingerprint stamp.
+*/
+function stampResult(result, input) {
+	return {
+		...result,
+		sourceFingerprint: getFingerprint(input)
+	};
+}
+/**
+* Attempts to parse the width and height of an SVG from its buffer.
+* Falls back to viewBox ratios if explicitly defined sizes are missing.
+*/
+function extractSvgDimensions(buffer) {
+	try {
+		const match = buffer.toString("utf-8").match(/<svg[^>]*>/i);
+		if (!match) return null;
+		const svgTag = match[0];
+		const getAttr = (name) => {
+			const attrMatch = svgTag.match(new RegExp(`${name}=["']([^"']+)["']`, "i"));
+			if (!attrMatch) return null;
+			const val = parseFloat(attrMatch[1].replace(/[a-z%]/gi, ""));
+			return isNaN(val) ? null : val;
+		};
+		let w = getAttr("width");
+		let h = getAttr("height");
+		const viewBoxMatch = svgTag.match(/viewBox=["']([^"']+)["']/i);
+		if (viewBoxMatch) {
+			const parts = viewBoxMatch[1].split(/[\s,]+/).map(parseFloat);
+			if (parts.length >= 4 && !isNaN(parts[2]) && !isNaN(parts[3])) {
+				const vbW = parts[2];
+				const vbH = parts[3];
+				if (w == null && h == null) {
+					w = vbW;
+					h = vbH;
+				} else if (w != null && h == null) h = w * (vbH / vbW);
+				else if (h != null && w == null) w = h * (vbW / vbH);
+			}
+		}
+		if (w != null && h != null && w > 0 && h > 0) return {
+			w,
+			h
+		};
+		return null;
+	} catch (error) {
+		console.error("Error parsing SVG dimensions", error);
+		return null;
+	}
+}
+
+//#endregion
+//#region ../node-sdk/dist/renderer.mjs
+function defineRenderer(plugin) {
+	return Object.freeze(plugin);
+}
+const GLOBAL_WEBGPU_REGISTRY_KEY = Symbol.for("gitframes.webgpuRegistry");
+var WebGPURegistry = class {
+	renderers = /* @__PURE__ */ new Map();
+	register(op, renderer) {
+		this.renderers.set(op, renderer);
+	}
+	get(op) {
+		return this.renderers.get(op);
+	}
+	has(op) {
+		return this.renderers.has(op);
+	}
+};
+const webgpuRegistry = (() => {
+	const g = globalThis;
+	if (!g[GLOBAL_WEBGPU_REGISTRY_KEY]) g[GLOBAL_WEBGPU_REGISTRY_KEY] = new WebGPURegistry();
+	return g[GLOBAL_WEBGPU_REGISTRY_KEY];
+})();
+function registerWebGPURenderer(op, renderer) {
+	webgpuRegistry.register(op, renderer);
+}
+var AudioProcessorRegistry = class {
+	processors = /* @__PURE__ */ new Map();
+	register(opType, processor) {
+		this.processors.set(opType, processor);
+	}
+	get(opType) {
+		return this.processors.get(opType) || null;
+	}
+};
+const GLOBAL_AUDIO_KEY = Symbol.for("gitframes.audioRegistry");
+const audioRegistry = (() => {
+	const g = globalThis;
+	if (!g[GLOBAL_AUDIO_KEY]) g[GLOBAL_AUDIO_KEY] = new AudioProcessorRegistry();
+	return g[GLOBAL_AUDIO_KEY];
+})();
+
+//#endregion
+//#region ../node-sdk/dist/index.mjs
+var ConfigBuilder = class ConfigBuilder$1 {
+	constructor(shape = {}, options = { strict: true }) {
+		this.shape = shape;
+		this.options = options;
+	}
+	field(key, schema, options) {
+		const withMeta = options ? schema.meta({ ...options }) : schema;
+		return new ConfigBuilder$1({
+			...this.shape,
+			[key]: withMeta
+		}, this.options);
+	}
+	build() {
+		const base = z.object(this.shape);
+		return { schema: this.options.strict !== false ? base.strict() : base };
+	}
+};
+function configBuilder(options = { strict: true }) {
+	return new ConfigBuilder({}, options);
+}
+const COMPOSITE_OPERATIONS = [
+	"source-over",
+	"source-in",
+	"source-out",
+	"source-atop",
+	"destination-over",
+	"destination-in",
+	"destination-out",
+	"destination-atop",
+	"lighter",
+	"copy",
+	"xor",
+	"multiply",
+	"screen",
+	"overlay",
+	"darken",
+	"lighten",
+	"color-dodge",
+	"color-burn",
+	"hard-light",
+	"soft-light",
+	"difference",
+	"exclusion",
+	"hue",
+	"saturation",
+	"color",
+	"luminosity"
+];
+const GlobalCompositeOperation = z.enum(COMPOSITE_OPERATIONS);
+const ColorSchema = z.string().optional();
+const PercentageSchema = z.number().min(0).max(100);
+const DimensionSchema = z.number().min(0).optional();
+const AnimationSchema = z.object({ animations: z.array(z.object({
+	id: z.string(),
+	type: z.enum([
+		"fade-in",
+		"fade-out",
+		"slide-in-left",
+		"slide-in-right",
+		"slide-in-top",
+		"slide-in-bottom",
+		"zoom-in",
+		"zoom-out",
+		"rotate-cw",
+		"rotate-ccw",
+		"bounce",
+		"shake"
+	]),
+	value: z.number()
+})).optional() });
+const StrokeSchema = z.object({
+	stroke: ColorSchema,
+	strokeWidth: z.number().min(0).optional(),
+	strokeAlign: z.enum([
+		"inside",
+		"center",
+		"outside"
+	]).optional().default("inside"),
+	strokeRadius: z.number().min(0).optional()
+});
+const ImageResultSchema = SingleOutputGenericSchema(createOutputItemSchema(z.literal("Image"), FileDataSchema));
+const VideoResultSchema = SingleOutputGenericSchema(createOutputItemSchema(z.literal("Video"), VirtualMediaDataSchema));
+const AudioResultSchema = SingleOutputGenericSchema(createOutputItemSchema(z.literal("Audio"), VirtualMediaDataSchema));
+const TextResultSchema = SingleOutputGenericSchema(createOutputItemSchema(z.literal("Text"), z.string()));
+const NumberResultSchema = SingleOutputGenericSchema(createOutputItemSchema(z.literal("Number"), z.number()));
+const SignalResultSchema = SingleOutputGenericSchema(createOutputItemSchema(z.literal("Signal"), z.unknown()));
+
+//#endregion
+//#region ../renderers/dist/index.mjs
+const mapBlendModeToSkia = (mode) => {
+	if (!mode) return "srcOver";
+	switch (mode) {
+		case "source-over": return "srcOver";
+		case "source-in": return "srcIn";
+		case "source-out": return "srcOut";
+		case "source-atop": return "srcATop";
+		case "destination-over": return "dstOver";
+		case "destination-in": return "dstIn";
+		case "destination-out": return "dstOut";
+		case "destination-atop": return "dstATop";
+		case "copy": return "src";
+		case "xor": return "xor";
+		case "multiply": return "multiply";
+		case "screen": return "screen";
+		case "overlay": return "overlay";
+		case "darken": return "darken";
+		case "lighten":
+		case "lighter": return "lighten";
+		case "color-dodge": return "colorDodge";
+		case "color-burn": return "colorBurn";
+		case "hard-light": return "hardLight";
+		case "soft-light": return "softLight";
+		case "difference": return "difference";
+		case "exclusion": return "exclusion";
+		case "hue": return "hue";
+		case "saturation": return "saturation";
+		case "color": return "color";
+		case "luminosity": return "luminosity";
+		default: return "srcOver";
+	}
+};
+const requiresIsolation = (mode) => {
+	return mode === "destination-in" || mode === "source-in";
+};
+function computeStrokeRect(w, h, cornerRadius, strokeWidth, align = "outside") {
+	if (align === "inside") {
+		const half = strokeWidth / 2;
+		return {
+			x: half,
+			y: half,
+			width: Math.max(0, w - strokeWidth),
+			height: Math.max(0, h - strokeWidth),
+			radius: cornerRadius === 0 ? 0 : Math.max(0, cornerRadius - half)
+		};
+	}
+	if (align === "outside") {
+		const half = strokeWidth / 2;
+		return {
+			x: -half,
+			y: -half,
+			width: w + strokeWidth,
+			height: h + strokeWidth,
+			radius: cornerRadius === 0 ? 0 : cornerRadius + half
+		};
+	}
+	return {
+		x: 0,
+		y: 0,
+		width: w,
+		height: h,
+		radius: cornerRadius
+	};
+}
+const { cbrt, sqrt, PI: π } = Math;
+const x2t = (x, a, b, c, d) => {
+	const q = a + b * x;
+	const s = q ** 2 + c;
+	if (s > 0) {
+		const root = sqrt(s);
+		return cbrt(q + root) + cbrt(q - root) - d;
+	}
+	const l = cbrt(sqrt(q * q - s));
+	const angle = q ? Math.atan(sqrt(-s) / q) : -π / 2;
+	let φ;
+	if (b < 0) φ = (q > 0 ? 2 * π : π) - angle;
+	else if (d < 0) φ = (q > 0 ? 2 * π : -3 * π) + angle;
+	else φ = (q > 0 ? 0 : π) + angle;
+	return 2 * l * Math.cos(φ / 3) - d;
+};
+const Y = (t, ay, by, cy) => ((ay * t + 3 * by) * t + cy) * t;
+const linearEasing = (x) => x;
+function bezier(mX1, mY1, mX2, mY2) {
+	if (!(0 <= mX1 && mX1 <= 1 && 0 <= mX2 && mX2 <= 1)) throw new Error("bezier x values must be in [0, 1] range");
+	if (mX1 === mY1 && mX2 === mY2) return linearEasing;
+	const a = 6 * (3 * mX1 - 3 * mX2 + 1);
+	const b = 6 * (mX2 - 2 * mX1);
+	const c = 3 * mX1;
+	const a2 = a * a;
+	const b2 = b * b;
+	const d = b / a;
+	const e = 3 * b * c / a2 - b2 * b / (a2 * a);
+	const w1 = 2 * c / a - b2 / a2;
+	const w = w1 * w1 * w1;
+	const o = 3 / a;
+	const ay = 3 * mY1 - 3 * mY2 + 1;
+	const by = mY2 - 2 * mY1;
+	const cy = 3 * mY1;
+	const X2T = a ? x2t : linearEasing;
+	return function BezierEasing(x) {
+		if (x === 0 || x === 1) return x;
+		return Y(X2T(x, e, o, w, d), ay, by, cy);
+	};
+}
+const Easing = {
+	linear: linearEasing,
+	ease: bezier(.25, .1, .25, 1),
+	quad: (t) => t * t,
+	cubic: (t) => t * t * t,
+	poly: (n) => (t) => t ** n,
+	sin: (t) => 1 - Math.cos(t * Math.PI / 2),
+	circle: (t) => 1 - Math.sqrt(1 - t * t),
+	exp: (t) => 2 ** (10 * (t - 1)),
+	elastic: (bounciness = 1) => {
+		const p = bounciness * Math.PI;
+		return (t) => 1 - Math.cos(t * Math.PI / 2) ** 3 * Math.cos(t * p);
+	},
+	back: (s = 1.70158) => (t) => t * t * ((s + 1) * t - s),
+	bounce: (t) => {
+		if (t < 1 / 2.75) return 7.5625 * t * t;
+		if (t < 2 / 2.75) {
+			const t2$1 = t - 1.5 / 2.75;
+			return 7.5625 * t2$1 * t2$1 + .75;
+		}
+		if (t < 2.5 / 2.75) {
+			const t2$1 = t - 2.25 / 2.75;
+			return 7.5625 * t2$1 * t2$1 + .9375;
+		}
+		const t2 = t - 2.625 / 2.75;
+		return 7.5625 * t2 * t2 + .984375;
+	},
+	bezier,
+	in: (fn) => fn,
+	out: (fn) => (t) => 1 - fn(1 - t),
+	inOut: (fn) => (t) => t < .5 ? fn(t * 2) / 2 : 1 - fn((1 - t) * 2) / 2
+};
+function interpolate(value, inputRange, outputRange, options) {
+	const extrapolateLeft = options?.extrapolateLeft ?? "extend";
+	const extrapolateRight = options?.extrapolateRight ?? "extend";
+	if (inputRange.length !== outputRange.length) throw new Error("inputRange and outputRange must have the same length");
+	if (inputRange.length < 2) throw new Error("inputRange must have at least 2 elements");
+	const firstInput = inputRange[0];
+	const lastInput = inputRange[inputRange.length - 1];
+	if (value < firstInput) {
+		if (extrapolateLeft === "clamp") return outputRange[0];
+		if (extrapolateLeft === "identity") return value;
+	}
+	if (value > lastInput) {
+		if (extrapolateRight === "clamp") return outputRange[outputRange.length - 1];
+		if (extrapolateRight === "identity") return value;
+	}
+	let i = 1;
+	for (; i < inputRange.length - 1; i++) if (value < inputRange[i]) break;
+	const x0 = inputRange[i - 1];
+	const x1 = inputRange[i];
+	const y0 = outputRange[i - 1];
+	const y1 = outputRange[i];
+	if (x0 === x1) return y0;
+	let progress = (value - x0) / (x1 - x0);
+	if (options?.easing) progress = options.easing(progress);
+	return y0 + progress * (y1 - y0);
+}
+const Vector3Math = {
+	create(x = 0, y = 0, z$2 = 0) {
+		return [
+			x,
+			y,
+			z$2
+		];
+	},
+	copy(v) {
+		return [
+			v[0],
+			v[1],
+			v[2]
+		];
+	},
+	set(out, x, y, z$2) {
+		out[0] = x;
+		out[1] = y;
+		out[2] = z$2;
+		return out;
+	},
+	add(a, b) {
+		return [
+			a[0] + b[0],
+			a[1] + b[1],
+			a[2] + b[2]
+		];
+	},
+	subtract(a, b) {
+		return [
+			a[0] - b[0],
+			a[1] - b[1],
+			a[2] - b[2]
+		];
+	},
+	multiplyScalar(v, s) {
+		return [
+			v[0] * s,
+			v[1] * s,
+			v[2] * s
+		];
+	},
+	dot(a, b) {
+		return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+	},
+	cross(a, b) {
+		return [
+			a[1] * b[2] - a[2] * b[1],
+			a[2] * b[0] - a[0] * b[2],
+			a[0] * b[1] - a[1] * b[0]
+		];
+	},
+	lengthSq(v) {
+		return v[0] * v[0] + v[1] * v[1] + v[2] * v[2];
+	},
+	length(v) {
+		return Math.hypot(v[0], v[1], v[2]);
+	},
+	distance(a, b) {
+		return Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
+	},
+	normalize(v) {
+		const len = Math.hypot(v[0], v[1], v[2]);
+		if (len === 0) return [
+			0,
+			0,
+			0
+		];
+		const inv = 1 / len;
+		return [
+			v[0] * inv,
+			v[1] * inv,
+			v[2] * inv
+		];
+	},
+	lerp(a, b, t) {
+		return [
+			a[0] + (b[0] - a[0]) * t,
+			a[1] + (b[1] - a[1]) * t,
+			a[2] + (b[2] - a[2]) * t
+		];
+	},
+	equals(a, b, epsilon = 1e-6) {
+		return Math.abs(a[0] - b[0]) <= epsilon && Math.abs(a[1] - b[1]) <= epsilon && Math.abs(a[2] - b[2]) <= epsilon;
+	}
+};
+/**
+* Column-major 4x4 matrix mathematics for WebGPU 3D rendering and camera projections.
+* Memory layout matches WGSL `mat4x4<f32>`:
+* [ 0,  4,  8, 12 ]
+* [ 1,  5,  9, 13 ]
+* [ 2,  6, 10, 14 ]
+* [ 3,  7, 11, 15 ]
+*/
+const Matrix4Math = {
+	identity() {
+		return [
+			1,
+			0,
+			0,
+			0,
+			0,
+			1,
+			0,
+			0,
+			0,
+			0,
+			1,
+			0,
+			0,
+			0,
+			0,
+			1
+		];
+	},
+	copy(m) {
+		return [...m];
+	},
+	multiply(a, b) {
+		const out = new Array(16);
+		for (let row = 0; row < 4; row++) for (let col = 0; col < 4; col++) out[col * 4 + row] = a[0 + row] * b[col * 4 + 0] + a[4 + row] * b[col * 4 + 1] + a[8 + row] * b[col * 4 + 2] + a[12 + row] * b[col * 4 + 3];
+		return out;
+	},
+	translate(tx, ty, tz = 0) {
+		return [
+			1,
+			0,
+			0,
+			0,
+			0,
+			1,
+			0,
+			0,
+			0,
+			0,
+			1,
+			0,
+			tx,
+			ty,
+			tz,
+			1
+		];
+	},
+	scale(sx, sy, sz = 1) {
+		return [
+			sx,
+			0,
+			0,
+			0,
+			0,
+			sy,
+			0,
+			0,
+			0,
+			0,
+			sz,
+			0,
+			0,
+			0,
+			0,
+			1
+		];
+	},
+	rotateX(rad) {
+		const c = Math.cos(rad);
+		const s = Math.sin(rad);
+		return [
+			1,
+			0,
+			0,
+			0,
+			0,
+			c,
+			s,
+			0,
+			0,
+			-s,
+			c,
+			0,
+			0,
+			0,
+			0,
+			1
+		];
+	},
+	rotateY(rad) {
+		const c = Math.cos(rad);
+		const s = Math.sin(rad);
+		return [
+			c,
+			0,
+			-s,
+			0,
+			0,
+			1,
+			0,
+			0,
+			s,
+			0,
+			c,
+			0,
+			0,
+			0,
+			0,
+			1
+		];
+	},
+	rotateZ(rad) {
+		const c = Math.cos(rad);
+		const s = Math.sin(rad);
+		return [
+			c,
+			s,
+			0,
+			0,
+			-s,
+			c,
+			0,
+			0,
+			0,
+			0,
+			1,
+			0,
+			0,
+			0,
+			0,
+			1
+		];
+	},
+	rotateAxis(axis, rad) {
+		const norm = Vector3Math.normalize(axis);
+		const x = norm[0];
+		const y = norm[1];
+		const z$2 = norm[2];
+		const c = Math.cos(rad);
+		const s = Math.sin(rad);
+		const t = 1 - c;
+		return [
+			t * x * x + c,
+			t * x * y + s * z$2,
+			t * x * z$2 - s * y,
+			0,
+			t * x * y - s * z$2,
+			t * y * y + c,
+			t * y * z$2 + s * x,
+			0,
+			t * x * z$2 + s * y,
+			t * y * z$2 - s * x,
+			t * z$2 * z$2 + c,
+			0,
+			0,
+			0,
+			0,
+			1
+		];
+	},
+	lookAt(eye, target, up = [
+		0,
+		-1,
+		0
+	]) {
+		let f = Vector3Math.subtract(target, eye);
+		if (Vector3Math.lengthSq(f) === 0) f = [
+			0,
+			0,
+			1
+		];
+		else f = Vector3Math.normalize(f);
+		let r = Vector3Math.cross(f, up);
+		if (Vector3Math.lengthSq(r) === 0) r = [
+			1,
+			0,
+			0
+		];
+		else r = Vector3Math.normalize(r);
+		const u = Vector3Math.cross(r, f);
+		return [
+			r[0],
+			u[0],
+			f[0],
+			0,
+			r[1],
+			u[1],
+			f[1],
+			0,
+			r[2],
+			u[2],
+			f[2],
+			0,
+			-Vector3Math.dot(r, eye),
+			-Vector3Math.dot(u, eye),
+			-Vector3Math.dot(f, eye),
+			1
+		];
+	},
+	perspective(fovYRad, aspect, near, far) {
+		const f = 1 / Math.tan(fovYRad / 2);
+		const rangeInv = 1 / (far - near);
+		return [
+			f / aspect,
+			0,
+			0,
+			0,
+			0,
+			f,
+			0,
+			0,
+			0,
+			0,
+			far * rangeInv,
+			1,
+			0,
+			0,
+			-near * far * rangeInv,
+			0
+		];
+	},
+	orthographic(left, right, bottom, top, near, far) {
+		const lr = 1 / (right - left);
+		const bt = 1 / (top - bottom);
+		const nf = 1 / (far - near);
+		return [
+			2 * lr,
+			0,
+			0,
+			0,
+			0,
+			2 * bt,
+			0,
+			0,
+			0,
+			0,
+			nf,
+			0,
+			-(right + left) * lr,
+			-(top + bottom) * bt,
+			-near * nf,
+			1
+		];
+	},
+	invert(m) {
+		const inv = new Array(16);
+		inv[0] = m[5] * m[10] * m[15] - m[5] * m[11] * m[14] - m[9] * m[6] * m[15] + m[9] * m[7] * m[14] + m[13] * m[6] * m[11] - m[13] * m[7] * m[10];
+		inv[4] = -m[4] * m[10] * m[15] + m[4] * m[11] * m[14] + m[8] * m[6] * m[15] - m[8] * m[7] * m[14] - m[12] * m[6] * m[11] + m[12] * m[7] * m[10];
+		inv[8] = m[4] * m[9] * m[15] - m[4] * m[11] * m[13] - m[8] * m[5] * m[15] + m[8] * m[7] * m[13] + m[12] * m[5] * m[11] - m[12] * m[7] * m[9];
+		inv[12] = -m[4] * m[9] * m[14] + m[4] * m[10] * m[13] + m[8] * m[5] * m[14] - m[8] * m[6] * m[13] - m[12] * m[5] * m[10] + m[12] * m[6] * m[9];
+		inv[1] = -m[1] * m[10] * m[15] + m[1] * m[11] * m[14] + m[9] * m[2] * m[15] - m[9] * m[3] * m[14] - m[13] * m[2] * m[11] + m[13] * m[3] * m[10];
+		inv[5] = m[0] * m[10] * m[15] - m[0] * m[11] * m[14] - m[8] * m[2] * m[15] + m[8] * m[3] * m[14] + m[12] * m[2] * m[11] - m[12] * m[3] * m[10];
+		inv[9] = -m[0] * m[9] * m[15] + m[0] * m[11] * m[13] + m[8] * m[1] * m[15] - m[8] * m[3] * m[13] - m[12] * m[1] * m[11] + m[12] * m[3] * m[9];
+		inv[13] = m[0] * m[9] * m[14] - m[0] * m[10] * m[13] - m[8] * m[1] * m[14] + m[8] * m[2] * m[13] + m[12] * m[1] * m[10] - m[12] * m[2] * m[9];
+		inv[2] = m[1] * m[6] * m[15] - m[1] * m[7] * m[14] - m[5] * m[2] * m[15] + m[5] * m[3] * m[14] + m[13] * m[2] * m[7] - m[13] * m[3] * m[6];
+		inv[6] = -m[0] * m[6] * m[15] + m[0] * m[7] * m[14] + m[4] * m[2] * m[15] - m[4] * m[3] * m[14] - m[12] * m[2] * m[7] + m[12] * m[3] * m[6];
+		inv[10] = m[0] * m[5] * m[15] - m[0] * m[7] * m[13] - m[4] * m[1] * m[15] + m[4] * m[3] * m[13] + m[12] * m[1] * m[7] - m[12] * m[3] * m[5];
+		inv[14] = -m[0] * m[5] * m[14] + m[0] * m[6] * m[13] + m[4] * m[1] * m[14] - m[4] * m[2] * m[13] - m[12] * m[1] * m[6] + m[12] * m[2] * m[5];
+		inv[3] = -m[1] * m[6] * m[11] + m[1] * m[7] * m[10] + m[5] * m[2] * m[11] - m[5] * m[3] * m[10] - m[9] * m[2] * m[7] + m[9] * m[3] * m[6];
+		inv[7] = m[0] * m[6] * m[11] - m[0] * m[7] * m[10] - m[4] * m[2] * m[11] + m[4] * m[3] * m[10] + m[8] * m[2] * m[7] - m[8] * m[3] * m[6];
+		inv[11] = -m[0] * m[5] * m[11] + m[0] * m[7] * m[9] + m[4] * m[1] * m[11] - m[4] * m[3] * m[9] - m[8] * m[1] * m[7] + m[8] * m[3] * m[5];
+		inv[15] = m[0] * m[5] * m[10] - m[0] * m[6] * m[9] - m[4] * m[1] * m[10] + m[4] * m[2] * m[9] + m[8] * m[1] * m[6] - m[8] * m[2] * m[5];
+		let det = m[0] * inv[0] + m[1] * inv[4] + m[2] * inv[8] + m[3] * inv[12];
+		if (Math.abs(det) < 1e-12) return null;
+		det = 1 / det;
+		for (let i = 0; i < 16; i++) inv[i] *= det;
+		return inv;
+	},
+	transpose(m) {
+		return [
+			m[0],
+			m[4],
+			m[8],
+			m[12],
+			m[1],
+			m[5],
+			m[9],
+			m[13],
+			m[2],
+			m[6],
+			m[10],
+			m[14],
+			m[3],
+			m[7],
+			m[11],
+			m[15]
+		];
+	},
+	projectPoint(m, p) {
+		const x = p[0];
+		const y = p[1];
+		const z$2 = p[2];
+		const X = m[0] * x + m[4] * y + m[8] * z$2 + m[12];
+		const Y$1 = m[1] * x + m[5] * y + m[9] * z$2 + m[13];
+		const Z = m[2] * x + m[6] * y + m[10] * z$2 + m[14];
+		const W = m[3] * x + m[7] * y + m[11] * z$2 + m[15];
+		const wInv = Math.abs(W) > 1e-6 ? 1 / W : 1;
+		return [
+			X * wInv,
+			Y$1 * wInv,
+			Z * wInv
+		];
+	},
+	projectRectangle(m, width, height) {
+		return [
+			Matrix4Math.projectPoint(m, [
+				0,
+				0,
+				0
+			]),
+			Matrix4Math.projectPoint(m, [
+				width,
+				0,
+				0
+			]),
+			Matrix4Math.projectPoint(m, [
+				width,
+				height,
+				0
+			]),
+			Matrix4Math.projectPoint(m, [
+				0,
+				height,
+				0
+			])
+		];
+	},
+	toFloat32Array(m) {
+		return new Float32Array(m);
+	}
+};
+/**
+* WebGPU 3D Lighting & Material Shading engine.
+* Supports Ambient, Directional, Point, and Spot light sources,
+* normal matrix computation for non-uniform surface scaling,
+* and binary uniform buffer packing for WGSL shaders.
+*/
+const MAX_LIGHTS = 8;
+const LIGHT_UNIFORM_SIZE_BYTES = 544;
+/**
+* Parses CSS / hex / rgb color strings, arrays, or color objects into normalized linear [r, g, b] floats in [0, 1].
+*/
+function parseColorToRgb(color) {
+	if (!color) return [
+		1,
+		1,
+		1
+	];
+	if (Array.isArray(color)) {
+		const r = color[0] ?? 1;
+		const g = color[1] ?? 1;
+		const b = color[2] ?? 1;
+		return [
+			r > 1 ? r / 255 : r,
+			g > 1 ? g / 255 : g,
+			b > 1 ? b / 255 : b
+		];
+	}
+	if (typeof color === "object" && color !== null) {
+		const r = color.r ?? 1;
+		const g = color.g ?? 1;
+		const b = color.b ?? 1;
+		return [
+			r > 1 ? r / 255 : r,
+			g > 1 ? g / 255 : g,
+			b > 1 ? b / 255 : b
+		];
+	}
+	if (typeof color !== "string") return [
+		1,
+		1,
+		1
+	];
+	const str = color.trim().toLowerCase();
+	if (str.startsWith("#")) {
+		const hex = str.slice(1);
+		if (hex.length === 3) return [
+			Number.parseInt(hex[0] + hex[0], 16) / 255,
+			Number.parseInt(hex[1] + hex[1], 16) / 255,
+			Number.parseInt(hex[2] + hex[2], 16) / 255
+		];
+		if (hex.length >= 6) return [
+			Number.parseInt(hex.slice(0, 2), 16) / 255,
+			Number.parseInt(hex.slice(2, 4), 16) / 255,
+			Number.parseInt(hex.slice(4, 6), 16) / 255
+		];
+	}
+	const rgbMatch = str.match(/rgba?\s*\(\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)/);
+	if (rgbMatch) {
+		const r = Number.parseFloat(rgbMatch[1]) / 255;
+		const g = Number.parseFloat(rgbMatch[2]) / 255;
+		const b = Number.parseFloat(rgbMatch[3]) / 255;
+		return [
+			Math.max(0, Math.min(1, r)),
+			Math.max(0, Math.min(1, g)),
+			Math.max(0, Math.min(1, b))
+		];
+	}
+	const hslMatch = str.match(/hsla?\s*\(\s*([\d.]+)\s*,\s*([\d.]+)%?\s*,\s*([\d.]+)%?/);
+	if (hslMatch) return hslToRgb(Number.parseFloat(hslMatch[1]) / 360, Number.parseFloat(hslMatch[2]) / 100, Number.parseFloat(hslMatch[3]) / 100);
+	return [
+		1,
+		1,
+		1
+	];
+}
+function hslToRgb(h, s, l) {
+	if (s === 0) return [
+		l,
+		l,
+		l
+	];
+	const hue2rgb = (p$1, q$1, t) => {
+		let tt = t;
+		if (tt < 0) tt += 1;
+		if (tt > 1) tt -= 1;
+		if (tt < 1 / 6) return p$1 + (q$1 - p$1) * 6 * tt;
+		if (tt < 1 / 2) return q$1;
+		if (tt < 2 / 3) return p$1 + (q$1 - p$1) * (2 / 3 - tt) * 6;
+		return p$1;
+	};
+	const q = l < .5 ? l * (1 + s) : l + s - l * s;
+	const p = 2 * l - q;
+	return [
+		hue2rgb(p, q, h + 1 / 3),
+		hue2rgb(p, q, h),
+		hue2rgb(p, q, h - 1 / 3)
+	];
+}
+const PlaybackContext = createContext({
+	frame: 0,
+	fps: 24,
+	isPlaying: false
+});
+const PlaybackProvider = PlaybackContext.Provider;
+const useCurrentFrame = () => {
+	return useContext(PlaybackContext).frame;
+};
+const useVideoConfig = () => {
+	return {
+		fps: useContext(PlaybackContext).fps,
+		width: 1920,
+		height: 1080
+	};
+};
+const defaultSpringConfig = {
+	damping: 10,
+	mass: 1,
+	stiffness: 100,
+	overshootClamping: false
+};
+const advanceCache = {};
+function advance({ animation, now, config }) {
+	const { toValue, lastTimestamp, current, velocity } = animation;
+	const deltaTime = Math.min(now - lastTimestamp, 64);
+	if (config.damping <= 0) throw new Error("Spring damping must be greater than 0, otherwise the spring() animation will never end, causing an infinite loop.");
+	if (config.stiffness <= 0) throw new Error("Spring stiffness must be greater than 0.");
+	if (config.mass <= 0) throw new Error("Spring mass must be greater than 0.");
+	const c = config.damping;
+	const m = config.mass;
+	const k = config.stiffness;
+	const cacheKey = [
+		toValue,
+		lastTimestamp,
+		current,
+		velocity,
+		c,
+		m,
+		k,
+		now
+	].join("-");
+	if (advanceCache[cacheKey]) return advanceCache[cacheKey];
+	const v0 = -velocity;
+	const x0 = toValue - current;
+	const zeta = c / (2 * Math.sqrt(k * m));
+	const omega0 = Math.sqrt(k / m);
+	const omega1 = omega0 * Math.sqrt(1 - zeta ** 2);
+	const t = deltaTime / 1e3;
+	const sin1 = Math.sin(omega1 * t);
+	const cos1 = Math.cos(omega1 * t);
+	const underDampedEnvelope = Math.exp(-zeta * omega0 * t);
+	const underDampedFrag1 = underDampedEnvelope * (sin1 * ((v0 + zeta * omega0 * x0) / omega1) + x0 * cos1);
+	const underDampedPosition = toValue - underDampedFrag1;
+	const underDampedVelocity = zeta * omega0 * underDampedFrag1 - underDampedEnvelope * (cos1 * (v0 + zeta * omega0 * x0) - omega1 * x0 * sin1);
+	const criticallyDampedEnvelope = Math.exp(-omega0 * t);
+	const criticallyDampedPosition = toValue - criticallyDampedEnvelope * (x0 + (v0 + omega0 * x0) * t);
+	const criticallyDampedVelocity = criticallyDampedEnvelope * (v0 * (t * omega0 - 1) + t * x0 * omega0 * omega0);
+	const animationNode = {
+		toValue,
+		prevPosition: current,
+		lastTimestamp: now,
+		current: zeta < 1 ? underDampedPosition : criticallyDampedPosition,
+		velocity: zeta < 1 ? underDampedVelocity : criticallyDampedVelocity
+	};
+	advanceCache[cacheKey] = animationNode;
+	return animationNode;
+}
+const calculationCache = {};
+function springCalculation({ frame, fps, config = {} }) {
+	const from = 0;
+	const to = 1;
+	const cacheKey = [
+		frame,
+		fps,
+		config.damping,
+		config.mass,
+		config.overshootClamping,
+		config.stiffness
+	].join("-");
+	if (calculationCache[cacheKey]) return calculationCache[cacheKey];
+	let animation = {
+		lastTimestamp: 0,
+		current: from,
+		toValue: to,
+		velocity: 0,
+		prevPosition: 0
+	};
+	const frameClamped = Math.max(0, frame);
+	const unevenRest = frameClamped % 1;
+	for (let f = 0; f <= Math.floor(frameClamped); f++) {
+		if (f === Math.floor(frameClamped)) f += unevenRest;
+		const time = f / fps * 1e3;
+		animation = advance({
+			animation,
+			now: time,
+			config: {
+				...defaultSpringConfig,
+				...config
+			}
+		});
+	}
+	calculationCache[cacheKey] = animation;
+	return animation;
+}
+const measureCache = /* @__PURE__ */ new Map();
+function measureSpring({ fps, config = {}, threshold = .005 }) {
+	if (typeof threshold !== "number") throw new TypeError(`threshold must be a number, got ${threshold}`);
+	if (threshold === 0) return Infinity;
+	if (threshold === 1) return 0;
+	if (Number.isNaN(threshold)) throw new TypeError("Threshold is NaN");
+	if (!Number.isFinite(threshold)) throw new TypeError("Threshold is not finite");
+	if (threshold < 0) throw new TypeError("Threshold is below 0");
+	const cacheKey = [
+		fps,
+		config.damping,
+		config.mass,
+		config.overshootClamping,
+		config.stiffness,
+		threshold
+	].join("-");
+	if (measureCache.has(cacheKey)) return measureCache.get(cacheKey);
+	let frame = 0;
+	let finishedFrame = 0;
+	const calc = () => {
+		return springCalculation({
+			fps,
+			frame,
+			config
+		});
+	};
+	let animation = calc();
+	const calcDifference = () => {
+		return Math.abs(animation.current - animation.toValue);
+	};
+	let difference = calcDifference();
+	while (difference >= threshold) {
+		frame++;
+		animation = calc();
+		difference = calcDifference();
+	}
+	finishedFrame = frame;
+	for (let i = 0; i < 20; i++) {
+		frame++;
+		animation = calc();
+		difference = calcDifference();
+		if (difference >= threshold) {
+			i = 0;
+			finishedFrame = frame + 1;
+		}
+	}
+	measureCache.set(cacheKey, finishedFrame);
+	return finishedFrame;
+}
+function spring({ frame: passedFrame, fps, config = {}, from = 0, to = 1, durationInFrames: passedDurationInFrames, durationRestThreshold, delay = 0, reverse = false }) {
+	const needsToCalculateNaturalDuration = reverse || typeof passedDurationInFrames !== "undefined";
+	const naturalDuration = needsToCalculateNaturalDuration ? measureSpring({
+		fps,
+		config,
+		threshold: durationRestThreshold
+	}) : void 0;
+	const naturalDurationGetter = needsToCalculateNaturalDuration ? { get: () => naturalDuration } : { get: () => {
+		throw new Error("did not calculate natural duration");
+	} };
+	const delayProcessed = (reverse ? (passedDurationInFrames ?? naturalDurationGetter.get()) - passedFrame : passedFrame) + (reverse ? delay : -delay);
+	const durationProcessed = passedDurationInFrames === void 0 ? delayProcessed : delayProcessed / (passedDurationInFrames / naturalDurationGetter.get());
+	if (passedDurationInFrames && delayProcessed > passedDurationInFrames) return to;
+	const spr = springCalculation({
+		fps,
+		frame: durationProcessed,
+		config
+	});
+	const inner = config.overshootClamping ? to >= from ? Math.min(spr.current, to) : Math.max(spr.current, to) : spr.current;
+	return from === 0 && to === 1 ? inner : interpolate(inner, [0, 1], [from, to]);
+}
+const cache = /* @__PURE__ */ new Map();
+function getCacheKey(text, style) {
+	return JSON.stringify({
+		text,
+		...style
+	});
+}
+/**
+* Shared text measurer that uses SlugGeometry.measure for all environments.
+*/
+function measureText(text, style) {
+	const safeText = text ? String(text) : " ";
+	const cacheKey = getCacheKey(safeText, style);
+	const cached = cache.get(cacheKey);
+	if (cached) return cached;
+	const fontSize = style.fontSize ?? 48;
+	let fontFamily = style.fontFamily ?? "Inter";
+	if (SlugFontCache.isFailed(fontFamily)) fontFamily = "Inter";
+	const letterSpacing = style.letterSpacing ?? 0;
+	const calculatedLineHeight = style.lineHeight !== void 0 && style.lineHeight < 10 ? style.lineHeight * fontSize : style.lineHeight ?? fontSize * 1.2;
+	const slugFont = SlugFontCache.getFont(fontFamily, style.fontWeight, null);
+	const padding = style.padding ?? 0;
+	if (!slugFont) {
+		if (!SlugFontCache.isFailed(fontFamily)) {
+			const fontUrl = GetFontAssetUrl(fontFamily);
+			SlugFontCache.preloadSlugFont(null, fontFamily, fontUrl).catch(() => {});
+		}
+		const lines = safeText.split("\n");
+		let totalWrappedLines = 0;
+		const maxW = style.width !== void 0 ? Math.max(10, style.width - padding * 2) : 0;
+		for (const line of lines) if (maxW > 0) {
+			const estLineWidth = line.length * fontSize * .55 + letterSpacing * line.length;
+			const wrapCount = Math.max(1, Math.ceil(estLineWidth / maxW));
+			totalWrappedLines += wrapCount;
+		} else totalWrappedLines += 1;
+		const result$1 = {
+			width: style.width !== void 0 ? style.width : Math.ceil(safeText.length * fontSize * .6 + letterSpacing * safeText.length) + 2 + padding * 2,
+			height: style.height !== void 0 ? style.height : Math.ceil(totalWrappedLines * calculatedLineHeight) + 2 + padding * 2
+		};
+		cache.set(cacheKey, result$1);
+		return result$1;
+	}
+	const measured = SlugGeometry.measure(safeText, slugFont, fontSize, letterSpacing, calculatedLineHeight, style.width !== void 0 ? Math.max(0, style.width - padding * 2) : void 0, style.spans);
+	const result = {
+		width: style.width !== void 0 && !style.keepNaturalWidth ? style.width : Math.ceil(measured.width) + padding * 2 + 8,
+		height: style.height !== void 0 ? style.height : Math.ceil(measured.height) + padding * 2
+	};
+	cache.set(cacheKey, result);
+	return result;
+}
+/**
+* Async variant of measureText. Preloads the Slug font and yields to the browser.
+*/
+function measureTextAsync(text, style) {
+	let fontFamily = style.fontFamily ?? "Inter";
+	if (SlugFontCache.isFailed(fontFamily)) fontFamily = "Inter";
+	if (SlugFontCache.isFailed(fontFamily)) return Promise.resolve(measureText(text, style));
+	const fontUrl = GetFontAssetUrl(fontFamily);
+	return SlugFontCache.preloadSlugFont(null, fontFamily, fontUrl).then(() => measureText(text, style)).catch(() => measureText(text, style));
+}
+if (typeof globalThis !== "undefined") globalThis.__GATEWAI_DELAYS__ = globalThis.__GATEWAI_DELAYS__ || /* @__PURE__ */ new Set();
+const hasDelayRender = () => {
+	return useMemo(() => {
+		let nextHandle = 0;
+		return {
+			delayRender: (_msg) => {
+				const h = nextHandle++;
+				if (typeof globalThis !== "undefined") globalThis.__GATEWAI_DELAYS__.add(h);
+				return h;
+			},
+			continueRender: (h) => {
+				if (typeof globalThis !== "undefined") globalThis.__GATEWAI_DELAYS__.delete(h);
+			}
+		};
+	}, []);
+};
+/**
+* Preloads a font into the browser or headless environment.
+*/
+async function preloadFont(family, url) {
+	if (typeof window !== "undefined" && typeof FontFace !== "undefined") try {
+		const loadedFace = await new FontFace(family, `url(${url})`).load();
+		document.fonts.add(loadedFace);
+		await document.fonts.ready;
+	} catch (e) {
+		console.warn(`[preloadFont] Failed to load font "${family}" from ${url}:`, e);
+	}
+	else await registerHeadlessFont(family, url);
+}
+
+//#endregion
+//#region ../compositions/dist/layer-logic-B4xSPDvq.mjs
+const BASE_URL = getEnv("BASE_URL");
+const CDN_DOMAIN = getEnv("R2_CUSTOM_DOMAIN");
+/**
+* Compute render parameters for the CURRENT node only — does NOT recurse into
+* children. Each node in the VirtualMedia tree is responsible for exactly its
+* own operation; `SingleClipComposition` drives traversal via React recursion.
+*
+* This is the correct function to use inside the renderer.
+*/
+function computeRenderParams(vv) {
+	const op = vv.operation;
+	const baseMeta = getActiveMediaMetadata(vv);
+	const params = {
+		sourceUrl: void 0,
+		trimStartSec: 0,
+		trimEndSec: null,
+		speed: 1,
+		cropRegion: null,
+		flipH: false,
+		flipV: false,
+		rotation: 0,
+		effectiveDurationSec: 0,
+		mimeType: resolveMediaMimeType(vv) || null
+	};
+	switch (op.op) {
+		case "text":
+			params.sourceUrl = void 0;
+			break;
+		default:
+			params.sourceUrl = resolveMediaSourceUrl(vv);
+			break;
+	}
+	const sourceDurationSec = (baseMeta?.durationMs ?? 0) / 1e3;
+	params.effectiveDurationSec = ((params.trimEndSec ?? sourceDurationSec) - params.trimStartSec) / params.speed;
+	return params;
+}
+function secondsToFrames(seconds, fps) {
+	return Math.round(seconds * fps);
+}
+
+//#endregion
+//#region ../compositions/dist/index.mjs
+/**
+* normalizeTimeline recurses through the virtual media tree and "absorbs"
+* generic timeline-shifting operations into standard properties
+* of their children.
+*/
+function normalizeTimeline(vv, fps, context = { timeOffsetSec: 0 }) {
+	if (!vv) return vv;
+	const { operation, metadata = {}, children = [] } = vv;
+	const { timeOffsetSec, durationLimitMs } = context;
+	if (!operation) return {
+		...vv,
+		children: (children || []).map((child) => normalizeTimeline(child, fps, context))
+	};
+	const timeline = operation.timeline;
+	const segments = timeline?.segments || [];
+	let totalDurationMs = getActiveMediaMetadata(vv)?.durationMs ?? 0;
+	if (segments.length > 0) {
+		const totalSegmentsFrames = segments.reduce((acc, seg) => {
+			const durSec = seg.endSec != null ? seg.endSec - seg.startSec : 0;
+			return acc + Math.max(1, Math.round(durSec * fps));
+		}, 0);
+		if (totalSegmentsFrames > 0) totalDurationMs = totalSegmentsFrames / fps * 1e3;
+	}
+	const newOperation = { ...operation };
+	const rawStartFrame = timeline?.startFrame ?? newOperation.startFrame;
+	if (typeof rawStartFrame === "number") newOperation.startFrame = rawStartFrame - secondsToFrames(timeOffsetSec, fps);
+	const newMetadata = {
+		...metadata,
+		durationMs: totalDurationMs
+	};
+	const childContext = typeof rawStartFrame === "number" || newOperation.op === "compose" ? {
+		timeOffsetSec: 0,
+		durationLimitMs: void 0
+	} : {
+		timeOffsetSec,
+		durationLimitMs
+	};
+	return {
+		metadata: newMetadata,
+		operation: newOperation,
+		children: (children || []).map((child) => normalizeTimeline(child, fps, childContext))
+	};
+}
+let mediaLogger = {
+	info: (msg, ...args) => {
+		if (typeof msg === "object" && msg !== null) console.info("[AudioExtractor]", msg, ...args);
+		else console.info(`[AudioExtractor] ${msg}`, ...args);
+	},
+	warn: (msg, ...args) => {
+		if (typeof msg === "object" && msg !== null) console.warn("[AudioExtractor]", msg, ...args);
+		else console.warn(`[AudioExtractor] ${msg}`, ...args);
+	},
+	error: (msg, ...args) => {
+		if (typeof msg === "object" && msg !== null) console.error("[AudioExtractor]", msg, ...args);
+		else console.error(`[AudioExtractor] ${msg}`, ...args);
+	}
+};
+if (typeof window === "undefined" || typeof process !== "undefined" && process.versions?.node) import(
+	/* webpackIgnore: true */
+	/* @vite-ignore */
+	"@gitframes/server-utils"
+).then((m) => {
+	if (m.mediaLogger) mediaLogger = m.mediaLogger;
+}).catch(() => {});
+const yieldToMain$1 = () => {
+	if (typeof window === "undefined") return Promise.resolve();
+	const sched = globalThis.scheduler;
+	return typeof sched?.yield === "function" ? sched.yield() : new Promise((resolve) => setTimeout(resolve, 0));
+};
+const waitForDelayRender$1 = async (timeoutMs = 3e4) => {
+	await new Promise((resolve) => setTimeout(resolve, 100));
+	const start = Date.now();
+	return new Promise((resolve) => {
+		const check = () => {
+			const browserHandles = typeof window !== "undefined" && window.renderer_delayRenderHandles ? window.renderer_delayRenderHandles : [];
+			const globalDelays = typeof globalThis !== "undefined" ? globalThis.__GATEWAI_DELAYS__ : null;
+			const hasBrowserDelays = browserHandles.length > 0;
+			const hasGlobalDelays = globalDelays instanceof Set && globalDelays.size > 0;
+			if (!hasBrowserDelays && !hasGlobalDelays) {
+				resolve();
+				return;
+			}
+			if (Date.now() - start > timeoutMs) {
+				mediaLogger.warn(`[AudioExtractor] waitForDelayRender timed out waiting for handles: ${JSON.stringify({
+					browserHandles,
+					globalDelays: globalDelays ? Array.from(globalDelays) : []
+				})}`);
+				resolve();
+				return;
+			}
+			setTimeout(check, 50);
+		};
+		check();
+	});
+};
+/**
+* Decodes all audio samples from a given source URL into raw Float32 mono/stereo channel buffers.
+*/
+async function decodeAudioSource(url) {
+	mediaLogger.info(`[AudioExtractor] decodeAudioSource started for url: ${url}`);
+	try {
+		if (typeof window !== "undefined" && typeof window.document !== "undefined" && !(typeof process !== "undefined" && process.versions && process.versions.node)) {
+			mediaLogger.info(`[AudioExtractor] Browser detected. Fetching arrayBuffer for ${url}...`);
+			const AudioContextClass = window.AudioContext || window.webkitAudioContext;
+			if (!AudioContextClass) throw new Error("AudioContext is not supported in this browser");
+			const audioCtx = new AudioContextClass();
+			try {
+				const response = await fetch(url);
+				mediaLogger.info(`[AudioExtractor] Fetch response status for ${url}: ${response.status} (${response.statusText})`);
+				if (!response.ok) throw new Error(`Failed to fetch audio source: ${response.statusText}`);
+				const arrayBuffer = await response.arrayBuffer();
+				mediaLogger.info(`[AudioExtractor] Fetched ${arrayBuffer.byteLength} bytes. Decoding audio data...`);
+				const audioBuffer = await audioCtx.decodeAudioData(arrayBuffer);
+				mediaLogger.info(`[AudioExtractor] Decoded successfully: ${audioBuffer.numberOfChannels} channels, sampleRate: ${audioBuffer.sampleRate}, duration: ${audioBuffer.duration}s`);
+				const channels = [];
+				for (let c = 0; c < audioBuffer.numberOfChannels; c++) channels.push(new Float32Array(audioBuffer.getChannelData(c)));
+				return {
+					channels,
+					sampleRate: audioBuffer.sampleRate
+				};
+			} finally {
+				audioCtx.close();
+				mediaLogger.info(`[AudioExtractor] AudioContext closed for ${url}`);
+			}
+		}
+		let inputAcquired = false;
+		try {
+			mediaLogger.info(`[AudioExtractor] Server / Node.js detected. Acquiring from inputStore for ${url}...`);
+			const input = await inputStore.acquire(url);
+			inputAcquired = true;
+			mediaLogger.info(`[AudioExtractor] inputStore acquired. Retrieving primary audio track...`);
+			const track = await input.getPrimaryAudioTrack();
+			if (!track) {
+				mediaLogger.warn(`[AudioExtractor] No primary audio track found in input for ${url}`);
+				return null;
+			}
+			const generator = new AudioSampleSink(track).samples(0);
+			const decodedPlanes = [];
+			let totalFrames = 0;
+			let sampleRate = 48e3;
+			let numChannels = 1;
+			mediaLogger.info(`[AudioExtractor] Starting mediabunny generator loop for ${url}...`);
+			for await (const sample of generator) {
+				sampleRate = sample.sampleRate;
+				numChannels = sample.numberOfChannels;
+				const sampleFrames = sample.numberOfFrames;
+				if (decodedPlanes.length === 0) for (let c = 0; c < numChannels; c++) decodedPlanes.push([]);
+				for (let c = 0; c < numChannels; c++) {
+					let planeBuffer;
+					try {
+						const allocSize = sample.allocationSize({
+							planeIndex: c,
+							format: "f32-planar"
+						});
+						planeBuffer = new Float32Array(allocSize / 4);
+						sample.copyTo(planeBuffer, {
+							planeIndex: c,
+							format: "f32-planar"
+						});
+					} catch {
+						const allocSize = sample.allocationSize({ planeIndex: c });
+						if (sample.format === "s16" || sample.format === "s16-planar") {
+							const int16Buffer = new Int16Array(allocSize / 2);
+							sample.copyTo(int16Buffer, { planeIndex: c });
+							planeBuffer = new Float32Array(int16Buffer.length);
+							for (let i = 0; i < int16Buffer.length; i++) planeBuffer[i] = (int16Buffer[i] ?? 0) / 32768;
+						} else if (sample.format === "s32" || sample.format === "s32-planar") {
+							const int32Buffer = new Int32Array(allocSize / 4);
+							sample.copyTo(int32Buffer, { planeIndex: c });
+							planeBuffer = new Float32Array(int32Buffer.length);
+							for (let i = 0; i < int32Buffer.length; i++) planeBuffer[i] = (int32Buffer[i] ?? 0) / 2147483648;
+						} else if (sample.format === "u8" || sample.format === "u8-planar") {
+							const u8Buffer = new Uint8Array(allocSize);
+							sample.copyTo(u8Buffer, { planeIndex: c });
+							planeBuffer = new Float32Array(u8Buffer.length);
+							for (let i = 0; i < u8Buffer.length; i++) planeBuffer[i] = ((u8Buffer[i] ?? 128) - 128) / 128;
+						} else {
+							planeBuffer = new Float32Array(allocSize / 4);
+							sample.copyTo(planeBuffer, { planeIndex: c });
+						}
+					}
+					decodedPlanes[c].push(planeBuffer);
+				}
+				totalFrames += sampleFrames;
+				sample.close();
+			}
+			mediaLogger.info(`[AudioExtractor] Generator loop finished. Decoded total frames: ${totalFrames}`);
+			if (totalFrames === 0 || decodedPlanes.length === 0) return null;
+			return {
+				channels: decodedPlanes.map((planes) => {
+					const merged = new Float32Array(totalFrames);
+					let offset = 0;
+					for (const plane of planes) {
+						merged.set(plane, offset);
+						offset += plane.length;
+					}
+					return merged;
+				}),
+				sampleRate
+			};
+		} catch (err) {
+			if (typeof process !== "undefined" && process.versions?.node) try {
+				const { execSync } = await import("node:child_process");
+				const stdout = execSync(`ffmpeg -v error -i "${url}" -f f32le -ar 48000 -ac 2 pipe:1`, { maxBuffer: 100 * 1024 * 1024 });
+				const totalSamples = stdout.byteLength / 4;
+				const numFrames = totalSamples / 2;
+				const interleaved = new Float32Array(stdout.buffer, stdout.byteOffset, totalSamples);
+				const left = new Float32Array(numFrames);
+				const right = new Float32Array(numFrames);
+				for (let i = 0; i < numFrames; i++) {
+					left[i] = interleaved[i * 2];
+					right[i] = interleaved[i * 2 + 1];
+				}
+				return {
+					channels: [left, right],
+					sampleRate: 48e3
+				};
+			} catch (ffmpegErr) {
+				mediaLogger.warn({ ffmpegErr }, `[AudioExtractor] ffmpeg fallback decode failed for ${url}`);
+			}
+			mediaLogger.error({ err }, `[AudioExtractor] Failed to decode source ${url}`);
+			return null;
+		} finally {
+			if (inputAcquired) inputStore.release(url);
+		}
+	} catch (err) {
+		mediaLogger.error({ err }, `[AudioExtractor] Failed to decode source ${url}`);
+		return null;
+	}
+}
+/**
+* Resamples a PCM buffer using linear interpolation to target sample rate & speed.
+*/
+async function resampleAndStretchPCM(inputChannel, sourceSampleRate, targetSampleRate, speed, outputLength, trimOffsetSamples) {
+	const output = new Float32Array(outputLength);
+	const factor = sourceSampleRate / targetSampleRate * speed;
+	const YIELD_INTERVAL = 1e5;
+	for (let i = 0; i < outputLength; i++) {
+		if (i > 0 && i % YIELD_INTERVAL === 0) await yieldToMain$1();
+		const srcIndex = trimOffsetSamples + i * factor;
+		const indexFloor = Math.floor(srcIndex);
+		const indexCeil = Math.ceil(srcIndex);
+		if (indexFloor < 0) {
+			output[i] = 0;
+			continue;
+		}
+		if (indexFloor >= inputChannel.length) break;
+		const weight = srcIndex - indexFloor;
+		const sampleFloor = inputChannel[indexFloor] ?? 0;
+		const val = sampleFloor + weight * ((indexCeil >= 0 && indexCeil < inputChannel.length ? inputChannel[indexCeil] ?? sampleFloor : sampleFloor) - sampleFloor);
+		output[i] = Number.isFinite(val) ? val : 0;
+	}
+	return output;
+}
+/**
+* Recursively parses the VirtualMediaData tree and mixes all active audio tracks
+* into a single unified stereo PCM stream (Float32Array channels).
+*/
+async function mixAudioTracks(virtualMedia, fps, targetSampleRate = 48e3, device, renderId) {
+	mediaLogger.info(`[AudioExtractor] mixAudioTracks started. FPS: ${fps}, targetSampleRate: ${targetSampleRate}`);
+	await waitForDelayRender$1();
+	shaderStore.registerSignalsFromComposition(renderId, virtualMedia);
+	const durationMs = getActiveMediaMetadata(virtualMedia)?.durationMs || 1e3;
+	const totalDurationSec = durationMs / 1e3;
+	const totalTargetSamples = Math.ceil(totalDurationSec * targetSampleRate);
+	mediaLogger.info(`[AudioExtractor] Composition total duration: ${durationMs}ms (${totalDurationSec}s). Total mixed samples to allocate: ${totalTargetSamples}`);
+	const outputLeft = new Float32Array(totalTargetSamples);
+	const outputRight = new Float32Array(totalTargetSamples);
+	const mixedChannels = [outputLeft, outputRight];
+	const decodedCache = /* @__PURE__ */ new Map();
+	async function traverse(node, inheritedSeekSec, inheritedClockFrames, inheritedVolume, inheritedSpeed, inheritedDurationFrames) {
+		if (!node) return null;
+		const op = node.operation;
+		if (!op) {
+			const durationMs$1 = getActiveMediaMetadata(node)?.durationMs ?? 0;
+			const durationFrames = Math.round(durationMs$1 / 1e3 * fps);
+			const actualDurationFrames = inheritedDurationFrames !== null ? durationFrames > 0 ? Math.min(inheritedDurationFrames, durationFrames) : inheritedDurationFrames : durationFrames;
+			const localSamplesCount$1 = Math.ceil(actualDurationFrames / fps * targetSampleRate);
+			if (localSamplesCount$1 <= 0) return null;
+			const localChannels$1 = [new Float32Array(localSamplesCount$1), new Float32Array(localSamplesCount$1)];
+			for (const child of node.children) {
+				const childChannels = await traverse(child, inheritedSeekSec, inheritedClockFrames, inheritedVolume, inheritedSpeed, actualDurationFrames);
+				if (childChannels) {
+					const childOp = child.operation;
+					const childStartFrame = childOp?.startFrame ?? childOp?.timeline?.startFrame ?? 0;
+					const childStartSample = Math.round(childStartFrame / fps * targetSampleRate);
+					for (let c = 0; c < 2; c++) {
+						const dest = localChannels$1[c];
+						const src = childChannels[c];
+						const len = Math.min(src.length, dest.length - childStartSample);
+						for (let i = 0; i < len; i++) if (childStartSample + i >= 0) dest[childStartSample + i] += src[i];
+					}
+				}
+			}
+			return localChannels$1;
+		}
+		const volume = inheritedVolume * (op.volume ?? 1) * (op.opacity === 0 ? 0 : 1) * (op.muted ? 0 : 1);
+		const speedMultiplier = inheritedSpeed;
+		const localClockFrames = inheritedClockFrames + (op.startFrame ?? op.timeline?.startFrame ?? 0);
+		const segments = op.timeline?.segments || [];
+		const nodeDurationMs = getActiveMediaMetadata(node)?.durationMs ?? 0;
+		const nodeDurationFrames = Math.round(nodeDurationMs / 1e3 * fps);
+		const nodeActualDurationFrames = inheritedDurationFrames !== null ? nodeDurationFrames > 0 ? Math.min(inheritedDurationFrames, nodeDurationFrames) : inheritedDurationFrames : nodeDurationFrames;
+		const localSamplesCount = Math.ceil(nodeActualDurationFrames / fps * targetSampleRate);
+		if (localSamplesCount <= 0) return null;
+		const localLeft = new Float32Array(localSamplesCount);
+		const localRight = new Float32Array(localSamplesCount);
+		const localChannels = [localLeft, localRight];
+		const processSegment = async (seg, windowStartFrameOffset) => {
+			const totalSeekSec = inheritedSeekSec + (seg ? seg.startSec : 0);
+			const totalClockFrames = localClockFrames + windowStartFrameOffset;
+			let segDurationFrames = 0;
+			if (seg) segDurationFrames = Math.max(1, Math.round(((seg.endSec ?? 0) - seg.startSec) * fps));
+			else segDurationFrames = nodeDurationFrames;
+			const actualDurationFrames = inheritedDurationFrames !== null ? Math.min(inheritedDurationFrames, segDurationFrames) : segDurationFrames;
+			const segmentStartSample = Math.round(windowStartFrameOffset / fps * targetSampleRate);
+			if (op.op === "source") {
+				const mediaType = getMediaType(node);
+				const params = computeRenderParams(node);
+				if (params.sourceUrl && (mediaType === "Audio" || mediaType === "Video") && volume > 0) {
+					const finalSpeed = Math.max(.5, speedMultiplier * (Number(params.speed) || 1));
+					const effectiveTrimSec = Math.max(0, (Number(params.trimStartSec) || 0) + totalSeekSec);
+					let decoded = decodedCache.get(params.sourceUrl);
+					if (decoded === void 0) {
+						decoded = await decodeAudioSource(params.sourceUrl);
+						decodedCache.set(params.sourceUrl, decoded);
+					}
+					if (decoded) {
+						const clipDurationSec = actualDurationFrames / fps;
+						const clipSamplesCount = Math.min(localSamplesCount - segmentStartSample, Math.ceil(clipDurationSec * targetSampleRate));
+						if (clipSamplesCount > 0 && segmentStartSample < localSamplesCount) {
+							const trimOffsetSamples = Math.round(effectiveTrimSec * decoded.sampleRate);
+							const srcLeft = decoded.channels[0];
+							const srcRight = decoded.channels.length > 1 ? decoded.channels[1] : decoded.channels[0];
+							const stretchedLeft = await resampleAndStretchPCM(srcLeft, decoded.sampleRate, targetSampleRate, finalSpeed, clipSamplesCount, trimOffsetSamples);
+							const stretchedRight = await resampleAndStretchPCM(srcRight, decoded.sampleRate, targetSampleRate, finalSpeed, clipSamplesCount, trimOffsetSamples);
+							for (let i = 0; i < clipSamplesCount; i++) {
+								const outIndex = segmentStartSample + i;
+								localLeft[outIndex] += stretchedLeft[i] * volume;
+								localRight[outIndex] += stretchedRight[i] * volume;
+							}
+						}
+					}
+					await yieldToMain$1();
+				}
+			}
+			if (node.children) for (const child of node.children) {
+				const childChannels = await traverse(child, totalSeekSec, totalClockFrames, volume, speedMultiplier, actualDurationFrames);
+				if (childChannels) {
+					const childOp = child.operation;
+					const childStartFrame = childOp?.startFrame ?? childOp?.timeline?.startFrame ?? 0;
+					const destStartSample = segmentStartSample + Math.round(childStartFrame / fps * targetSampleRate);
+					for (let c = 0; c < 2; c++) {
+						const dest = localChannels[c];
+						const src = childChannels[c];
+						const len = Math.min(src.length, dest.length - destStartSample);
+						for (let i = 0; i < len; i++) if (destStartSample + i >= 0) dest[destStartSample + i] += src[i];
+					}
+				}
+			}
+			const pluginProcessor = audioRegistry.get(op.op);
+			if (pluginProcessor) try {
+				const clipDurationSec = actualDurationFrames / fps;
+				const clipSamplesCount = Math.min(localSamplesCount - segmentStartSample, Math.ceil(clipDurationSec * targetSampleRate));
+				if (clipSamplesCount > 0 && segmentStartSample < localSamplesCount && segmentStartSample >= 0) await pluginProcessor(localChannels.map((ch) => ch.subarray(segmentStartSample, segmentStartSample + clipSamplesCount)), targetSampleRate, node, {
+					device,
+					frame: totalClockFrames,
+					fps,
+					renderId,
+					elapsedMs: (totalClockFrames / fps + totalSeekSec) * 1e3,
+					durationMs: getActiveMediaMetadata(node)?.durationMs ?? void 0
+				});
+			} catch (pluginErr) {
+				mediaLogger.error({ err: pluginErr }, `[AudioExtractor] Custom plugin for operation '${op.op}' failed`);
+			}
+		};
+		if (segments.length > 0) {
+			let currentStart = 0;
+			for (const seg of segments) {
+				const durSec = (seg.endSec ?? 0) - seg.startSec;
+				const durFrames = Math.max(1, Math.round(durSec * fps));
+				await processSegment(seg, currentStart);
+				currentStart += durFrames;
+			}
+		} else await processSegment(null, 0);
+		return localChannels;
+	}
+	const rootChannels = await traverse(normalizeTimeline(virtualMedia, fps), 0, 0, 1, 1, null);
+	if (rootChannels) for (let c = 0; c < 2; c++) {
+		const dest = mixedChannels[c];
+		const src = rootChannels[c];
+		const len = Math.min(src.length, dest.length);
+		for (let i = 0; i < len; i++) dest[i] = src[i];
+	}
+	decodedCache.clear();
+	let mixPeak = 0;
+	for (let i = 0; i < totalTargetSamples; i++) {
+		const l = Math.abs(outputLeft[i] ?? 0);
+		const r = Math.abs(outputRight[i] ?? 0);
+		if (l > mixPeak) mixPeak = l;
+		if (r > mixPeak) mixPeak = r;
+	}
+	const autoGain = mixPeak > .95 ? .92 / mixPeak : 1;
+	for (let i = 0; i < totalTargetSamples; i++) {
+		const l = (outputLeft[i] ?? 0) * autoGain;
+		const r = (outputRight[i] ?? 0) * autoGain;
+		outputLeft[i] = Number.isFinite(l) ? Math.tanh(l) : 0;
+		outputRight[i] = Number.isFinite(r) ? Math.tanh(r) : 0;
+	}
+	return {
+		channels: mixedChannels,
+		sampleRate: targetSampleRate
+	};
+}
+const RenderTimelineContext = createContext({
+	accumulatedSeekOffsetSec: 0,
+	accumulatedClockOffsetSec: 0
+});
+const RenderTimelineProvider = RenderTimelineContext.Provider;
+const AudioProcessorContext = React.createContext({ processors: [] });
+const DEFAULT_STATE = {
+	frame: 0,
+	fps: 30,
+	isPlaying: false
+};
+var CompositionStateStore = class {
+	states = /* @__PURE__ */ new Map();
+	listeners = /* @__PURE__ */ new Map();
+	setState(key, frame, fps, isPlaying) {
+		const current = this.states.get(key);
+		const resolvedPlaying = isPlaying !== void 0 ? isPlaying : current?.isPlaying ?? false;
+		if (current?.frame === frame && current?.fps === fps && current?.isPlaying === resolvedPlaying) return;
+		this.states.set(key, {
+			frame,
+			fps,
+			isPlaying: resolvedPlaying
+		});
+		this.notify(key);
+	}
+	getState(key) {
+		if (this.states.has(key)) return this.states.get(key);
+		for (const [storeKey, value] of this.states.entries()) if (key.startsWith(storeKey)) return value;
+		return DEFAULT_STATE;
+	}
+	subscribe(key, listener) {
+		if (!this.listeners.has(key)) this.listeners.set(key, /* @__PURE__ */ new Set());
+		this.listeners.get(key).add(listener);
+		return () => {
+			const set = this.listeners.get(key);
+			set?.delete(listener);
+			if (set?.size === 0) {
+				this.listeners.delete(key);
+				this.states.delete(key);
+			}
+		};
+	}
+	clearKey(key) {
+		this.states.delete(key);
+	}
+	notify(key) {
+		for (const [listenerKey, set] of this.listeners.entries()) if (listenerKey === key || listenerKey.startsWith(key)) set.forEach((l) => l());
+	}
+};
+const compositionStateStore = new CompositionStateStore();
+const useCompositionState = (renderId) => {
+	if (typeof globalThis !== "undefined" && globalThis.__IS_HEADLESS_RENDERER__ === true) return compositionStateStore.getState(renderId);
+	return useSyncExternalStore(useCallback((onStoreChange) => compositionStateStore.subscribe(renderId, onStoreChange), [renderId]), () => compositionStateStore.getState(renderId), () => DEFAULT_STATE);
+};
+const segmentRangeCache = /* @__PURE__ */ new WeakMap();
+function getCachedSegmentRanges(segments, fps) {
+	const cached = segmentRangeCache.get(segments);
+	if (cached && cached.fps === fps) return cached.ranges;
+	let currentStart = 0;
+	const ranges = segments.map((seg) => {
+		const durSec = (seg.endSec ?? 0) - seg.startSec;
+		const durFrames = Math.max(1, Math.round(durSec * fps));
+		const start = currentStart;
+		currentStart += durFrames;
+		return {
+			seg,
+			start,
+			duration: durFrames
+		};
+	});
+	segmentRangeCache.set(segments, {
+		fps,
+		ranges
+	});
+	return ranges;
+}
+const frameCtxPool = [];
+function acquireFrameContext() {
+	return frameCtxPool.pop() ?? {};
+}
+/**
+* Effect operations carry every config field as a signal. Hand node renderers
+* the plain value for this frame (nested objects/arrays included), keeping only
+* GPU-bound signals intact since those are consumed as textures.
+*/
+function resolveSignalOperation(virtualMedia, frameCtx) {
+	const op = virtualMedia.operation;
+	const resolved = { ...op };
+	for (const [key, sig] of Object.entries(op.signals)) if (isSignal(sig) && !sig.gpuBinding) resolved[key] = sig.get(frameCtx);
+	return {
+		...virtualMedia,
+		operation: resolved
+	};
+}
+async function drawCompositionTree(ctx, encoder, targetView, targetTexture, targetWidth, targetHeight, virtualMedia, props, inheritedSeekOffset = 0, inheritedClockOffset = 0) {
+	const fps = props.fps ?? 24;
+	const op = virtualMedia.operation;
+	if (!op) return;
+	const isCompositor = op.op === "Compositor";
+	const frame = props.frame ?? 0;
+	const segments = op.timeline?.segments || [];
+	const localFrame = frame - (op.startFrame ?? op.timeline?.startFrame ?? 0);
+	const isTimelineProvider = op.timeline !== void 0 || op.startFrame !== void 0 || op.op === "compose";
+	const resolvedDurationMs = isTimelineProvider ? getActiveMediaMetadata(virtualMedia)?.durationMs ?? props.durationMs ?? void 0 : props.durationMs ?? getActiveMediaMetadata(virtualMedia)?.durationMs ?? void 0;
+	if (!(op.op === "source" || op.op === "text" || op.op === "caption")) updateClockSignals(frame, fps, resolvedDurationMs);
+	const frameCtx = acquireFrameContext();
+	frameCtx.frame = frame;
+	frameCtx.fps = fps;
+	frameCtx.time = fps > 0 ? frame / fps : 0;
+	frameCtx.duration = (resolvedDurationMs ?? 0) / 1e3;
+	frameCtx.durationMs = resolvedDurationMs ?? 0;
+	frameCtx.progress = resolvedDurationMs && resolvedDurationMs > 0 ? Math.max(0, Math.min(1, frame / fps * 1e3 / resolvedDurationMs)) : 0;
+	frameCtx.deltaTime = fps > 0 ? 1 / fps : 0;
+	const resolvedElapsedMs = isTimelineProvider ? (localFrame !== void 0 && fps !== void 0 ? localFrame / fps * 1e3 : void 0) ?? props.elapsedMs : props.elapsedMs ?? (localFrame !== void 0 && fps !== void 0 ? localFrame / fps * 1e3 : void 0);
+	const effectiveLocalFrame = localFrame + Math.round(inheritedSeekOffset * fps);
+	let activeSeg = null;
+	let windowStartFrame = 0;
+	if (segments.length > 0) {
+		const active = getCachedSegmentRanges(segments, fps).find(({ start, duration }) => effectiveLocalFrame >= start && effectiveLocalFrame < start + duration);
+		if (active) {
+			activeSeg = active.seg;
+			windowStartFrame = active.start;
+		} else return;
+	}
+	const segmentLocalFrame = localFrame - windowStartFrame;
+	const accumulatedSeekOffsetSec = inheritedSeekOffset + (activeSeg ? activeSeg.startSec - windowStartFrame / fps : 0);
+	const accumulatedClockOffsetSec = inheritedClockOffset + windowStartFrame / fps;
+	if (typeof op.onRequestFrame === "function") op.onRequestFrame(frameCtx);
+	else if (op.effect && typeof op.effect.notifyFrame === "function") op.effect.notifyFrame(frameCtx);
+	const CustomRenderer = webgpuRegistry.get(op.op);
+	if (CustomRenderer) {
+		if (op.signals) virtualMedia = resolveSignalOperation(virtualMedia, frameCtx);
+		const inputs = op?.inputs;
+		if (inputs) {
+			for (const entry of Object.values(inputs)) if (entry?.connectionValid && entry?.outputItem?.type === "LUT") {
+				const lutVirtualMedia = entry.outputItem.data;
+				if (lutVirtualMedia && typeof lutVirtualMedia === "object" && lutVirtualMedia.operation) {
+					const lutW = lutVirtualMedia.metadata?.width ?? targetWidth;
+					const lutH = lutVirtualMedia.metadata?.height ?? targetHeight;
+					const dummyTex = ctx.renderer.getTemporaryTexture(lutW, lutH);
+					await drawCompositionTree(ctx, encoder, dummyTex.createView(), dummyTex, lutW, lutH, lutVirtualMedia, {
+						...props,
+						virtualMedia: lutVirtualMedia
+					}, accumulatedSeekOffsetSec, accumulatedClockOffsetSec);
+				}
+			} else if (entry?.connectionValid && entry?.outputItem?.type === "Signal") {
+				const sigData = entry.outputItem.data;
+				if (sigData && typeof sigData === "object") await signalRegistry.ensureAudioSourcesExtracted(ctx.device, sigData.signalConfig ?? sigData, fps, props.renderId);
+			}
+		}
+		const pass = ctx.renderer.beginFrame(encoder, targetView, {
+			r: 0,
+			g: 0,
+			b: 0,
+			a: 0
+		}, targetWidth, targetHeight, "load");
+		let passEnded = false;
+		const originalEnd = pass.end.bind(pass);
+		pass.end = () => {
+			if (!passEnded) {
+				originalEnd();
+				passEnded = true;
+			}
+		};
+		const renderArgs = {
+			ctx,
+			encoder,
+			pass,
+			targetView,
+			targetTexture,
+			targetWidth,
+			targetHeight,
+			props: {
+				...props,
+				virtualMedia,
+				inheritedSeekOffset: accumulatedSeekOffsetSec,
+				inheritedClockOffset: accumulatedClockOffsetSec,
+				durationMs: resolvedDurationMs,
+				elapsedMs: resolvedElapsedMs
+			},
+			drawChild: async (child, overrides, targetViewOverride, targetTextureOverride, targetWidthOverride, targetHeightOverride) => {
+				await drawCompositionTree(ctx, encoder, targetViewOverride ?? targetView, targetTextureOverride ?? targetTexture, targetWidthOverride ?? targetWidth, targetHeightOverride ?? targetHeight, child, {
+					...props,
+					durationMs: resolvedDurationMs,
+					elapsedMs: resolvedElapsedMs,
+					virtualMedia: child,
+					...overrides,
+					excludeTextures: [
+						...props.excludeTextures || [],
+						...overrides?.excludeTextures || [],
+						targetTextureOverride ?? targetTexture
+					]
+				}, isCompositor ? 0 : accumulatedSeekOffsetSec, accumulatedClockOffsetSec);
+			}
+		};
+		await CustomRenderer(renderArgs);
+		renderArgs.pass.end();
+		return;
+	}
+	if (op.op === "LUT") return;
+	if (op.op === "Signal" || op.op === "SignalMath" || op.dataType === "Signal") {
+		const pass = ctx.renderer.beginFrame(encoder, targetView, {
+			r: 0,
+			g: 0,
+			b: 0,
+			a: 0
+		}, targetWidth, targetHeight, "load");
+		await drawSignalNode(ctx, encoder, pass, {
+			nodeId: op.nodeId || op.signalConfig?.nodeId || props.renderId,
+			func: op.func,
+			amplitude: Number(op.amplitude ?? 1),
+			frequency: Number(op.frequency ?? 1),
+			phase: Number(op.phase ?? 0),
+			offset: Number(op.offset ?? 0),
+			signalConfig: {
+				...op.signalConfig,
+				...op
+			},
+			frame,
+			fps,
+			elapsedMs: resolvedElapsedMs,
+			durationMs: resolvedDurationMs ?? 0,
+			width: targetWidth,
+			height: targetHeight,
+			drawChild: async (child, childProps, childView, childTex, childW, childH) => {
+				await drawCompositionTree(ctx, encoder, childView, childTex, childW, childH, child, {
+					...props,
+					durationMs: resolvedDurationMs,
+					elapsedMs: resolvedElapsedMs,
+					...childProps,
+					excludeTextures: [
+						...props.excludeTextures || [],
+						...childProps?.excludeTextures || [],
+						childTex
+					]
+				});
+			}
+		});
+		pass.end();
+		return;
+	}
+	if (op.op === "source" || op.op === "text" || op.op === "caption") {
+		const pass = ctx.renderer.beginFrame(encoder, targetView, {
+			r: 0,
+			g: 0,
+			b: 0,
+			a: 0
+		}, targetWidth, targetHeight, "load");
+		if (op.op === "source") {
+			const mediaType = getMediaType(virtualMedia);
+			const params = computeRenderParams(virtualMedia);
+			if (params.sourceUrl) {
+				const containerWidth = props.containerWidth ?? ctx.surface.width;
+				const containerHeight = props.containerHeight ?? ctx.surface.height;
+				if (mediaType === "Image") await drawImageNode(ctx, pass, {
+					src: params.sourceUrl,
+					dstRect: {
+						x: 0,
+						y: 0,
+						width: containerWidth,
+						height: containerHeight
+					},
+					opacity: Number(op.opacity ?? 1) * Number(props.opacity ?? 1),
+					isHeadless: props.isHeadless
+				});
+				else if (mediaType === "SVG") await drawSvgNode(ctx, pass, {
+					src: params.sourceUrl,
+					dstRect: {
+						x: 0,
+						y: 0,
+						width: containerWidth,
+						height: containerHeight
+					},
+					opacity: Number(op.opacity ?? 1),
+					isHeadless: props.isHeadless
+				});
+				else if (mediaType === "Lottie") await drawLottieNode(ctx, pass, {
+					src: params.sourceUrl,
+					dstRect: {
+						x: 0,
+						y: 0,
+						width: containerWidth,
+						height: containerHeight
+					},
+					frame: segmentLocalFrame + Math.round(accumulatedSeekOffsetSec * fps),
+					fps,
+					opacity: Number(op.opacity ?? 1) * Number(props.opacity ?? 1),
+					isHeadless: props.isHeadless
+				});
+				else if (mediaType === "GIF") await drawGifNode(ctx, pass, {
+					src: params.sourceUrl,
+					dstRect: {
+						x: 0,
+						y: 0,
+						width: containerWidth,
+						height: containerHeight
+					},
+					frame: segmentLocalFrame + Math.round(accumulatedSeekOffsetSec * fps),
+					fps,
+					opacity: Number(op.opacity ?? 1) * Number(props.opacity ?? 1),
+					isHeadless: props.isHeadless
+				});
+				else if (mediaType === "Text") {
+					const opText = { ...op };
+					drawParagraphNode(ctx, pass, {
+						text: opText.text || "",
+						dstRect: {
+							x: Number(opText.x ?? 0),
+							y: Number(opText.y ?? 0),
+							width: Number(opText.width ?? containerWidth),
+							height: Number(opText.height ?? containerHeight)
+						},
+						fontFamily: opText.fontFamily,
+						fontSize: Number(opText.fontSize ?? 48),
+						color: opText.fill ?? opText.color ?? "white",
+						width: opText.width ? Number(opText.width) : void 0,
+						height: opText.height ? Number(opText.height) : void 0,
+						lineHeight: Number(opText.lineHeight ?? 1.2),
+						align: opText.align,
+						fontWeight: opText.fontWeight,
+						fontStyle: opText.fontStyle,
+						letterSpacing: opText.letterSpacing,
+						shadows: opText.shadows,
+						textBackgroundColor: opText.textBackgroundColor,
+						borderRadius: opText.borderRadius != null ? Number(opText.borderRadius) : void 0,
+						padding: opText.padding != null ? Number(opText.padding) : void 0,
+						stroke: opText.stroke,
+						strokeWidth: opText.strokeWidth ?? opText.strokeThickness ? Number(opText.strokeWidth ?? opText.strokeThickness) : void 0,
+						strokeAlign: opText.strokeAlign,
+						opacity: Number(opText.opacity ?? 1) * Number(props.opacity ?? 1),
+						isHeadless: props.isHeadless,
+						animation: opText.animation ?? opText.textAnimation,
+						animators: opText.animators,
+						pathOptions: opText.pathOptions,
+						typewriter: opText.typewriter,
+						marquee: opText.marquee,
+						textProgress: opText.textProgress != null ? Number(opText.textProgress) : void 0,
+						signals: props.signals ?? opText.signals,
+						firstMargin: opText.firstMargin != null ? Number(opText.firstMargin) : void 0,
+						lastMargin: opText.lastMargin != null ? Number(opText.lastMargin) : void 0,
+						baselineShift: opText.baselineShift != null ? Number(opText.baselineShift) : void 0,
+						frame: localFrame,
+						fps,
+						durationMs: resolvedDurationMs,
+						elapsedMs: resolvedElapsedMs,
+						isVideoMode: props.isVideoMode
+					});
+				} else if (mediaType === "Video") {
+					const finalPlaybackRate = Math.max(.01, (Number(props.playbackRateOverride) || 1) * (Number(params.speed) || 1));
+					const effectiveTrimSec = Math.max(0, (Number(props.trimStartOverride) || 0) + (Number(params.trimStartSec) || 0) + accumulatedSeekOffsetSec);
+					const rawTimestampSec = segmentLocalFrame / fps * finalPlaybackRate + effectiveTrimSec;
+					const timestampSec = Math.max(0, Number.isFinite(rawTimestampSec) ? rawTimestampSec : 0);
+					await drawVideoNode(ctx, pass, {
+						nodeId: props.renderId,
+						frameKey: `${props.renderId ?? "video"}-${params.sourceUrl}-${Math.round(timestampSec * fps)}`,
+						sourceUrl: params.sourceUrl,
+						timestampSec,
+						dstRect: {
+							x: 0,
+							y: 0,
+							width: containerWidth,
+							height: containerHeight
+						},
+						opacity: Number(op.opacity ?? 1) * Number(props.opacity ?? 1),
+						isHeadless: props.isHeadless,
+						isPlaying: props.isPlaying,
+						forceWait: props.forceWait
+					});
+				} else if (mediaType === "Caption") {
+					const opCap = {
+						...op,
+						...props
+					};
+					await drawCaptionNode(ctx, pass, {
+						renderId: props.renderId,
+						src: params.sourceUrl,
+						dstRect: {
+							x: 0,
+							y: 0,
+							width: containerWidth,
+							height: containerHeight
+						},
+						frame: localFrame,
+						fps,
+						fontFamily: opCap.fontFamily,
+						fontSize: Number(opCap.fontSize ?? 48),
+						color: opCap.fill ?? opCap.color ?? "white",
+						lineHeight: Number(opCap.lineHeight ?? 1.2),
+						align: opCap.align === "start" ? "left" : opCap.align === "end" ? "right" : opCap.align ?? "center",
+						textAlignVertical: opCap.verticalAlign ?? opCap.textAlignVertical,
+						fontWeight: opCap.fontWeight,
+						fontStyle: opCap.fontStyle,
+						letterSpacing: opCap.letterSpacing,
+						shadows: opCap.shadows,
+						textBackgroundColor: opCap.background ?? opCap.textBackgroundColor,
+						borderRadius: (opCap.borderRadius ?? opCap.strokeRadius) != null ? Number(opCap.borderRadius ?? opCap.strokeRadius) : void 0,
+						strokeRadius: (opCap.strokeRadius ?? opCap.borderRadius) != null ? Number(opCap.strokeRadius ?? opCap.borderRadius) : void 0,
+						stroke: opCap.stroke,
+						strokeWidth: (opCap.strokeWidth ?? opCap.strokeThickness) != null ? Number(opCap.strokeWidth ?? opCap.strokeThickness) : void 0,
+						maxWidth: opCap.maxWidth,
+						padding: opCap.padding != null ? Number(opCap.padding) : void 0,
+						opacity: Number(opCap.opacity ?? 1) * Number(props.opacity ?? 1),
+						isHeadless: props.isHeadless,
+						isVideoMode: props.isVideoMode
+					});
+				}
+			}
+		} else if (op.op === "text") {
+			const opText = { ...op };
+			const containerWidth = props.containerWidth ?? ctx.surface.width;
+			const containerHeight = props.containerHeight ?? ctx.surface.height;
+			drawParagraphNode(ctx, pass, {
+				renderId: props.renderId,
+				text: opText.text || "",
+				dstRect: {
+					x: Number(opText.x ?? 0),
+					y: Number(opText.y ?? 0),
+					width: Number(opText.width ?? containerWidth),
+					height: Number(opText.height ?? containerHeight)
+				},
+				spans: opText.spans,
+				fontFamily: opText.fontFamily,
+				fontSize: Number(opText.fontSize ?? 48),
+				color: opText.fill ?? opText.color ?? "white",
+				width: opText.width ? Number(opText.width) : void 0,
+				height: opText.height ? Number(opText.height) : void 0,
+				lineHeight: Number(opText.lineHeight ?? 1.2),
+				align: opText.align,
+				fontWeight: opText.fontWeight,
+				fontStyle: opText.fontStyle,
+				letterSpacing: opText.letterSpacing,
+				shadows: opText.shadows,
+				textBackgroundColor: opText.textBackgroundColor,
+				borderRadius: (opText.borderRadius ?? opText.strokeRadius) != null ? Number(opText.borderRadius ?? opText.strokeRadius) : void 0,
+				strokeRadius: (opText.strokeRadius ?? opText.borderRadius) != null ? Number(opText.strokeRadius ?? opText.borderRadius) : void 0,
+				padding: opText.padding != null ? Number(opText.padding) : void 0,
+				stroke: opText.stroke,
+				strokeWidth: opText.strokeWidth ?? opText.strokeThickness ? Number(opText.strokeWidth ?? opText.strokeThickness) : void 0,
+				strokeAlign: opText.strokeAlign,
+				opacity: Number(opText.opacity ?? 1) * Number(props.opacity ?? 1),
+				isHeadless: props.isHeadless,
+				animation: opText.animation ?? opText.textAnimation,
+				animators: opText.animators,
+				pathOptions: opText.pathOptions,
+				typewriter: opText.typewriter,
+				marquee: opText.marquee,
+				signals: props.signals ?? opText.signals,
+				firstMargin: opText.firstMargin != null ? Number(opText.firstMargin) : void 0,
+				lastMargin: opText.lastMargin != null ? Number(opText.lastMargin) : void 0,
+				baselineShift: opText.baselineShift != null ? Number(opText.baselineShift) : void 0,
+				frame: localFrame,
+				fps,
+				durationMs: resolvedDurationMs,
+				elapsedMs: resolvedElapsedMs,
+				isVideoMode: props.isVideoMode
+			});
+		}
+		pass.end();
+	}
+	if (virtualMedia.children && virtualMedia.children.length > 0) for (let i = 0; i < virtualMedia.children.length; i++) {
+		const child = virtualMedia.children[i];
+		if (child) await drawCompositionTree(ctx, encoder, targetView, targetTexture, targetWidth, targetHeight, child, {
+			...props,
+			durationMs: resolvedDurationMs,
+			elapsedMs: resolvedElapsedMs,
+			virtualMedia: child,
+			renderId: `${props.renderId}-c${i}`
+		}, isCompositor ? 0 : accumulatedSeekOffsetSec, accumulatedClockOffsetSec);
+	}
+}
+const CanvasComposition = memo((props) => {
+	const ctx = useRenderContext();
+	const { renderId, virtualMedia: rawVirtualMedia } = props;
+	const state = useCompositionState(renderId);
+	const { virtualMedia, fps } = React.useMemo(() => {
+		const fpsValue = props.fps ?? state.fps;
+		return {
+			virtualMedia: normalizeTimeline(rawVirtualMedia, fpsValue),
+			fps: fpsValue
+		};
+	}, [
+		rawVirtualMedia,
+		state.fps,
+		props.fps
+	]);
+	const frame = props.frame ?? state.frame;
+	const isMountedRef = React.useRef(false);
+	const latestTaskRef = React.useRef(null);
+	const isRenderingRef = React.useRef(false);
+	const [fontUpdateTick, forceUpdate] = React.useState(0);
+	React.useEffect(() => {
+		return SlugFontCache.addListener(() => {
+			if (isMountedRef.current) forceUpdate((t) => t + 1);
+		});
+	}, []);
+	React.useEffect(() => {
+		const cdnDomain = getEnv("R2_CUSTOM_DOMAIN");
+		if (!cdnDomain) {
+			console.error("[CanvasComposition] R2_CUSTOM_DOMAIN is not defined.");
+			return;
+		}
+		const url = `https://${cdnDomain}/static/NotoColorEmoji.ttf`;
+		SlugFontCache.preloadEmojiFontFace(url).catch((err) => {
+			console.error("[CanvasComposition] Failed to preload emoji font:", err);
+		});
+	}, []);
+	const [lutUpdateTick, setLutUpdateTick] = React.useState(0);
+	React.useEffect(() => {
+		return lutStore.onChange(() => {
+			if (isMountedRef.current) setLutUpdateTick((t) => t + 1);
+		});
+	}, []);
+	React.useLayoutEffect(() => {
+		isMountedRef.current = true;
+		return () => {
+			isMountedRef.current = false;
+			mediaDecoderCache.clearNode(renderId);
+			clearVideoNodeState(renderId, ctx?.device);
+			if (typeof globalThis !== "undefined" && globalThis.__GATEWAI_DELAYS__) {
+				const delays = globalThis.__GATEWAI_DELAYS__;
+				if (delays instanceof Set) {
+					for (const handle of delays) if (typeof handle === "string" && handle.startsWith(renderId)) delays.delete(handle);
+				}
+			}
+			if (typeof window !== "undefined" && window.renderer_delayRenderHandles) {
+				const handles = window.renderer_delayRenderHandles;
+				if (Array.isArray(handles)) {
+					const filtered = handles.filter((handle) => !(typeof handle === "string" && handle.startsWith(renderId)));
+					window.renderer_delayRenderHandles = filtered;
+				}
+			}
+		};
+	}, [renderId, ctx]);
+	React.useLayoutEffect(() => {
+		if (!ctx || !virtualMedia) return;
+		latestTaskRef.current = {
+			ctx,
+			virtualMedia,
+			frame,
+			fps,
+			props
+		};
+		const triggerRender = async () => {
+			if (isRenderingRef.current) return;
+			isRenderingRef.current = true;
+			while (latestTaskRef.current && isMountedRef.current) {
+				const task = latestTaskRef.current;
+				if (task.ctx !== ctx) break;
+				latestTaskRef.current = null;
+				try {
+					const { device, surface, renderer } = task.ctx;
+					const targetW = surface.width;
+					const targetH = surface.height;
+					if (targetW === 0 || targetH === 0) continue;
+					const encoder = device.createCommandEncoder();
+					const stableTex = renderer.getTemporaryTexture(targetW, targetH);
+					const stableView = stableTex.createView();
+					renderer.beginFrame(encoder, stableView, {
+						r: 0,
+						g: 0,
+						b: 0,
+						a: 0
+					}, targetW, targetH, "clear").end();
+					await drawCompositionTree(task.ctx, encoder, stableView, stableTex, targetW, targetH, task.virtualMedia, {
+						...task.props,
+						frame: task.frame,
+						fps: task.fps,
+						isPlaying: task.props.isPlaying ?? state.isPlaying,
+						isVideoMode: task.virtualMedia.operation.dataType === "Video",
+						excludeTextures: [stableTex]
+					});
+					if (latestTaskRef.current !== null) continue;
+					if (isMountedRef.current && !renderer.isDestroyed) {
+						const blitW = surface.width;
+						const blitH = surface.height;
+						if (blitW > 0 && blitH > 0) {
+							const canvasView = surface.getCurrentTextureView();
+							const blitPass = renderer.beginFrame(encoder, canvasView, {
+								r: 0,
+								g: 0,
+								b: 0,
+								a: 0
+							}, blitW, blitH, "clear");
+							renderer.drawTexture(blitPass, stableTex, {
+								x: 0,
+								y: 0,
+								width: blitW,
+								height: blitH
+							});
+							blitPass.end();
+						}
+						device.queue.submit([encoder.finish()]);
+						surface.present();
+						const key = `${task.props.renderId}-${task.frame}`;
+						if (!window.__frameRenderResolvers) window.__frameRenderResolvers = /* @__PURE__ */ new Map();
+						const status = window.__frameRenderResolvers.get(key);
+						if (status) {
+							status.rendered = true;
+							if (status.resolver) status.resolver();
+						} else window.__frameRenderResolvers.set(key, { rendered: true });
+					}
+				} catch (err) {
+					console.error("Error drawing WebGPU composition tree:", err);
+				}
+			}
+			isRenderingRef.current = false;
+			if (latestTaskRef.current && isMountedRef.current) triggerRender();
+		};
+		triggerRender();
+	}, [
+		ctx,
+		virtualMedia,
+		frame,
+		fps,
+		props,
+		fontUpdateTick,
+		lutUpdateTick
+	]);
+	return null;
+});
+/**
+* browser-video-renderer.tsx
+*
+* Architecture
+* ────────────
+* ┌─────────────────────────────────────────────────────────────────┐
+* │ AudioMuxer (no React deps)                                      │
+* │  · subscribe / getSnapshot  →  useSyncExternalStore contract    │
+* │  · run()  →  mixing + encoding with cooperative yielding        │
+* │  · abort() → AbortSignal cancellation                           │
+* └─────────────────────────────────────────────────────────────────┘
+*          ▲  useSyncExternalStore
+* ┌─────────────────────────────────────────────────────────────────┐
+* │ BrowserVideoRendererInner                                       │
+* │  Effect 1: muxer init (output, sources, OPFS target)           │
+* │  Effect 2: video frame loop  →  setVideoFramesDone(true)        │
+* │  Effect 3: audio kick-off    when videoFramesDone               │
+* │  Effect 4: finalization      when audioState.phase === "done"   │
+* │  Effect 5: progress bridge   audioState → onProgress prop       │
+* │  Effect 6: error bridge      audioState → onError prop          │
+* └─────────────────────────────────────────────────────────────────┘
+*
+* Why FPS dropped to 2-3 during audio processing (and how it's fixed)
+* ────────────────────────────────────────────────────────────────────
+*
+* ROOT CAUSE 1 — Main-thread monopoly
+*   The old audio chunk loop ran entirely on the JS main thread. Each
+*   iteration allocated a Float32Array, interleaved channel data, and
+*   called `await audioSource.add()`. Consecutive microtask continuations
+*   never returned control to the browser's rendering pipeline; the
+*   compositor thread was starved waiting for a JS task to complete before
+*   it could issue a new paint frame.
+*
+* ROOT CAUSE 2 — React scheduler saturation
+*   `onProgress("audio", pct)` was called on every chunk (up to ~100×/sec
+*   for long clips). Each call triggered a parent setState, enqueuing a
+*   React reconciliation. When updates arrived faster than the reconciler
+*   could drain them, React degraded to synchronous rendering to clear the
+*   backlog — which blocked the main thread even longer.
+*
+* ROOT CAUSE 3 — AudioEncoder backpressure
+*   mediabunny's AudioSampleSource.add() awaits the encoder's internal
+*   queue. Under load it parks the caller in a microtask continuation and
+*   immediately resumes on the same task. The browser task scheduler never
+*   saw an idle slot to run its rendering pipeline.
+*
+* ROOT CAUSE 4 — Entangled concerns
+*   Audio encoding lived inside the video frame useEffect. The render loop
+*   and the encoder competed for the same task slot and the same React
+*   reconciliation pass.
+*
+* FIX — yieldToMain() between every audio chunk
+*   `scheduler.yield()` (Chrome 115+) is the correct primitive: it
+*   explicitly yields to the browser's task queue at "user-blocking"
+*   priority, guaranteeing a paint opportunity between chunks. The
+*   `setTimeout(0)` fallback provides equivalent semantics on older
+*   browsers (>4 ms clamped, sufficient for ~60 FPS).
+*   Progress notifications are throttled to ≤12 updates/sec to avoid
+*   overwhelming the React scheduler.
+*/
+const isNode = typeof process !== "undefined" && Boolean(process.versions?.node);
+if (typeof window !== "undefined" && !isNode) canEncodeAudio("mp3").then((supported) => {
+	if (!supported) registerMp3Encoder();
+}).catch(() => {});
+
+//#endregion
+export { DataTypes as $, frameArraySignal as $t, ImageResultSchema as A, TextOperationSchema as At, BaseMediaOperationPropsSchema as B, VideoTimingPropsSchema as Bt, preloadFont as C, SignalDataSchema as Ct, useCurrentFrame as D, SingleOutputGenericSchema as Dt, springCalculation as E, SignalStatsSchema as Et, defineRenderer as F, VideoAnimationSchema as Ft, ConfigHandleSchema as G, computed as Gt, CAPTION_LAYER_DEFAULTS as H, appendOperation as Ht, registerWebGPURenderer as I, VideoLayerTypeSchema as It, DEFAULT_DURATION_MS as J, createVirtualMedia as Jt, ConfigSchemaRegistry as K, cosineSignal as Kt, AnimationTypeSchema as L, VideoSpatialPropsSchema as Lt, VideoResultSchema as M, TimelineTransformSchema as Mt, configBuilder as N, TransitionSchema as Nt, useVideoConfig as O, SourceOperationSchema as Ot, audioRegistry as P, TransitionTypeSchema as Pt, DataTypeVal as Q, findSourceAsset as Qt, AnyOutputUnionSchema as R, VideoStylePropsSchema as Rt, parseColorToRgb as S, updateClockSignals as Sn, SignalChannelMetaSchema as St, spring as T, SignalMathDataSchema as Tt, COMPOSITE_OPERATIONS$1 as U, checkNodeResultCache as Ut, BaseVideoLayerPropsSchema as V, VirtualMediaDataSchema as Vt, COMPOSITOR_DEFAULTS as W, computeVideoCropRenderProps as Wt, DEFAULT_MEDIA_DIMENSION as X, deserializeSignalData as Xt, DEFAULT_FPS as Y, dataTypeColors as Yt, DataType as Z, extractSvgDimensions as Zt, interpolate as _, signal as _n, NodeResultSchema as _t, mixAudioTracks as a, getLeafMediaType as an, GeneratorSignalDataSchema as at, measureText as b, stampResult as bn, ProgrammaticSignal as bt, LIGHT_UNIFORM_SIZE_BYTES as c, hasOnlySingleSource as cn, JsonValueSchema as ct, PlaybackContext as d, isVirtualMediaData as dn, MediaOperationSchema as dt, frameSignal as en, Effect as et, PlaybackProvider as f, programmaticSignal as fn, MediaSourceSchema as ft, hasDelayRender as g, serializeSignalData as gn, NodeMetadataSchema as gt, computeStrokeRect as h, resolveMediaMimeType as hn, MultiOutputGenericSchema as ht, drawCompositionTree as i, getFingerprint as in, FileDataSchema as it, SignalResultSchema as j, TimelineSegmentSchema as jt, ColorSchema as k, TEXT_LAYER_DEFAULTS as kt, MAX_LIGHTS as l, isEqual as ln, MIME_TYPES as lt, bezier as m, registerSignalDependency as mn, ModerationUnrefundableError as mt, compositionStateStore as n, getActiveMediaMetadata as nn, ExtendedLayerSchema as nt, useCompositionState as o, getMediaType as on, GlobalCompositeOperation$1 as ot, Vector3Math as p, progressSignal as pn, ModerationError as pt, DATA_TYPE_EXTENSIONS as q, createOutputItemSchema as qt, decodeAudioSource as r, getFileDataMetadata as rn, FileAssetSchema as rt, Easing as s, getRenderFingerprint as sn, HandleTypeVal as st, CanvasComposition as t, generateId as tn, ExportResultSchema as tt, Matrix4Math as u, isSignal as un, MediaMetadataSchema as ut, mapBlendModeToSkia as v, signalBuilder as vn, NodeVisualConfigSchema as vt, requiresIsolation as w, SignalGateDataSchema as wt, measureTextAsync as x, timeSignal as xn, Signal as xt, measureSpring as y, sineSignal as yn, OutputItemSchema as yt, AudioExtractorSignalDataSchema as z, VideoTextPropsSchema as zt };
+//# sourceMappingURL=dist-CMF9eNLB.mjs.map