framefields 2.0.2

package/dist/dist-Bx6J0VcM.mjs

@@ -0,0 +1,1859 @@
+import { nanoid } from "nanoid";
+import z$1, { z } from "zod";
+
+//#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 = Math.max(1, Math.round(windowFrames));
+		if (window <= 1) return this;
+		return this._derive((ctx) => {
+			let sum = 0;
+			let count = 0;
+			const startF = Math.max(0, ctx.frame - window + 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})` });
+	}
+	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 STORE_KEY = Symbol.for("framefields.renderDiagnostics");
+const diagnosticsByRender = globalThis[STORE_KEY] ?? (globalThis[STORE_KEY] = /* @__PURE__ */ new Map());
+const MAX_TRACKED_RENDERS = 256;
+/** Record a diagnostic for a render; repeats (same code, layer and message) are kept once. */
+function reportRenderDiagnostic(renderId, diagnostic) {
+	let forRender = diagnosticsByRender.get(renderId);
+	if (!forRender) {
+		if (diagnosticsByRender.size >= MAX_TRACKED_RENDERS) {
+			const oldest = diagnosticsByRender.keys().next().value;
+			if (oldest !== void 0) diagnosticsByRender.delete(oldest);
+		}
+		forRender = /* @__PURE__ */ new Map();
+		diagnosticsByRender.set(renderId, forRender);
+	}
+	const key = `${diagnostic.code}|${diagnostic.layerId ?? ""}|${diagnostic.message}`;
+	if (!forRender.has(key)) forRender.set(key, diagnostic);
+}
+/**
+* Everything reported for a render, including its nested compositions (they
+* render under derived ids, `${renderId}-…`), removing it from the store.
+*/
+function takeRenderDiagnostics(renderId) {
+	const collected = /* @__PURE__ */ new Map();
+	for (const [id, forRender] of diagnosticsByRender) {
+		if (id !== renderId && !id.startsWith(`${renderId}-`)) continue;
+		for (const [key, diagnostic] of forRender) collected.set(key, diagnostic);
+		diagnosticsByRender.delete(id);
+	}
+	return [...collected.values()];
+}
+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 = [
+	"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);
+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.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
+export { VideoAnimationSchema as $, MediaSourceSchema as A, programmaticSignal as At, SignalChannelMetaSchema as B, takeRenderDiagnostics as Bt, GeneratorSignalDataSchema as C, getLeafMediaType as Ct, MIME_TYPES as D, isEqual as Dt, JsonValueSchema as E, hasOnlySingleSource as Et, NodeResultSchema as F, serializeSignalData as Ft, SingleOutputGenericSchema as G, SignalGateDataSchema as H, updateClockSignals as Ht, NodeVisualConfigSchema as I, signal as It, TextOperationSchema as J, SourceOperationSchema as K, OutputItemSchema as L, signalBuilder as Lt, ModerationUnrefundableError as M, registerSignalDependency as Mt, MultiOutputGenericSchema as N, reportRenderDiagnostic as Nt, MediaMetadataSchema as O, isSignal as Ot, NodeMetadataSchema as P, resolveMediaMimeType as Pt, TransitionTypeSchema as Q, ProgrammaticSignal as R, sineSignal as Rt, FileDataSchema as S, getFingerprint as St, HandleTypeVal as T, getRenderFingerprint as Tt, SignalMathDataSchema as U, SignalDataSchema as V, timeSignal as Vt, SignalStatsSchema as W, TimelineTransformSchema as X, TimelineSegmentSchema as Y, TransitionSchema as Z, DataTypes as _, frameArraySignal as _t, BaseVideoLayerPropsSchema as a, VirtualMediaDataSchema as at, ExtendedLayerSchema as b, getActiveMediaMetadata as bt, COMPOSITOR_DEFAULTS as c, computeVideoCropRenderProps as ct, DATA_TYPE_EXTENSIONS as d, createOutputItemSchema as dt, VideoLayerTypeSchema as et, DEFAULT_DURATION_MS as f, createVirtualMedia as ft, DataTypeVal as g, findSourceAsset as gt, DataType as h, extractSvgDimensions as ht, BaseMediaOperationPropsSchema as i, VideoTimingPropsSchema as it, ModerationError as j, progressSignal as jt, MediaOperationSchema as k, isVirtualMediaData as kt, ConfigHandleSchema as l, computed as lt, DEFAULT_MEDIA_DIMENSION as m, deserializeSignalData as mt, AnyOutputUnionSchema as n, VideoStylePropsSchema as nt, CAPTION_LAYER_DEFAULTS as o, appendOperation as ot, DEFAULT_FPS as p, dataTypeColors as pt, TEXT_LAYER_DEFAULTS as q, AudioExtractorSignalDataSchema as r, VideoTextPropsSchema as rt, COMPOSITE_OPERATIONS as s, checkNodeResultCache as st, AnimationTypeSchema as t, VideoSpatialPropsSchema as tt, ConfigSchemaRegistry as u, cosineSignal as ut, Effect as v, frameSignal as vt, GlobalCompositeOperation as w, getMediaType as wt, FileAssetSchema as x, getFileDataMetadata as xt, ExportResultSchema as y, generateId as yt, Signal as z, stampResult as zt };
+//# sourceMappingURL=dist-Bx6J0VcM.mjs.map