framefields 2.0.2

package/dist/dist-1iUYuPct.mjs

@@ -0,0 +1,1859 @@
+import { Ht as updateClockSignals, Ot as isSignal, Pt as resolveMediaMimeType, bt as getActiveMediaMetadata, f as DEFAULT_DURATION_MS, wt as getMediaType } from "./dist-Bx6J0VcM.mjs";
+import { i as webgpuRegistry, t as audioRegistry } from "./renderer-CtVkU_GA.mjs";
+import { $ as registerHeadlessFont, A as drawLottieNode, B as inputStore, D as drawCaptionNode, M as drawSignalNode, N as drawSvgNode, O as drawGifNode, P as drawVideoNode, b as SlugGeometry, et as shaderStore, it as GetFontAssetUrl, j as drawParagraphNode, k as drawImageNode, ot as getEnv, st as resolveMediaSourceUrl, tt as signalRegistry, y as SlugFontCache } from "./dist-gjHmorxL.mjs";
+import { AudioSampleSink } from "mediabunny";
+
+//#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 = 0) {
+		return [
+			x,
+			y,
+			z
+		];
+	},
+	copy(v) {
+		return [
+			v[0],
+			v[1],
+			v[2]
+		];
+	},
+	set(out, x, y, z) {
+		out[0] = x;
+		out[1] = y;
+		out[2] = z;
+		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 = 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,
+			t * x * z - s * y,
+			0,
+			t * x * y - s * z,
+			t * y * y + c,
+			t * y * z + s * x,
+			0,
+			t * x * z + s * y,
+			t * y * z - s * x,
+			t * z * z + 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 = p[2];
+		const X = m[0] * x + m[4] * y + m[8] * z + m[12];
+		const Y$1 = m[1] * x + m[5] * y + m[9] * z + m[13];
+		const Z = m[2] * x + m[6] * y + m[10] * z + m[14];
+		const W = m[3] * x + m[7] * y + m[11] * z + 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 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));
+}
+/**
+* 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-DBs4NHoi.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);
+}
+const isStaticVisualMedia = (type) => type === "Image" || type === "SVG" || type === "Text";
+const resolveLayerDuration = (layerDurationInMS, metaDurationMs, defaultDuration = DEFAULT_DURATION_MS, type) => {
+	if (type === "Caption") return metaDurationMs && metaDurationMs > 0 ? metaDurationMs : layerDurationInMS || defaultDuration;
+	const isStatic = isStaticVisualMedia(type);
+	if (layerDurationInMS && metaDurationMs && !isStatic) return Math.min(layerDurationInMS, metaDurationMs);
+	return layerDurationInMS || metaDurationMs || defaultDuration;
+};
+
+//#endregion
+//#region ../compositions/dist/index.mjs
+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,
+						verticalAlign: opText.verticalAlign,
+						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,
+				verticalAlign: opText.verticalAlign,
+				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 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();
+/**
+* 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))
+	};
+}
+const verbose = typeof process !== "undefined" && /^(debug|trace)$/i.test(process.env?.LOG_LEVEL ?? "");
+let mediaLogger = {
+	debug: (msg, ...args) => {
+		if (!verbose) return;
+		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 */
+	"@framefields/server-utils"
+).then((m) => {
+	if (m.mediaLogger) mediaLogger = m.mediaLogger;
+}).catch(() => {});
+const yieldToMain = () => {
+	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 = 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.debug(`[AudioExtractor] decodeAudioSource started for url: ${url}`);
+	try {
+		if (typeof window !== "undefined" && typeof window.document !== "undefined" && !(typeof process !== "undefined" && process.versions && process.versions.node)) {
+			mediaLogger.debug(`[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.debug(`[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.debug(`[AudioExtractor] Fetched ${arrayBuffer.byteLength} bytes. Decoding audio data...`);
+				const audioBuffer = await audioCtx.decodeAudioData(arrayBuffer);
+				mediaLogger.debug(`[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.debug(`[AudioExtractor] AudioContext closed for ${url}`);
+			}
+		}
+		let inputAcquired = false;
+		try {
+			mediaLogger.debug(`[AudioExtractor] Server / Node.js detected. Acquiring from inputStore for ${url}...`);
+			const input = await inputStore.acquire(url);
+			inputAcquired = true;
+			mediaLogger.debug(`[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.debug(`[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.debug(`[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();
+		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.debug(`[AudioExtractor] mixAudioTracks started. FPS: ${fps}, targetSampleRate: ${targetSampleRate}`);
+	await waitForDelayRender();
+	shaderStore.registerSignalsFromComposition(renderId, virtualMedia);
+	const durationMs = getActiveMediaMetadata(virtualMedia)?.durationMs || 1e3;
+	const totalDurationSec = durationMs / 1e3;
+	const totalTargetSamples = Math.ceil(totalDurationSec * targetSampleRate);
+	mediaLogger.debug(`[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();
+				}
+			}
+			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
+	};
+}
+
+//#endregion
+export { springCalculation as S, measureTextAsync as _, resolveLayerDuration as a, requiresIsolation as b, MAX_LIGHTS as c, bezier as d, computeStrokeRect as f, measureText as g, measureSpring as h, mixAudioTracks as i, Matrix4Math as l, mapBlendModeToSkia as m, decodeAudioSource as n, Easing as o, interpolate as p, drawCompositionTree as r, LIGHT_UNIFORM_SIZE_BYTES as s, compositionStateStore as t, Vector3Math as u, parseColorToRgb as v, spring as x, preloadFont as y };
+//# sourceMappingURL=dist-1iUYuPct.mjs.map