framefields 2.0.10 → 2.1.0

package/dist/{program-xRfFoPxe.mjs → program-BqFVw5Mu.mjs}

@@ -1,6 +1,6 @@
-import { bt as getActiveMediaMetadata, ft as createVirtualMedia } from "./dist-B9Afsv83.mjs";
-import { t as ColorSchema } from "./dist-DzUJmIHt.mjs";
-import { nt as signalRegistry } from "./dist-B9PkqWnN.mjs";
+import { Bt as parseCssColor, Lt as mixColors, Vt as parseCssGradient, ht as createVirtualMedia, l as Color, wt as getActiveMediaMetadata } from "./dist-fjKpBYkc.mjs";
+import { t as ColorSchema } from "./dist-BY0bIWgr.mjs";
+import { $t as TypewriterAnimatorSchema, An as signalRegistry, Kt as TextPathOptionsSchema, ht as AdvancedTextAnimatorSchema, kt as KineticMarqueeConfigSchema, pt as AETextAnimatorSchema } from "./dist-Bun_TUvZ.mjs";
 import { z } from "zod";
 import { loadYoga } from "yoga-layout/load";
 
@@ -385,6 +385,36 @@ function collectInlineSignals(nodes, out = {}) {
 	}
 	return out;
 }
+const isKeyframeTrack = (t) => !t.source || t.source.type === "keyframe";
+/**
+* Merges keyframe tracks that animate the same prop into one sorted track,
+* the later key winning on a shared frame. Procedural tracks (signal,
+* wiggle, spring…) pass through untouched.
+*/
+function mergeAnimationTracks(tracks) {
+	const out = [];
+	const byProp = /* @__PURE__ */ new Map();
+	for (const t of tracks) {
+		if (!isKeyframeTrack(t)) {
+			out.push(t);
+			continue;
+		}
+		const existing = byProp.get(t.prop);
+		if (!existing) {
+			const copy = {
+				...t,
+				keyframes: [...t.keyframes ?? []]
+			};
+			byProp.set(t.prop, copy);
+			out.push(copy);
+			continue;
+		}
+		const frames = new Map(existing.keyframes.map((k) => [k.frame, k]));
+		for (const k of t.keyframes ?? []) frames.set(k.frame, k);
+		existing.keyframes = [...frames.values()].sort((a, b) => a.frame - b.frame);
+	}
+	return out;
+}
 function evaluateEasingProgress(ease, t) {
 	if (!ease) return t;
 	const ref = parseEase(ease);
@@ -586,12 +616,15 @@ var LayerAnimation = class LayerAnimation$1 {
 			this.tracks.push(track);
 		}
 		const parsedEase = parseEase(ease);
-		track.keyframes.push({
+		const kf = {
 			id: `k_${track.keyframes.length}_f${frame}`,
 			frame,
 			value,
 			...parsedEase && { ease: parsedEase }
-		});
+		};
+		const at = track.keyframes.findIndex((k) => k.frame === frame);
+		if (at >= 0) track.keyframes[at] = kf;
+		else track.keyframes.push(kf);
 		track.keyframes.sort((a, b) => a.frame - b.frame);
 		return this;
 	}
@@ -968,6 +1001,19 @@ var LayerAnimation = class LayerAnimation$1 {
 		return node;
 	}
 	/**
+	* Folds other animations into this one. Keyframe tracks on the same prop
+	* merge into one track (a later key wins on a shared frame), so separate
+	* behaviours — an entrance, presses, a wave — can be authored apart:
+	* `LayerAnimation.merge(rainIn, presses, wave)`.
+	*/
+	merge(...others) {
+		this.tracks = mergeAnimationTracks([...this.tracks, ...others.flatMap((o) => o.tracks)]);
+		return this;
+	}
+	static merge(...anims) {
+		return new LayerAnimation$1().merge(...anims);
+	}
+	/**
 	* Returns the validated LayerAnimation specification object.
 	*/
 	toSpec() {
@@ -1467,17 +1513,9 @@ function parseHexColor(hex) {
 		1
 	];
 }
+/** Color keyframes blend perceptually (OKLab) and accept any CSS color. */
 function lerpColor(c1, c2, t) {
-	if (!c1.startsWith("#") || !c2.startsWith("#")) return t < .5 ? c1 : c2;
-	const [r1, g1, b1, a1] = parseHexColor(c1);
-	const [r2, g2, b2, a2] = parseHexColor(c2);
-	const r = Math.round(lerp(r1, r2, t));
-	const g = Math.round(lerp(g1, g2, t));
-	const b = Math.round(lerp(b1, b2, t));
-	const a = lerp(a1, a2, t);
-	const toHex = (n) => n.toString(16).padStart(2, "0");
-	if (a >= .999) return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
-	return `rgba(${r}, ${g}, ${b}, ${Math.round(a * 100) / 100})`;
+	return mixColors(c1, c2, t);
 }
 function hueToRgb(p, q, t) {
 	let tt = t;
@@ -1529,7 +1567,7 @@ function rotateHue(hex, delta) {
 	if (a >= .999) return `#${toHex(newR)}${toHex(newG)}${toHex(newB)}`;
 	return `rgba(${Math.round(newR * 255)}, ${Math.round(newG * 255)}, ${Math.round(newB * 255)}, ${Math.round(a * 100) / 100})`;
 }
-const COLOR_PROPS = new Set([
+const COLOR_PROPS$1 = new Set([
 	"fill",
 	"fillColor",
 	"strokeColor",
@@ -1589,7 +1627,7 @@ function evaluateTrackAtFrame(track, frame, fps = 24, context = {}) {
 		}
 		case "signal": {
 			const sigVal = evaluateSignal(source, frame, fps, context.signals);
-			if (COLOR_PROPS.has(track.prop)) {
+			if (COLOR_PROPS$1.has(track.prop)) {
 				const src = source;
 				const colorA = src.colorA ?? "#ffffff";
 				const colorB = src.colorB ?? "#ffffff";
@@ -1613,2268 +1651,168 @@ function evaluateAnimationAtFrame(animation, frame, fps = 24, context = {}) {
 	return result;
 }
 /**
-* Fluent Builder for Extended Text Animators.
-*/
-var AdvancedTextAnimatorBuilder = class AdvancedTextAnimatorBuilder$1 {
-	name;
-	props = {};
-	selectors = [];
-	constructor(name) {
-		this.name = name;
-	}
-	static create(name) {
-		return new AdvancedTextAnimatorBuilder$1(name);
-	}
-	/** Directional Skew */
-	skew(angleDeg, axisDeg = 0) {
-		this.props.skew = angleDeg;
-		this.props.skewAxis = axisDeg;
-		return this;
-	}
-	/** Anchor Point Grouping and Preset Pivot */
-	anchor(preset, grouping = "character", offsetX = 0, offsetY = 0) {
-		this.props.anchor = {
-			grouping,
-			preset,
-			anchorX: .5,
-			anchorY: .5,
-			offsetX,
-			offsetY
-		};
-		return this;
-	}
-	/** Custom Anchor Point Coordinates (0 to 1 normalized) */
-	anchorNormalized(ax, ay, grouping = "character") {
-		this.props.anchor = {
-			grouping,
-			preset: "custom",
-			anchorX: ax,
-			anchorY: ay,
-			offsetX: 0,
-			offsetY: 0
-		};
-		return this;
-	}
-	/** 3D Spatial Z-Depth */
-	translateZ(zPixels) {
-		this.props.translateZ = zPixels;
-		return this;
-	}
-	/** 3D Tilts */
-	tilt3D(rx = 0, ry = 0, rz = 0) {
-		this.props.rotationX = rx;
-		this.props.rotationY = ry;
-		this.props.rotationZ = rz;
-		return this;
-	}
-	/** 3D Rotation along X axis */
-	rotationX(deg) {
-		this.props.rotationX = deg;
-		return this;
-	}
-	/** 3D Rotation along Y axis */
-	rotationY(deg) {
-		this.props.rotationY = deg;
-		return this;
-	}
-	/** 3D Rotation along Z axis */
-	rotationZ(deg) {
-		this.props.rotationZ = deg;
-		return this;
-	}
-	/** 3D Volumetric Formations */
-	volumetricFormation(mode = "cylinder", radius = 300, pitch = 120, totalAngle = 360, perspective = 1200, axis = "y") {
-		this.props.formation = {
-			mode,
-			radius,
-			pitch,
-			totalAngle,
-			perspective,
-			axis
-		};
-		return this;
-	}
-	/** Dynamic Line Spacing (Leading) */
-	lineSpacing(extraLeadingPixels, lineAnchor = 0) {
-		this.props.lineSpacing = extraLeadingPixels;
-		this.props.lineAnchor = lineAnchor;
-		return this;
-	}
-	/** Normalized Line Anchor (0=top, 0.5=center, 1=bottom) */
-	lineAnchor(anchor) {
-		this.props.lineAnchor = anchor;
-		return this;
-	}
-	/** Inertial Spring Settling Physics */
-	spring(stiffness = 180, damping = 12, mass = 1, initialVelocity = 0) {
-		this.props.spring = {
-			stiffness,
-			damping,
-			mass,
-			initialVelocity,
-			overshootMultiplier: 1
-		};
-		return this;
-	}
-	/** Dynamic Stroke & Wireframe Properties */
-	stroke(widthPixels, color = "#ffffff", fillOpacity = 1) {
-		this.props.stroke = {
-			strokeWidth: widthPixels,
-			strokeColor: color,
-			strokeAlign: "center",
-			fillOpacity,
-			dashOffset: 0
-		};
-		return this;
-	}
-	/** Variable Font Axes */
-	variableFont(axes) {
-		this.props.variableAxes = axes;
-		return this;
-	}
-	/** Chromatic Aberration / Cyberpunk Glitch */
-	chromaticGlitch(redShiftX, redShiftY = 0, blueShiftX = -redShiftX, blueShiftY = 0) {
-		this.props.chromaticGlitch = {
-			redShiftX,
-			redShiftY,
-			blueShiftX,
-			blueShiftY,
-			sliceProbability: 0,
-			sliceAmplitude: 0
-		};
-		return this;
-	}
-	/** Multi-Band Audio Spectrum Equalizer */
-	audioSpectrum(signalChannel, minFreqHz = 60, maxFreqHz = 16e3, maxScale = 2.5) {
-		this.props.audioSpectrum = {
-			signalChannel,
-			minFreqHz,
-			maxFreqHz,
-			scaleAxis: "scaleY",
-			minScale: .2,
-			maxScale,
-			peakDecay: .8
-		};
-		return this;
-	}
-	/** Long Shadow Extrusion */
-	longShadow(angle = 45, length = 40, color = "#000000", startOpacity = .8, endOpacity = 0, steps = 16) {
-		this.props.longShadow = {
-			angle,
-			length,
-			color,
-			startOpacity,
-			endOpacity,
-			steps
-		};
-		return this;
-	}
-	/** Particle Dust / Quantum Dissolve */
-	particleDissolve(progress = 0, dispersalAngle = 90, maxDisplacement = 120) {
-		this.props.particleDissolve = {
-			progress,
-			dispersalAngle,
-			maxDisplacement,
-			turbulence: .5,
-			particleSize: 2
-		};
-		return this;
-	}
-	/** Add Expression Selector */
-	addExpressionSelector(expression, mode = "add") {
-		this.selectors.push({
-			type: "expression",
-			expression,
-			mode,
-			amount: 1
-		});
-		return this;
-	}
-	/** Alias for addExpressionSelector */
-	expressionSelector(expression, mode = "add") {
-		return this.addExpressionSelector(expression, mode);
-	}
-	/** Standard 2D Transforms */
-	x(v) {
-		this.props.x = v;
-		return this;
-	}
-	y(v) {
-		this.props.y = v;
-		return this;
-	}
-	scale(v) {
-		this.props.scale = v;
-		return this;
-	}
-	scaleX(v) {
-		this.props.scaleX = v;
-		return this;
-	}
-	scaleY(v) {
-		this.props.scaleY = v;
-		return this;
-	}
-	rotation(deg) {
-		this.props.rotation = deg;
-		return this;
-	}
-	opacity(v) {
-		this.props.opacity = v;
-		return this;
-	}
-	blur(v) {
-		this.props.blur = v;
-		return this;
-	}
-	fillColor(hex) {
-		this.props.fillColor = hex;
-		return this;
-	}
-	build() {
-		return {
-			name: this.name,
-			selectors: this.selectors,
-			props: this.props
-		};
-	}
-};
-/**
-* @file packages/compositions/src/program/text-animations/advanced-types.ts
-* Data contracts and Zod schemas for Advanced Motion Design & After Effects Extended Typography Engine.
-*/
-const AnchorGroupingSchema = z.enum([
-	"character",
-	"word",
-	"line",
-	"all"
-]);
-const AnchorPresetSchema = z.enum([
-	"center",
-	"baseline",
-	"bottom_left",
-	"bottom_center",
-	"bottom_right",
-	"top_left",
-	"top_center",
-	"top_right",
-	"custom"
-]);
-const TextAnchorConfigSchema = z.object({
-	grouping: AnchorGroupingSchema.default("character"),
-	preset: AnchorPresetSchema.default("center"),
-	anchorX: z.number().default(.5),
-	anchorY: z.number().default(.5),
-	offsetX: z.number().default(0),
-	offsetY: z.number().default(0)
-});
-const SkewPropertiesSchema = z.object({
-	skew: z.number().min(-90).max(90),
-	skewAxis: z.number().default(0)
-});
-const LineSpacingDynamicsSchema = z.object({
-	lineSpacing: z.number(),
-	lineAnchor: z.number().min(0).max(1).default(0)
-});
-const VolumetricFormationModeSchema = z.enum([
-	"planar",
-	"vortex",
-	"cylinder",
-	"helix"
-]);
-const VolumetricFormationConfigSchema = z.object({
-	mode: VolumetricFormationModeSchema.default("planar"),
-	radius: z.number().default(300),
-	pitch: z.number().default(120),
-	totalAngle: z.number().default(360),
-	axis: z.enum([
-		"x",
-		"y",
-		"z"
-	]).default("y"),
-	perspective: z.number().positive().default(1200)
-});
-const Spatial3DPropertiesSchema = z.object({
-	translateZ: z.number().optional(),
-	rotationX: z.number().optional(),
-	rotationY: z.number().optional(),
-	rotationZ: z.number().optional(),
-	formation: VolumetricFormationConfigSchema.optional()
-});
-const SpringPhysicsSchema = z.object({
-	stiffness: z.number().positive().default(180),
-	damping: z.number().positive().default(12),
-	mass: z.number().positive().default(1),
-	initialVelocity: z.number().default(0),
-	overshootMultiplier: z.number().min(.5).max(3).default(1)
-});
-const ExpressionSelectorSchema = z.object({
-	type: z.literal("expression"),
-	name: z.string().optional(),
-	expression: z.string(),
-	mode: z.enum([
-		"add",
-		"subtract",
-		"intersect",
-		"min",
-		"max",
-		"difference"
-	]).default("add"),
-	amount: z.number().default(1)
-});
-const DynamicStrokePropertiesSchema = z.object({
-	strokeWidth: z.number().min(0).default(0),
-	strokeColor: z.string().default("#ffffff"),
-	strokeAlign: z.enum([
-		"center",
-		"inside",
-		"outside"
-	]).default("center"),
-	fillOpacity: z.number().min(0).max(1).default(1),
-	dashArray: z.tuple([z.number(), z.number()]).optional(),
-	dashOffset: z.number().default(0)
-});
-const KineticMarqueeConfigSchema = z.object({
-	direction: z.enum([
-		"left",
-		"right",
-		"up",
-		"down"
-	]).default("left"),
-	velocity: z.number().default(120),
-	loop: z.boolean().default(true),
-	repeatGap: z.number().default(80),
-	snap: z.object({
-		enabled: z.boolean().default(false),
-		granularity: z.enum([
-			"character",
-			"word",
-			"line"
-		]).default("word"),
-		stopIndex: z.number().default(0),
-		decelEase: z.string().default("cubic.out")
-	}).optional()
-});
-const VariableFontAxesSchema = z.object({
-	weight: z.number().min(100).max(1e3).optional(),
-	width: z.number().min(50).max(200).optional(),
-	slant: z.number().min(-25).max(25).optional(),
-	italic: z.number().min(0).max(1).optional(),
-	opticalSize: z.number().min(6).max(144).optional()
-});
-const ChromaticGlitchConfigSchema = z.object({
-	redShiftX: z.number().default(0),
-	redShiftY: z.number().default(0),
-	blueShiftX: z.number().default(0),
-	blueShiftY: z.number().default(0),
-	sliceProbability: z.number().min(0).max(1).default(0),
-	sliceAmplitude: z.number().default(0)
-});
-const AudioSpectrumTypographySchema = z.object({
-	signalChannel: z.string(),
-	minFreqHz: z.number().default(60),
-	maxFreqHz: z.number().default(16e3),
-	scaleAxis: z.enum([
-		"scaleY",
-		"scaleX",
-		"scale",
-		"y"
-	]).default("scaleY"),
-	minScale: z.number().default(.2),
-	maxScale: z.number().default(2.5),
-	peakDecay: z.number().min(0).max(.99).default(.8)
-});
-const LongShadowConfigSchema = z.object({
-	angle: z.number().default(45),
-	length: z.number().min(0).default(0),
-	color: z.string().default("#000000"),
-	startOpacity: z.number().min(0).max(1).default(.8),
-	endOpacity: z.number().min(0).max(1).default(0),
-	steps: z.number().int().min(4).max(64).default(16)
-});
-const ParticleDissolveConfigSchema = z.object({
-	progress: z.number().min(0).max(1).default(0),
-	dispersalAngle: z.number().default(90),
-	maxDisplacement: z.number().default(120),
-	turbulence: z.number().default(.5),
-	particleSize: z.number().default(2)
-});
-const ExtendedGlyphPropertiesSchema = z.object({
-	x: z.number().optional(),
-	y: z.number().optional(),
-	translateZ: z.number().optional(),
-	scale: z.number().optional(),
-	scaleX: z.number().optional(),
-	scaleY: z.number().optional(),
-	rotation: z.number().optional(),
-	rotationX: z.number().optional(),
-	rotationY: z.number().optional(),
-	rotationZ: z.number().optional(),
-	formation: VolumetricFormationConfigSchema.optional(),
-	skew: z.number().optional(),
-	skewAxis: z.number().optional(),
-	tracking: z.number().optional(),
-	lineSpacing: z.number().optional(),
-	lineAnchor: z.number().optional(),
-	anchor: TextAnchorConfigSchema.optional(),
-	opacity: z.number().optional(),
-	blur: z.number().optional(),
-	fillColor: z.string().optional(),
-	stroke: DynamicStrokePropertiesSchema.optional(),
-	variableAxes: VariableFontAxesSchema.optional(),
-	chromaticGlitch: ChromaticGlitchConfigSchema.optional(),
-	longShadow: LongShadowConfigSchema.optional(),
-	particleDissolve: ParticleDissolveConfigSchema.optional(),
-	audioSpectrum: AudioSpectrumTypographySchema.optional(),
-	spring: SpringPhysicsSchema.optional()
-});
-const AdvancedTextAnimatorSchema = z.object({
-	name: z.string().default("AdvancedAnimator"),
-	selectors: z.array(z.record(z.string(), z.unknown())).default([]),
-	props: ExtendedGlyphPropertiesSchema
-});
-/**
-* @file packages/compositions/src/program/text-animations/types.ts
-* Data contracts and Zod schemas for After Effects Parity Text Animation Engine.
+* Static checks for things that render "fine" but not as intended: a color
+* the parser can't read (drawn transparent), text that disappears into its
+* background, a layer parked off-canvas, a shadow on a light that can't cast
+* one. Pure and fast; `renderVideo({ qa })` folds the findings into its report.
 */
-const Vec2Schema = z.object({
-	x: z.number(),
-	y: z.number()
-});
-const CubicBezierSegmentSchema = z.object({
-	p0: Vec2Schema,
-	p1: Vec2Schema,
-	p2: Vec2Schema,
-	p3: Vec2Schema
-});
-const TextPathSourceSchema = z.discriminatedUnion("type", [
-	z.object({
-		type: z.literal("svg"),
-		d: z.string().min(1, "SVG path string cannot be empty")
-	}),
-	z.object({
-		type: z.literal("bezier"),
-		segments: z.array(CubicBezierSegmentSchema).min(1)
-	}),
-	z.object({
-		type: z.literal("ellipse"),
-		cx: z.number(),
-		cy: z.number(),
-		rx: z.number().positive(),
-		ry: z.number().positive(),
-		startAngleDeg: z.number().default(0),
-		endAngleDeg: z.number().default(360)
-	}),
-	z.object({
-		type: z.literal("wave"),
-		startX: z.number(),
-		startY: z.number(),
-		length: z.number().positive(),
-		amplitude: z.number(),
-		frequency: z.number().positive(),
-		phaseDeg: z.number().default(0)
-	})
-]);
-const TextPathOptionsSchema = z.object({
-	path: TextPathSourceSchema,
-	firstMargin: z.number().default(0),
-	lastMargin: z.number().default(0),
-	reversePath: z.boolean().default(false),
-	perpendicularToPath: z.boolean().default(true),
-	forceAlignment: z.boolean().default(false),
-	loop: z.boolean().default(false),
-	baselineOffset: z.enum([
-		"baseline",
-		"center",
-		"ascender",
-		"descender"
-	]).default("baseline"),
-	baselineShift: z.number().default(0)
-});
-const TextCursorStyleSchema = z.enum([
-	"bar",
-	"underscore",
+const COLOR_PROPS = [
+	"background",
+	"fill",
+	"fillColor",
+	"strokeColor",
+	"borderColor",
+	"gradientEndColor",
+	"emissive",
+	"color"
+];
+/** Contrast below this makes text hard to read (WCAG large-text minimum). */
+const MIN_TEXT_CONTRAST = 3;
+function tracksOf(node) {
+	return node.animation?.tracks ?? [];
+}
+const animates = (node, props) => tracksOf(node).some((t) => props.includes(t.prop));
+const CONTAINERS = new Set([
+	"box",
+	"flex",
 	"block",
-	"custom"
-]);
-const TextCursorConfigSchema = z.object({
-	enabled: z.boolean().default(true),
-	style: TextCursorStyleSchema.default("bar"),
-	customChar: z.string().default("|"),
-	color: z.string().optional(),
-	blinkFrequency: z.number().min(0).default(2),
-	hideOnComplete: z.boolean().default(false),
-	width: z.number().positive().default(2.5),
-	spacing: z.number().default(3)
-});
-const TypingCadenceSchema = z.discriminatedUnion("mode", [z.object({ mode: z.literal("constant") }), z.object({
-	mode: z.literal("human"),
-	jitter: z.number().min(0).max(1).default(.35),
-	commaPauseMultiplier: z.number().min(1).default(3),
-	sentencePauseMultiplier: z.number().min(1).default(5.5),
-	paragraphPauseMultiplier: z.number().min(1).default(7)
-})]);
-const TextScrambleConfigSchema = z.object({
-	enabled: z.boolean().default(false),
-	charset: z.enum([
-		"ascii",
-		"alphanumeric",
-		"matrix",
-		"binary",
-		"hex",
-		"custom"
-	]).default("alphanumeric"),
-	customCharset: z.string().optional(),
-	scrambleFramesPerChar: z.number().int().min(1).default(8),
-	highlightProbability: z.number().min(0).max(1).default(.25),
-	scrambleColor: z.string().optional()
-});
-const TypewriterAnimatorSchema = z.object({
-	granularity: z.enum([
-		"character",
-		"word",
-		"line"
-	]).default("character"),
-	cursor: TextCursorConfigSchema.default({
-		enabled: true,
-		style: "bar",
-		customChar: "|",
-		blinkFrequency: 2,
-		hideOnComplete: false,
-		width: 2.5,
-		spacing: 3
-	}),
-	cadence: TypingCadenceSchema.default({
-		mode: "human",
-		jitter: .35,
-		commaPauseMultiplier: 3,
-		sentencePauseMultiplier: 5.5,
-		paragraphPauseMultiplier: 7
-	}),
-	scramble: TextScrambleConfigSchema.default({
-		enabled: false,
-		charset: "alphanumeric",
-		scrambleFramesPerChar: 8,
-		highlightProbability: .25
-	}),
-	soundSync: z.boolean().default(false)
-});
-const SelectorBasedOnSchema = z.enum([
-	"characters",
-	"characters_excluding_spaces",
-	"words",
-	"lines"
-]);
-const SelectorUnitsSchema = z.enum(["percentage", "index"]);
-const SelectorShapeSchema = z.enum([
-	"square",
-	"ramp_up",
-	"ramp_down",
-	"triangle",
-	"round",
-	"smooth"
-]);
-const SelectorModeSchema = z.enum([
-	"add",
-	"subtract",
-	"intersect",
-	"min",
-	"max",
-	"difference"
-]);
-const TextRangeSelectorSchema = z.object({
-	type: z.literal("range"),
-	start: z.number().default(0),
-	end: z.number().default(1),
-	offset: z.number().default(0),
-	units: SelectorUnitsSchema.default("percentage"),
-	basedOn: SelectorBasedOnSchema.default("characters"),
-	shape: SelectorShapeSchema.default("square"),
-	mode: SelectorModeSchema.default("add"),
-	amount: z.number().min(-1).max(1).default(1),
-	easeHigh: z.number().min(-1).max(1).default(0),
-	easeLow: z.number().min(-1).max(1).default(0),
-	randomizeOrder: z.boolean().default(false),
-	randomSeed: z.number().int().default(12345)
-});
-const TextWigglySelectorSchema = z.object({
-	type: z.literal("wiggly"),
-	wigglesPerSecond: z.number().positive().default(2),
-	correlation: z.number().min(0).max(1).default(.5),
-	temporalPhaseDeg: z.number().default(0),
-	spatialPhaseDeg: z.number().default(0),
-	minAmount: z.number().min(-1).max(1).default(-1),
-	maxAmount: z.number().min(-1).max(1).default(1),
-	randomSeed: z.number().int().default(42),
-	basedOn: SelectorBasedOnSchema.default("characters"),
-	mode: SelectorModeSchema.default("intersect")
-});
-const TextSignalSelectorSchema = z.object({
-	type: z.literal("signal"),
-	signalId: z.string(),
-	multiplier: z.number().default(1),
-	offset: z.number().default(0),
-	phaseSpread: z.number().default(0),
-	basedOn: SelectorBasedOnSchema.default("characters"),
-	mode: SelectorModeSchema.default("add")
-});
-const TextSelectorSchema = z.discriminatedUnion("type", [
-	TextRangeSelectorSchema,
-	TextWigglySelectorSchema,
-	TextSignalSelectorSchema
-]);
-const AnimatableGlyphPropsSchema = z.object({
-	x: z.number().optional(),
-	y: z.number().optional(),
-	z: z.number().optional(),
-	scale: z.number().optional(),
-	scaleX: z.number().optional(),
-	scaleY: z.number().optional(),
-	rotation: z.number().optional(),
-	rotationX: z.number().optional(),
-	rotationY: z.number().optional(),
-	skew: z.number().optional(),
-	skewAxis: z.number().optional(),
-	tracking: z.number().optional(),
-	lineSpacing: z.number().optional(),
-	opacity: z.number().min(0).max(1).optional(),
-	fillColor: z.string().optional(),
-	strokeColor: z.string().optional(),
-	strokeWidth: z.number().min(0).optional(),
-	blur: z.number().min(0).optional(),
-	characterOffset: z.number().int().optional()
-});
-const GlyphAnchorGroupingSchema = z.enum([
-	"character",
-	"word",
-	"line",
-	"all"
+	"group"
 ]);
-const GlyphAnchorPointSchema = z.object({
-	grouping: GlyphAnchorGroupingSchema.default("character"),
-	anchorX: z.number().default(.5),
-	anchorY: z.number().default(.8)
-});
-const AETextAnimatorSchema = z.object({
-	name: z.string().default("Animator"),
-	selectors: z.array(TextSelectorSchema).min(1),
-	props: AnimatableGlyphPropsSchema,
-	anchor: GlyphAnchorPointSchema.default({
-		grouping: "character",
-		anchorX: .5,
-		anchorY: .8
-	})
-});
-const EnhancedTextNodeSchema = z.object({
-	text: z.string(),
-	fontFamily: z.string().default("Inter"),
-	fontSize: z.number().positive().default(24),
-	fontWeight: z.union([z.number(), z.string()]).default(400),
-	fill: z.string().default("#ffffff"),
-	letterSpacing: z.number().default(0),
-	lineHeight: z.number().positive().default(1.2),
-	textAlign: z.enum([
-		"left",
-		"center",
-		"right"
-	]).default("left"),
-	pathOptions: TextPathOptionsSchema.optional(),
-	typewriter: TypewriterAnimatorSchema.optional(),
-	animators: z.array(AETextAnimatorSchema).default([])
-});
-/**
-* @file packages/compositions/src/program/text-animations/builder.ts
-* Fluent builders for Path-Following Text and After Effects Text Animators.
-*/
-/**
-* Fluent builder for creating Path-Following Text configurations.
-*/
-var TextPathBuilder = class TextPathBuilder$1 {
-	options = {
-		firstMargin: 0,
-		lastMargin: 0,
-		reversePath: false,
-		perpendicularToPath: true,
-		forceAlignment: false,
-		loop: false,
-		baselineOffset: "baseline",
-		baselineShift: 0
+/** Whether a layer puts pixels behind whatever is drawn after it (text over text aside). */
+function paints(node) {
+	if (node.kind === "text" || node.kind === "light" || node.kind === "camera") return false;
+	if (!CONTAINERS.has(String(node.kind))) return true;
+	const bg = node.background;
+	if (typeof bg === "string" && bg !== "" && bg !== "transparent") return true;
+	return (node.children ?? []).some(paints);
+}
+const byZ = (nodes) => [...nodes].sort((a, b) => (Number(a.zIndex) || 0) - (Number(b.zIndex) || 0));
+function solidColor(value) {
+	if (typeof value !== "string" || value.includes("gradient(")) return null;
+	const c = parseCssColor(value);
+	return c && c[3] > .99 ? value : null;
+}
+function lintComposition(config) {
+	const out = [];
+	const push = (severity, code, message, layerId) => out.push({
+		severity,
+		code,
+		message,
+		...layerId && { layerId }
+	});
+	const W = config.width;
+	const H = config.height;
+	let hasEnvironment = false;
+	const ambientLights = [];
+	let has3D = false;
+	const pbrNodes = [];
+	const shadowLights = [];
+	const visit = (node, backdrop, atRoot) => {
+		const id = String(node.id ?? "?");
+		for (const prop of COLOR_PROPS) {
+			const v = node[prop];
+			if (typeof v !== "string" || v === "" || v === "transparent") continue;
+			if (v.includes("gradient(")) {
+				if (!parseCssGradient(v)) push("error", "invalid_gradient", `\`${prop}\` on '${id}' is not a gradient this renderer reads: ${v}. It draws nothing.`, id);
+			} else if (!parseCssColor(v)) push("warning", "unknown_color", `\`${prop}: "${v}"\` on '${id}' is not a color (hex, rgb(), hsl(), oklch() or a CSS name). It draws transparent.`, id);
+		}
+		if (node.kind === "light") {
+			const type = node.lightType ?? "directional";
+			if (type === "environment") hasEnvironment = true;
+			if (type === "ambient") ambientLights.push(id);
+			if (node.castShadow) if (type === "directional" || type === "spot") shadowLights.push(id);
+			else push("warning", "shadow_unsupported_light", `'${id}' is a ${String(type)} light: only directional and spot lights cast shadows.`, id);
+			return;
+		}
+		if (node.kind === "camera") return;
+		if (node.kind === "media") {
+			const src = node.inputHandleId;
+			if (typeof src === "string") {
+				if ((node.dataType ?? "Video") === "Image") {
+					if (/\.(json|lottie)(\?.*)?$/i.test(src)) push("error", "unsupported_image_format", `'${id}' is an image layer with source '${src}', which is a Lottie vector animation. Use Layer.lottie() instead.`, id);
+					else if (/\.(mp4|mov|webm|mkv)(\?.*)?$/i.test(src)) push("error", "unsupported_image_format", `'${id}' is an image layer with video source '${src}'. Use Layer.video() instead.`, id);
+					else if (/\.(mp3|wav|ogg|m4a|aac)(\?.*)?$/i.test(src)) push("error", "unsupported_image_format", `'${id}' is an image layer with audio source '${src}'. Use Layer.audio() instead.`, id);
+				}
+			}
+		}
+		const is3D = Boolean(node.is3D) || typeof node.z === "number" && node.z !== 0;
+		if (is3D || node.kind === "model3d") has3D = true;
+		if (node.roughness !== void 0 || node.metallic !== void 0) pbrNodes.push(id);
+		if (node.kind === "text" && backdrop && !animates(node, ["fill", "color"])) {
+			const fg = solidColor(node.fill ?? node.color);
+			const behind = solidColor(node.background) ?? backdrop;
+			if (fg) {
+				const ratio = Color.contrast(fg, behind);
+				if (ratio < MIN_TEXT_CONTRAST) push("warning", "low_contrast_text", `Text '${id}' (${fg}) on ${behind} has contrast ${ratio.toFixed(2)}:1 (aim for ≥ ${MIN_TEXT_CONTRAST}; ${Color.readableOn(behind)} reads well).`, id);
+			}
+		}
+		if (atRoot && !is3D && node.position === "absolute" && typeof node.x === "number" && typeof node.y === "number" && typeof node.width === "number" && typeof node.height === "number" && !animates(node, [
+			"x",
+			"y",
+			"translateX",
+			"translateY",
+			"scale",
+			"rotation"
+		])) {
+			const { x, y, width, height } = node;
+			if (x + width <= 0 || y + height <= 0 || x >= W || y >= H) push("warning", "offscreen_layer", `'${id}' sits entirely outside the ${W}×${H} canvas (x ${x}, y ${y}) and never moves in.`, id);
+		}
+		for (const t of tracksOf(node)) {
+			const kfs = t.keyframes ?? [];
+			if ((!t.source || t.source.type === "keyframe") && kfs.length >= 2 && kfs.every((k) => JSON.stringify(k.value) === JSON.stringify(kfs[0].value))) push("info", "static_track", `'${id}' animates \`${t.prop}\` but every keyframe holds ${JSON.stringify(kfs[0].value)}.`, id);
+		}
+		const ownBackdrop = solidColor(node.background) ?? backdrop;
+		const children = node.children;
+		const fullFrame = node.x === 0 && node.y === 0 && node.width === W && node.height === H;
+		visitLevel(children ?? [], ownBackdrop, atRoot && fullFrame);
 	};
-	static fromSvg(svgPath) {
-		const builder = new TextPathBuilder$1();
-		builder.options.path = {
-			type: "svg",
-			d: svgPath
-		};
-		return builder;
-	}
-	static fromBezier(segments) {
-		const builder = new TextPathBuilder$1();
-		builder.options.path = {
-			type: "bezier",
-			segments
-		};
-		return builder;
-	}
-	static fromCurve(curve) {
-		return TextPathBuilder$1.fromBezier([curve]);
-	}
-	static circularBadge(cx, cy, radius) {
-		const builder = new TextPathBuilder$1();
-		builder.options.path = {
-			type: "ellipse",
-			cx,
-			cy,
-			rx: radius,
-			ry: radius,
-			startAngleDeg: 0,
-			endAngleDeg: 360
-		};
-		builder.options.loop = true;
-		return builder;
-	}
-	static ellipse(cx, cy, rx, ry, startAngleDeg = 0, endAngleDeg = 360) {
-		const builder = new TextPathBuilder$1();
-		builder.options.path = {
-			type: "ellipse",
-			cx,
-			cy,
-			rx,
-			ry,
-			startAngleDeg,
-			endAngleDeg
-		};
-		builder.options.loop = Math.abs(endAngleDeg - startAngleDeg) >= 360;
-		return builder;
-	}
-	static wave(startX, startY, length, amplitude, frequency, phaseDeg = 0) {
-		const builder = new TextPathBuilder$1();
-		builder.options.path = {
-			type: "wave",
-			startX,
-			startY,
-			length,
-			amplitude,
-			frequency,
-			phaseDeg
-		};
-		return builder;
-	}
-	firstMargin(margin) {
-		this.options.firstMargin = margin;
-		return this;
-	}
-	lastMargin(margin) {
-		this.options.lastMargin = margin;
-		return this;
-	}
-	reversePath(reverse) {
-		this.options.reversePath = reverse;
-		return this;
-	}
-	perpendicularToPath(perpendicular) {
-		this.options.perpendicularToPath = perpendicular;
-		return this;
-	}
-	forceAlignment(force) {
-		this.options.forceAlignment = force;
-		return this;
-	}
-	loop(isLoop) {
-		this.options.loop = isLoop;
-		return this;
-	}
-	baselineOffset(offset) {
-		this.options.baselineOffset = offset;
-		return this;
-	}
-	baselineShift(shiftPixels) {
-		this.options.baselineShift = shiftPixels;
-		return this;
-	}
-	build() {
-		return TextPathOptionsSchema.parse(this.options);
-	}
-};
-/**
-* Fluent builder for After Effects Range, Wiggly, and Signal Animators.
-*/
-var TextAnimatorBuilder = class TextAnimatorBuilder$1 {
-	name = "Animator";
-	selectors = [];
-	props = {};
-	anchor = {
-		grouping: "character",
-		anchorX: .5,
-		anchorY: .8
+	const visitLevel = (nodes, backdrop, atRoot) => {
+		let known = backdrop;
+		for (const n of byZ(nodes)) {
+			visit(n, known, atRoot);
+			if (paints(n)) known = null;
+		}
 	};
-	static create(name) {
-		const builder = new TextAnimatorBuilder$1();
-		builder.name = name;
-		return builder;
-	}
-	/** Adds an After Effects Range Selector */
-	addRangeSelector(config) {
-		const rawHigh = config.easeHigh ?? 0;
-		const easeHigh = Math.abs(rawHigh) > 1 ? rawHigh / 100 : rawHigh;
-		const rawLow = config.easeLow ?? 0;
-		const easeLow = Math.abs(rawLow) > 1 ? rawLow / 100 : rawLow;
-		this.selectors.push({
-			type: "range",
-			start: config.start ?? 0,
-			end: config.end ?? 1,
-			offset: config.offset ?? 0,
-			units: "percentage",
-			basedOn: config.basedOn ?? "characters",
-			shape: config.shape ?? "smooth",
-			mode: config.mode ?? "add",
-			amount: 1,
-			easeHigh: Math.max(-1, Math.min(1, easeHigh)),
-			easeLow: Math.max(-1, Math.min(1, easeLow)),
-			randomizeOrder: config.randomizeOrder ?? false,
-			randomSeed: config.randomSeed ?? 12345
-		});
-		return this;
-	}
-	/** Adds an After Effects Wiggly Selector for procedural organic flutter */
-	addWigglySelector(config) {
-		this.selectors.push({
-			type: "wiggly",
-			wigglesPerSecond: config.wigglesPerSecond ?? 2,
-			correlation: config.correlation ?? .5,
-			temporalPhaseDeg: 0,
-			spatialPhaseDeg: 0,
-			minAmount: config.minAmount ?? -1,
-			maxAmount: config.maxAmount ?? 1,
-			randomSeed: config.randomSeed ?? 42,
-			basedOn: "characters",
-			mode: config.mode ?? "intersect"
-		});
-		return this;
-	}
-	/** Adds a reactive signal selector */
-	addSignalSelector(signalId, multiplier = 1, phaseSpread = 0, offset = 0, mode = "add") {
-		this.selectors.push({
-			type: "signal",
-			signalId,
-			multiplier,
-			offset,
-			phaseSpread,
-			basedOn: "characters",
-			mode
-		});
-		return this;
-	}
-	x(pixels) {
-		this.props.x = pixels;
-		return this;
+	const rootBackdrop = solidColor(config.backgroundColor) ?? null;
+	visitLevel(config.layout, rootBackdrop, true);
+	if (hasEnvironment && ambientLights.length > 0) push("info", "ambient_with_environment", `The environment already fills shadows with light; ambient light ${ambientLights.join(", ")} adds flat light on top (remove it, or lower it, if the scene looks washed out).`);
+	if (shadowLights.length > 1) push("info", "multiple_shadow_lights", `${shadowLights.length} lights cast shadows (${shadowLights.join(", ")}); only the first one does.`);
+	if (has3D && pbrNodes.length > 0 && !hasEnvironment) push("info", "pbr_without_environment", `roughness / metallic are set (${pbrNodes.slice(0, 3).join(", ")}${pbrNodes.length > 3 ? ", …" : ""}) but the scene has no Layer.environment(): add one for physically based shading, reflections and tone mapping.`);
+	return out;
+}
+const GEOMETRY = [
+	"x",
+	"y",
+	"width",
+	"height"
+];
+function hoistOne(owner) {
+	const matte = owner.matte;
+	const { matte: _drop, ...rest } = owner;
+	const self = { ...rest };
+	if (Array.isArray(self.children)) self.children = hoistMattes(self.children);
+	if (!matte?.node) return [self];
+	const src = matte.node;
+	const id = src.id ?? `${String(owner.id)}__matte`;
+	const node = {
+		position: "absolute",
+		...src,
+		id,
+		matteOf: String(owner.id),
+		matteMode: matte.mode ?? "alpha"
+	};
+	if (GEOMETRY.every((k) => src[k] === void 0)) {
+		for (const k of GEOMETRY) if (typeof owner[k] === "number") node[k] = owner[k];
 	}
-	y(pixels) {
-		this.props.y = pixels;
-		return this;
-	}
-	z(pixels) {
-		this.props.z = pixels;
-		return this;
-	}
-	scale(scaleValue) {
-		this.props.scale = scaleValue;
-		return this;
-	}
-	scaleX(scaleValue) {
-		this.props.scaleX = scaleValue;
-		return this;
-	}
-	scaleY(scaleValue) {
-		this.props.scaleY = scaleValue;
-		return this;
-	}
-	rotation(degrees) {
-		this.props.rotation = degrees;
-		return this;
-	}
-	rotationX(degrees) {
-		this.props.rotationX = degrees;
-		return this;
-	}
-	rotationY(degrees) {
-		this.props.rotationY = degrees;
-		return this;
-	}
-	skew(degrees) {
-		this.props.skew = degrees;
-		return this;
-	}
-	skewAxis(degrees) {
-		this.props.skewAxis = degrees;
-		return this;
-	}
-	opacity(value) {
-		this.props.opacity = value;
-		return this;
-	}
-	blur(pixels) {
-		this.props.blur = pixels;
-		return this;
-	}
-	fill(colorHex) {
-		return this.fillColor(colorHex);
-	}
-	fillColor(colorHex) {
-		this.props.fillColor = colorHex;
-		return this;
-	}
-	strokeColor(colorHex) {
-		this.props.strokeColor = colorHex;
-		return this;
-	}
-	strokeWidth(pixels) {
-		this.props.strokeWidth = pixels;
-		return this;
-	}
-	tracking(spacingPixels) {
-		this.props.tracking = spacingPixels;
-		return this;
-	}
-	lineSpacing(spacingPixels) {
-		this.props.lineSpacing = spacingPixels;
-		return this;
-	}
-	characterOffset(offset) {
-		this.props.characterOffset = offset;
-		return this;
-	}
-	anchorGrouping(grouping, anchorX = .5, anchorY = .8) {
-		this.anchor = {
-			grouping,
-			anchorX,
-			anchorY
-		};
-		return this;
-	}
-	build() {
-		return AETextAnimatorSchema.parse({
-			name: this.name,
-			selectors: this.selectors,
-			props: this.props,
-			anchor: this.anchor
-		});
-	}
-};
-/**
-* Evaluates closed-form underdamped harmonic oscillator for spring physics:
-*
-*   x(t) = target + (x0 - target) * exp(-zeta * omega_n * t) *
-*          [ cos(omega_d * t) + (zeta / sqrt(1 - zeta^2)) * sin(omega_d * t) ]
-*
-* @param t Time in seconds since excitation
-* @param stiffness Spring stiffness (k)
-* @param damping Damping coefficient (c)
-* @param mass Mass of glyph (m)
-* @param initialVelocity Initial velocity (v0)
-* @returns Settled scalar progress in [0, 1] with overshoot
-*/
-function evaluateSpringProgress(t, stiffness = 180, damping = 12, mass = 1, initialVelocity = 0) {
-	if (t <= 0) return 0;
-	const omega_n = Math.sqrt(Math.max(1e-4, stiffness) / Math.max(1e-4, mass));
-	const zeta = damping / (2 * Math.sqrt(Math.max(1e-4, stiffness * mass)));
-	if (zeta < 1) {
-		const omega_d = omega_n * Math.sqrt(1 - zeta * zeta);
-		const decay = Math.exp(-zeta * omega_n * t);
-		const c1 = -1;
-		const c2 = (initialVelocity - zeta * omega_n * -1) / Math.max(1e-6, omega_d);
-		const displacement = decay * (c1 * Math.cos(omega_d * t) + c2 * Math.sin(omega_d * t));
-		return Math.min(2, Math.max(-1, 1 + displacement));
-	} else if (Math.abs(zeta - 1) < 1e-4) {
-		const decay = Math.exp(-omega_n * t);
-		return 1 + (-1 + (initialVelocity - omega_n) * t) * decay;
-	} else {
-		const s1 = -omega_n * (zeta - Math.sqrt(zeta * zeta - 1));
-		const s2 = -omega_n * (zeta + Math.sqrt(zeta * zeta - 1));
-		const c1 = (initialVelocity + s2) / Math.max(1e-6, s1 - s2);
-		const c2 = -1 - c1;
-		return 1 + (c1 * Math.exp(s1 * t) + c2 * Math.exp(s2 * t));
-	}
-}
-/**
-* Evaluates 2D Directional Skew matrix components:
-*
-*   S(theta, phi) = R(phi) * [ 1  tan(theta) ] * R(-phi)
-*                            [ 0      1     ]
-*
-* @param skewDeg Skew angle in degrees
-* @param skewAxisDeg Skew axis in degrees
-* @returns 2x2 affine shear matrix components [m00, m01, m10, m11]
-*/
-function evaluateSkewMatrix(skewDeg, skewAxisDeg = 0) {
-	if (skewDeg === 0) return [
-		1,
-		0,
-		0,
-		1
-	];
-	const theta = skewDeg * Math.PI / 180;
-	const phi = skewAxisDeg * Math.PI / 180;
-	const cosPhi = Math.cos(phi);
-	const sinPhi = Math.sin(phi);
-	const tanTheta = Math.tan(theta);
-	return [
-		1 - tanTheta * cosPhi * sinPhi,
-		tanTheta * cosPhi * cosPhi,
-		-tanTheta * sinPhi * sinPhi,
-		1 + tanTheta * sinPhi * cosPhi
-	];
-}
-/**
-* Computes anchor pivot coordinates relative to glyph bounding box:
-*
-* @param bbox Glyph bounding box { width, height, ascender, descender }
-* @param config Text anchor configuration
-* @returns Pivot offset (px, py) relative to glyph quad center
-*/
-function computeAnchorPivotOffset(bbox, config) {
-	let normX = config.anchorX;
-	let normY = config.anchorY;
-	switch (config.preset) {
-		case "center":
-			normX = .5;
-			normY = .5;
-			break;
-		case "baseline":
-			normX = .5;
-			normY = bbox.height > 0 ? bbox.ascender / bbox.height : .8;
-			break;
-		case "bottom_left":
-			normX = 0;
-			normY = 1;
-			break;
-		case "bottom_center":
-			normX = .5;
-			normY = 1;
-			break;
-		case "bottom_right":
-			normX = 1;
-			normY = 1;
-			break;
-		case "top_left":
-			normX = 0;
-			normY = 0;
-			break;
-		case "top_center":
-			normX = .5;
-			normY = 0;
-			break;
-		case "top_right":
-			normX = 1;
-			normY = 0;
-			break;
-		default:
-			normX = .5;
-			normY = .5;
-			break;
-	}
-	return {
-		px: (normX - .5) * bbox.width + config.offsetX,
-		py: (normY - .5) * bbox.height + config.offsetY
-	};
-}
-/**
-* Computes leading displacement per line based on lineAnchor:
-*
-* @param lineIndex 0-based index of current line
-* @param lineCount Total lines in paragraph
-* @param lineSpacing Additional leading in pixels
-* @param lineAnchor Pivot line anchor in [0, 1]
-* @returns Y displacement in pixels
-*/
-function computeLineLeadingDisplacement(lineIndex, lineCount, lineSpacing, lineAnchor = 0) {
-	if (lineSpacing === 0 || lineCount <= 1) return 0;
-	return (lineIndex - lineAnchor * (lineCount - 1)) * lineSpacing;
-}
-/**
-* Evaluates an Expression Selector formula safely in a sandboxed numeric scope.
-*
-* @param expression Formula string (e.g. "Math.sin(time * 4 + textIndex * 0.2)")
-* @param ctx Glyph evaluation context
-* @returns Numeric selector weight clamped to [-1, 1]
-*/
-function evaluateExpressionSelector(expression, ctx) {
-	try {
-		const scope = {
-			textIndex: ctx.charIndex,
-			textTotal: Math.max(1, ctx.totalChars),
-			wordIndex: ctx.wordIndex,
-			wordTotal: Math.max(1, ctx.totalWords),
-			lineIndex: ctx.lineIndex,
-			lineTotal: Math.max(1, ctx.totalLines),
-			time: ctx.time,
-			frame: ctx.frame,
-			fps: ctx.fps,
-			sin: Math.sin,
-			cos: Math.cos,
-			tan: Math.tan,
-			exp: Math.exp,
-			log: Math.log,
-			abs: Math.abs,
-			min: Math.min,
-			max: Math.max,
-			sqrt: Math.sqrt,
-			pow: Math.pow,
-			floor: Math.floor,
-			ceil: Math.ceil,
-			round: Math.round,
-			PI: Math.PI,
-			clamp: (v, lo, hi) => Math.max(lo, Math.min(hi, v)),
-			noise: (seed) => {
-				const n = Math.sin(seed * 12.9898 + ctx.frame * .1) * 43758.5453;
-				return (n - Math.floor(n)) * 2 - 1;
-			},
-			signals: ctx.signals ?? {}
-		};
-		const keys = Object.keys(scope);
-		const values = Object.values(scope);
-		const fn = new Function(...keys, `return (${expression});`);
-		const result = Number(fn(...values));
-		return Number.isFinite(result) ? Math.max(-1, Math.min(1, result)) : 0;
-	} catch {
-		return 0;
-	}
-}
-/**
-* Evaluates 3D Volumetric Formation parametric coordinates.
-*/
-function evaluateVolumetricFormation(glyphIndex, totalGlyphs, config) {
-	const n = Math.max(1, totalGlyphs);
-	const norm = n > 1 ? glyphIndex / (n - 1) : 0;
-	const totalAngleRad = config.totalAngle * Math.PI / 180;
-	const phi = norm * totalAngleRad;
-	let x = 0;
-	let y = 0;
-	let z$1$1 = 0;
-	let rotX = 0;
-	let rotY = 0;
-	let rotZ = 0;
-	let depthOpacity = 1;
-	switch (config.mode) {
-		case "cylinder": {
-			const theta = config.totalAngle < 360 ? (norm - .5) * totalAngleRad : phi;
-			if (config.axis === "y") {
-				x = config.radius * Math.sin(theta);
-				z$1$1 = config.radius * Math.cos(theta) - config.radius;
-				rotY = theta * 180 / Math.PI;
-			} else if (config.axis === "x") {
-				y = config.radius * Math.sin(theta);
-				z$1$1 = config.radius * Math.cos(theta) - config.radius;
-				rotX = theta * 180 / Math.PI;
-			} else {
-				x = config.radius * Math.sin(theta);
-				y = config.radius * Math.cos(theta);
-				rotZ = theta * 180 / Math.PI;
-			}
-			const facing = Math.cos(theta);
-			depthOpacity = Math.max(.25, (facing + 1) * .5);
-			break;
-		}
-		case "vortex": {
-			const spiralPhi = -Math.PI / 2 + phi;
-			const r = config.radius * (1 - norm * .35);
-			x = r * Math.cos(spiralPhi);
-			y = r * Math.sin(spiralPhi);
-			z$1$1 = -glyphIndex * config.pitch || 0;
-			const dr = -.35 * config.radius / (totalAngleRad || 1);
-			const dx = dr * Math.cos(spiralPhi) - r * Math.sin(spiralPhi);
-			const dy = dr * Math.sin(spiralPhi) + r * Math.cos(spiralPhi);
-			rotZ = Math.atan2(dy, dx) * 180 / Math.PI;
-			depthOpacity = Math.max(.65, 1 - norm * .35);
-			break;
-		}
-		case "helix":
-			if (config.axis === "x") {
-				const pitchX = config.pitch > 10 ? config.pitch : 28;
-				x = (glyphIndex - (n - 1) / 2) * pitchX;
-				y = config.radius * Math.sin(phi);
-				z$1$1 = config.radius * Math.cos(phi) - config.radius;
-				rotX = Math.sin(phi) * 22;
-				depthOpacity = .75 + .25 * ((Math.cos(phi) + 1) * .5);
-			} else {
-				const theta = (norm - .5) * totalAngleRad;
-				x = config.radius * Math.sin(theta);
-				y = (glyphIndex - (n - 1) / 2) * config.pitch;
-				z$1$1 = config.radius * Math.cos(theta) - config.radius;
-				rotY = theta * 180 / Math.PI;
-				const facing = Math.cos(theta);
-				depthOpacity = Math.max(.65, (facing + 1) * .5);
-			}
-			break;
-		default:
-			z$1$1 = 0;
-			break;
-	}
-	const perspective = Math.max(100, config.perspective ?? 1200);
-	const depthDist = perspective - z$1$1;
-	const scaleMult = depthDist > 1 ? perspective / depthDist : 1;
-	return {
-		x: x * scaleMult,
-		y: y * scaleMult,
-		z: z$1$1,
-		rotX,
-		rotY,
-		rotZ,
-		scaleMult: Math.max(.1, scaleMult),
-		depthOpacity
-	};
-}
-/**
-* Evaluates infinite kinetic marquee translation and snapping.
-*/
-function evaluateMarqueeOffset(baseX, containerWidth, contentWidth, config, elapsedSec) {
-	const totalSpan = (containerWidth > 0 ? Math.max(containerWidth, contentWidth) : contentWidth) + config.repeatGap;
-	if (totalSpan <= 0) return baseX;
-	let travel = config.velocity * elapsedSec;
-	if (config.snap?.enabled) {
-		const targetPos = (config.snap.stopIndex ?? 0) * (config.snap.granularity === "character" ? 40 : 120);
-		const decelFactor = Math.min(1, elapsedSec * 1.5);
-		travel = travel * (1 - decelFactor) + targetPos * decelFactor;
-	}
-	if (config.direction === "right" || config.direction === "down") travel = -travel;
-	if (config.loop) {
-		const wrapped = (baseX - travel) % totalSpan;
-		return wrapped < -contentWidth ? wrapped + totalSpan : wrapped;
-	}
-	return baseX - travel;
-}
-/**
-* Samples audio FFT frequency bin and computes scale factor for Audio Spectrum Typography.
-*/
-function sampleAudioSpectrumScale(glyphIndex, totalGlyphs, config, signals, frame, fps) {
-	const n = Math.max(1, totalGlyphs);
-	const norm = n > 1 ? glyphIndex / (n - 1) : .5;
-	const minFreq = Math.max(20, config.minFreqHz);
-	const targetFreq = minFreq * (Math.max(minFreq + 100, config.maxFreqHz) / minFreq) ** norm;
-	let magnitude = 0;
-	if (signals) {
-		const sig = signals[config.signalChannel];
-		if (typeof sig === "number") magnitude = sig;
-		else if (typeof sig === "function") magnitude = Number(sig(frame, fps, targetFreq)) || 0;
-		else if (typeof sig === "object" && sig !== null) {
-			const sObj = sig;
-			if (typeof sObj.get === "function") magnitude = Number(sObj.get({
-				frame,
-				fps,
-				freq: targetFreq
-			})) || 0;
-			else if (Array.isArray(sObj.samples) || ArrayBuffer.isView(sObj.samples)) {
-				const arr = sObj.samples;
-				const binIdx = Math.floor(norm * (arr.length - 1));
-				magnitude = Number(arr[binIdx]) || 0;
-			}
-		}
-	}
-	const clampedMag = Math.max(0, Math.min(1, magnitude));
-	return config.minScale + clampedMag * (config.maxScale - config.minScale);
-}
-/**
-* Evaluates a point on a cubic Bezier curve at parameter t in [0, 1].
-*/
-function evaluateCubicBezier(segment, t) {
-	const u = 1 - t;
-	const tt = t * t;
-	const uu = u * u;
-	const uuu = uu * u;
-	const ttt = tt * t;
-	return {
-		x: uuu * segment.p0.x + 3 * uu * t * segment.p1.x + 3 * u * tt * segment.p2.x + ttt * segment.p3.x,
-		y: uuu * segment.p0.y + 3 * uu * t * segment.p1.y + 3 * u * tt * segment.p2.y + ttt * segment.p3.y
-	};
-}
-/**
-* Evaluates the first derivative (tangent velocity vector) of a cubic Bezier curve at parameter t.
-*/
-function evaluateCubicBezierDerivative(segment, t) {
-	const u = 1 - t;
-	return {
-		x: 3 * u * u * (segment.p1.x - segment.p0.x) + 6 * u * t * (segment.p2.x - segment.p1.x) + 3 * t * t * (segment.p3.x - segment.p2.x),
-		y: 3 * u * u * (segment.p1.y - segment.p0.y) + 6 * u * t * (segment.p2.y - segment.p1.y) + 3 * t * t * (segment.p3.y - segment.p2.y)
-	};
-}
-/**
-* Generates an arc-length parameterization lookup table (LUT) for a cubic Bezier segment.
-* Ensures glyphs travel with uniform speed and do not bunch up on tight curve bends.
-*/
-function generateArcLengthLUT(segment, samples = 100) {
-	const lut = [{
-		distance: 0,
-		t: 0
-	}];
-	let accumulatedDist = 0;
-	let prevPoint = segment.p0;
-	for (let i = 1; i <= samples; i++) {
-		const t = i / samples;
-		const currentPoint = evaluateCubicBezier(segment, t);
-		const dx = currentPoint.x - prevPoint.x;
-		const dy = currentPoint.y - prevPoint.y;
-		accumulatedDist += Math.hypot(dx, dy);
-		lut.push({
-			distance: accumulatedDist,
-			t
-		});
-		prevPoint = currentPoint;
-	}
-	return {
-		lut,
-		totalLength: accumulatedDist
-	};
-}
-/**
-* Maps a distance along the curve (in pixels) to normalized curve parameter t via binary search on the LUT.
-*/
-function distanceToCurveParameter(lut, distance, totalLength) {
-	if (distance <= 0) return 0;
-	if (distance >= totalLength) return 1;
-	let low = 0;
-	let high = lut.length - 1;
-	while (low <= high) {
-		const mid = low + high >> 1;
-		if (lut[mid].distance < distance) low = mid + 1;
-		else high = mid - 1;
-	}
-	const index = Math.max(1, Math.min(low, lut.length - 1));
-	const prev = lut[index - 1];
-	const curr = lut[index];
-	const segmentDist = curr.distance - prev.distance;
-	if (segmentDist <= 1e-6) return prev.t;
-	const ratio = (distance - prev.distance) / segmentDist;
-	return prev.t + ratio * (curr.t - prev.t);
-}
-/**
-* Samples position and baseline tangent orientation angle along a curve at distance `dist`.
-*/
-function sampleCurveGeometry(segment, lut, totalLength, distance) {
-	const t = distanceToCurveParameter(lut, distance, totalLength);
-	const pos = evaluateCubicBezier(segment, t);
-	const deriv = evaluateCubicBezierDerivative(segment, t);
-	const length = Math.hypot(deriv.x, deriv.y);
-	const nx = length > 1e-6 ? -deriv.y / length : 0;
-	const ny = length > 1e-6 ? deriv.x / length : 1;
-	return {
-		position: pos,
-		tangentAngleDeg: Math.atan2(deriv.y, deriv.x) * 180 / Math.PI,
-		normal: {
-			x: nx,
-			y: ny
-		}
-	};
-}
-/**
-* Builds a cumulative Arc-Length LUT across a chain of Cubic Bezier segments.
-*/
-function buildPathLUT(segments, samplesPerSegment = 50) {
-	if (segments.length === 0) return {
-		totalLength: 0,
-		entries: [{
-			distance: 0,
-			segmentIndex: 0,
-			t: 0
-		}],
-		segments: []
-	};
-	const segLuts = [];
-	const entries = [];
-	let accumulatedDist = 0;
-	for (let segIdx = 0; segIdx < segments.length; segIdx++) {
-		const seg = segments[segIdx];
-		const { lut: segLut, totalLength: segLength } = generateArcLengthLUT(seg, samplesPerSegment);
-		segLuts.push({
-			segmentIndex: segIdx,
-			startDistance: accumulatedDist,
-			length: segLength,
-			lut: segLut
-		});
-		for (let i = 0; i < segLut.length; i++) entries.push({
-			distance: accumulatedDist + segLut[i].distance,
-			segmentIndex: segIdx,
-			t: segLut[i].t
-		});
-		accumulatedDist += segLength;
-	}
-	return {
-		totalLength: accumulatedDist,
-		entries,
-		segments: segLuts
-	};
-}
-/**
-* Samples position, tangent angle, and normal across a chain of Cubic Bezier segments.
-*/
-function samplePathChainGeometry(segments, chainLUT, distance) {
-	if (segments.length === 0) return {
-		position: {
-			x: 0,
-			y: 0
-		},
-		tangentAngleDeg: 0,
-		normal: {
-			x: 0,
-			y: 1
-		}
-	};
-	const totalLength = chainLUT.totalLength;
-	if (distance <= 0) {
-		const seg = segments[0];
-		const deriv$1 = evaluateCubicBezierDerivative(seg, 0);
-		const length$1 = Math.hypot(deriv$1.x, deriv$1.y);
-		const ux = length$1 > 1e-6 ? deriv$1.x / length$1 : 1;
-		const uy = length$1 > 1e-6 ? deriv$1.y / length$1 : 0;
-		const pos$1 = {
-			x: seg.p0.x + ux * distance,
-			y: seg.p0.y + uy * distance
-		};
-		const nx$1 = length$1 > 1e-6 ? -deriv$1.y / length$1 : 0;
-		const ny$1 = length$1 > 1e-6 ? deriv$1.x / length$1 : 1;
-		return {
-			position: pos$1,
-			tangentAngleDeg: Math.atan2(deriv$1.y, deriv$1.x) * 180 / Math.PI,
-			normal: {
-				x: nx$1,
-				y: ny$1
-			}
-		};
-	}
-	if (distance >= totalLength) {
-		const lastSeg = segments[segments.length - 1];
-		const deriv$1 = evaluateCubicBezierDerivative(lastSeg, 1);
-		const length$1 = Math.hypot(deriv$1.x, deriv$1.y);
-		const ux = length$1 > 1e-6 ? deriv$1.x / length$1 : 1;
-		const uy = length$1 > 1e-6 ? deriv$1.y / length$1 : 0;
-		const overflow = distance - totalLength;
-		const pos$1 = {
-			x: lastSeg.p3.x + ux * overflow,
-			y: lastSeg.p3.y + uy * overflow
-		};
-		const nx$1 = length$1 > 1e-6 ? -deriv$1.y / length$1 : 0;
-		const ny$1 = length$1 > 1e-6 ? deriv$1.x / length$1 : 1;
-		return {
-			position: pos$1,
-			tangentAngleDeg: Math.atan2(deriv$1.y, deriv$1.x) * 180 / Math.PI,
-			normal: {
-				x: nx$1,
-				y: ny$1
-			}
-		};
-	}
-	let segIdx = 0;
-	let t = 0;
-	if (chainLUT.segments && chainLUT.segments.length > 0) {
-		let low = 0;
-		let high = chainLUT.segments.length - 1;
-		while (low <= high) {
-			const mid = low + high >> 1;
-			const segLUT$1 = chainLUT.segments[mid];
-			if (distance < segLUT$1.startDistance) high = mid - 1;
-			else if (distance > segLUT$1.startDistance + segLUT$1.length) low = mid + 1;
-			else {
-				low = mid;
-				break;
-			}
-		}
-		const sIdx = Math.max(0, Math.min(low, chainLUT.segments.length - 1));
-		const segLUT = chainLUT.segments[sIdx];
-		segIdx = segLUT.segmentIndex;
-		const localDist = distance - segLUT.startDistance;
-		t = distanceToCurveParameter(segLUT.lut, localDist, segLUT.length);
-	} else {
-		let low = 0;
-		let high = chainLUT.entries.length - 1;
-		while (low <= high) {
-			const mid = low + high >> 1;
-			if (chainLUT.entries[mid].distance < distance) low = mid + 1;
-			else high = mid - 1;
-		}
-		const index = Math.max(1, Math.min(low, chainLUT.entries.length - 1));
-		const prev = chainLUT.entries[index - 1];
-		const curr = chainLUT.entries[index];
-		const segmentDist = curr.distance - prev.distance;
-		const ratio = segmentDist > 1e-6 ? (distance - prev.distance) / segmentDist : 0;
-		segIdx = curr.segmentIndex;
-		t = prev.segmentIndex === curr.segmentIndex ? prev.t + ratio * (curr.t - prev.t) : curr.t;
-	}
-	const segment = segments[segIdx] ?? segments[0];
-	const pos = evaluateCubicBezier(segment, t);
-	const deriv = evaluateCubicBezierDerivative(segment, t);
-	const length = Math.hypot(deriv.x, deriv.y);
-	const nx = length > 1e-6 ? -deriv.y / length : 0;
-	const ny = length > 1e-6 ? deriv.x / length : 1;
-	return {
-		position: pos,
-		tangentAngleDeg: Math.atan2(deriv.y, deriv.x) * 180 / Math.PI,
-		normal: {
-			x: nx,
-			y: ny
-		}
-	};
-}
-/**
-* Converts an ellipse arc into cubic Bezier segments (up to 90 degrees per segment).
-*/
-function ellipseToCubicBeziers(cx, cy, rx, ry, startAngleDeg = 0, endAngleDeg = 360) {
-	const startRad = startAngleDeg * Math.PI / 180;
-	const totalSweep = endAngleDeg * Math.PI / 180 - startRad;
-	const numSegments = Math.max(1, Math.ceil(Math.abs(totalSweep) / (Math.PI / 2)));
-	const sweepStep = totalSweep / numSegments;
-	const segments = [];
-	for (let i = 0; i < numSegments; i++) {
-		const a0 = startRad + i * sweepStep;
-		const a1 = a0 + sweepStep;
-		const halfSweep = sweepStep / 2;
-		const k = 4 / 3 * Math.tan(halfSweep / 2);
-		const cos0 = Math.cos(a0);
-		const sin0 = Math.sin(a0);
-		const cos1 = Math.cos(a1);
-		const sin1 = Math.sin(a1);
-		const p0 = {
-			x: cx + rx * cos0,
-			y: cy + ry * sin0
-		};
-		const p1 = {
-			x: p0.x - k * rx * sin0,
-			y: p0.y + k * ry * cos0
-		};
-		const p3 = {
-			x: cx + rx * cos1,
-			y: cy + ry * sin1
-		};
-		const p2 = {
-			x: p3.x + k * rx * sin1,
-			y: p3.y - k * ry * cos1
-		};
-		segments.push({
-			p0,
-			p1,
-			p2,
-			p3
-		});
-	}
-	return segments;
-}
-/**
-* Converts a sinusoidal wave into cubic Bezier segments per half-cycle.
-*/
-function waveToCubicBeziers(startX, startY, length, amplitude, frequency, phaseDeg = 0) {
-	const phaseRad = phaseDeg * Math.PI / 180;
-	const totalCycles = frequency < .1 && frequency * length >= .25 ? frequency * length : Math.max(.5, frequency);
-	const halfCycles = Math.max(1, Math.round(totalCycles * 2));
-	const dx = length / halfCycles;
-	const segments = [];
-	for (let i = 0; i < halfCycles; i++) {
-		const t0 = i / halfCycles * (2 * Math.PI * totalCycles) + phaseRad;
-		const t1 = (i + 1) / halfCycles * (2 * Math.PI * totalCycles) + phaseRad;
-		const x0 = startX + i * dx;
-		const x3 = startX + (i + 1) * dx;
-		const y0 = startY + amplitude * Math.sin(t0);
-		const y3 = startY + amplitude * Math.sin(t1);
-		const slope0 = amplitude * Math.cos(t0) * (Math.PI / 3);
-		const slope1 = amplitude * Math.cos(t1) * (Math.PI / 3);
-		const p0 = {
-			x: x0,
-			y: y0
-		};
-		const p1 = {
-			x: x0 + dx / 3,
-			y: y0 + slope0
-		};
-		const p2 = {
-			x: x3 - dx / 3,
-			y: y3 - slope1
-		};
-		const p3 = {
-			x: x3,
-			y: y3
-		};
-		segments.push({
-			p0,
-			p1,
-			p2,
-			p3
-		});
-	}
-	return segments;
-}
-/**
-* An SVG elliptical arc (endpoint form, SVG 1.1 F.6.5) as cubic Bezier
-* segments of at most 90° each.
-*/
-function svgArcToCubicBeziers(x1, y1, rxIn, ryIn, rotationDeg, largeArc, sweep, x2, y2) {
-	if (x1 === x2 && y1 === y2) return [];
-	let rx = Math.abs(rxIn);
-	let ry = Math.abs(ryIn);
-	if (rx === 0 || ry === 0) return [{
-		p0: {
-			x: x1,
-			y: y1
-		},
-		p1: {
-			x: x1 + (x2 - x1) / 3,
-			y: y1 + (y2 - y1) / 3
-		},
-		p2: {
-			x: x1 + 2 * (x2 - x1) / 3,
-			y: y1 + 2 * (y2 - y1) / 3
-		},
-		p3: {
-			x: x2,
-			y: y2
-		}
-	}];
-	const phi = rotationDeg * Math.PI / 180;
-	const cosPhi = Math.cos(phi);
-	const sinPhi = Math.sin(phi);
-	const dx = (x1 - x2) / 2;
-	const dy = (y1 - y2) / 2;
-	const x1p = cosPhi * dx + sinPhi * dy;
-	const y1p = -sinPhi * dx + cosPhi * dy;
-	const lambda = x1p * x1p / (rx * rx) + y1p * y1p / (ry * ry);
-	if (lambda > 1) {
-		rx *= Math.sqrt(lambda);
-		ry *= Math.sqrt(lambda);
-	}
-	const num = rx * rx * ry * ry - rx * rx * y1p * y1p - ry * ry * x1p * x1p;
-	const den = rx * rx * y1p * y1p + ry * ry * x1p * x1p;
-	const coef = (largeArc !== sweep ? 1 : -1) * Math.sqrt(Math.max(0, num / den));
-	const cxp = coef * rx * y1p / ry;
-	const cyp = -coef * ry * x1p / rx;
-	const cx = cosPhi * cxp - sinPhi * cyp + (x1 + x2) / 2;
-	const cy = sinPhi * cxp + cosPhi * cyp + (y1 + y2) / 2;
-	const angle = (ux, uy, vx, vy) => Math.atan2(ux * vy - uy * vx, ux * vx + uy * vy);
-	const theta1 = angle(1, 0, (x1p - cxp) / rx, (y1p - cyp) / ry);
-	let delta = angle((x1p - cxp) / rx, (y1p - cyp) / ry, (-x1p - cxp) / rx, (-y1p - cyp) / ry);
-	if (!sweep && delta > 0) delta -= 2 * Math.PI;
-	if (sweep && delta < 0) delta += 2 * Math.PI;
-	const n = Math.max(1, Math.ceil(Math.abs(delta) / (Math.PI / 2)));
-	const step = delta / n;
-	const k = 4 / 3 * Math.tan(step / 4);
-	const point = (a) => ({
-		x: cx + rx * Math.cos(a) * cosPhi - ry * Math.sin(a) * sinPhi,
-		y: cy + rx * Math.cos(a) * sinPhi + ry * Math.sin(a) * cosPhi
-	});
-	const tangent = (a) => ({
-		x: -rx * Math.sin(a) * cosPhi - ry * Math.cos(a) * sinPhi,
-		y: -rx * Math.sin(a) * sinPhi + ry * Math.cos(a) * cosPhi
-	});
-	const segments = [];
-	for (let s = 0; s < n; s++) {
-		const a0 = theta1 + s * step;
-		const a1 = a0 + step;
-		const p0 = point(a0);
-		const p3 = point(a1);
-		const t0 = tangent(a0);
-		const t1 = tangent(a1);
-		segments.push({
-			p0,
-			p1: {
-				x: p0.x + k * t0.x,
-				y: p0.y + k * t0.y
-			},
-			p2: {
-				x: p3.x - k * t1.x,
-				y: p3.y - k * t1.y
-			},
-			p3
-		});
-	}
-	segments[segments.length - 1].p3 = {
-		x: x2,
-		y: y2
-	};
-	return segments;
-}
-/**
-* Converts SVG path data string into a chain of Cubic Bezier segments.
-*/
-function parseSvgPathToCubicBeziers(d) {
-	const segments = [];
-	const tokens = d.match(/[a-df-z]|[-+]?(?:\d*\.\d+|\d+)(?:[eE][-+]?\d+)?/gi);
-	if (!tokens || tokens.length === 0) return segments;
-	let currentX = 0;
-	let currentY = 0;
-	let startX = 0;
-	let startY = 0;
-	let lastControlX = 0;
-	let lastControlY = 0;
-	let lastCommand = "";
-	let i = 0;
-	const nextNum = () => {
-		if (i >= tokens.length) return 0;
-		return Number.parseFloat(tokens[i++]);
-	};
-	while (i < tokens.length) {
-		const token = tokens[i++];
-		const isCommand = /^[a-df-z]$/i.test(token);
-		const cmd = isCommand ? token : lastCommand;
-		if (!isCommand) i--;
-		switch (cmd) {
-			case "M":
-				currentX = nextNum();
-				currentY = nextNum();
-				startX = currentX;
-				startY = currentY;
-				lastCommand = "L";
-				break;
-			case "m":
-				currentX += nextNum();
-				currentY += nextNum();
-				startX = currentX;
-				startY = currentY;
-				lastCommand = "l";
-				break;
-			case "L": {
-				const x = nextNum();
-				const y = nextNum();
-				segments.push({
-					p0: {
-						x: currentX,
-						y: currentY
-					},
-					p1: {
-						x: currentX + (x - currentX) / 3,
-						y: currentY + (y - currentY) / 3
-					},
-					p2: {
-						x: currentX + 2 * (x - currentX) / 3,
-						y: currentY + 2 * (y - currentY) / 3
-					},
-					p3: {
-						x,
-						y
-					}
-				});
-				currentX = x;
-				currentY = y;
-				lastCommand = "L";
-				break;
-			}
-			case "l": {
-				const dx = nextNum();
-				const dy = nextNum();
-				const x = currentX + dx;
-				const y = currentY + dy;
-				segments.push({
-					p0: {
-						x: currentX,
-						y: currentY
-					},
-					p1: {
-						x: currentX + dx / 3,
-						y: currentY + dy / 3
-					},
-					p2: {
-						x: currentX + 2 * dx / 3,
-						y: currentY + 2 * dy / 3
-					},
-					p3: {
-						x,
-						y
-					}
-				});
-				currentX = x;
-				currentY = y;
-				lastCommand = "l";
-				break;
-			}
-			case "H": {
-				const x = nextNum();
-				segments.push({
-					p0: {
-						x: currentX,
-						y: currentY
-					},
-					p1: {
-						x: currentX + (x - currentX) / 3,
-						y: currentY
-					},
-					p2: {
-						x: currentX + 2 * (x - currentX) / 3,
-						y: currentY
-					},
-					p3: {
-						x,
-						y: currentY
-					}
-				});
-				currentX = x;
-				lastCommand = "H";
-				break;
-			}
-			case "h": {
-				const dx = nextNum();
-				const x = currentX + dx;
-				segments.push({
-					p0: {
-						x: currentX,
-						y: currentY
-					},
-					p1: {
-						x: currentX + dx / 3,
-						y: currentY
-					},
-					p2: {
-						x: currentX + 2 * dx / 3,
-						y: currentY
-					},
-					p3: {
-						x,
-						y: currentY
-					}
-				});
-				currentX = x;
-				lastCommand = "h";
-				break;
-			}
-			case "V": {
-				const y = nextNum();
-				segments.push({
-					p0: {
-						x: currentX,
-						y: currentY
-					},
-					p1: {
-						x: currentX,
-						y: currentY + (y - currentY) / 3
-					},
-					p2: {
-						x: currentX,
-						y: currentY + 2 * (y - currentY) / 3
-					},
-					p3: {
-						x: currentX,
-						y
-					}
-				});
-				currentY = y;
-				lastCommand = "V";
-				break;
-			}
-			case "v": {
-				const dy = nextNum();
-				const y = currentY + dy;
-				segments.push({
-					p0: {
-						x: currentX,
-						y: currentY
-					},
-					p1: {
-						x: currentX,
-						y: currentY + dy / 3
-					},
-					p2: {
-						x: currentX,
-						y: currentY + 2 * dy / 3
-					},
-					p3: {
-						x: currentX,
-						y
-					}
-				});
-				currentY = y;
-				lastCommand = "v";
-				break;
-			}
-			case "C": {
-				const x1 = nextNum();
-				const y1 = nextNum();
-				const x2 = nextNum();
-				const y2 = nextNum();
-				const x = nextNum();
-				const y = nextNum();
-				segments.push({
-					p0: {
-						x: currentX,
-						y: currentY
-					},
-					p1: {
-						x: x1,
-						y: y1
-					},
-					p2: {
-						x: x2,
-						y: y2
-					},
-					p3: {
-						x,
-						y
-					}
-				});
-				lastControlX = x2;
-				lastControlY = y2;
-				currentX = x;
-				currentY = y;
-				lastCommand = "C";
-				break;
-			}
-			case "c": {
-				const dx1 = nextNum();
-				const dy1 = nextNum();
-				const dx2 = nextNum();
-				const dy2 = nextNum();
-				const dx = nextNum();
-				const dy = nextNum();
-				const x1 = currentX + dx1;
-				const y1 = currentY + dy1;
-				const x2 = currentX + dx2;
-				const y2 = currentY + dy2;
-				const x = currentX + dx;
-				const y = currentY + dy;
-				segments.push({
-					p0: {
-						x: currentX,
-						y: currentY
-					},
-					p1: {
-						x: x1,
-						y: y1
-					},
-					p2: {
-						x: x2,
-						y: y2
-					},
-					p3: {
-						x,
-						y
-					}
-				});
-				lastControlX = x2;
-				lastControlY = y2;
-				currentX = x;
-				currentY = y;
-				lastCommand = "c";
-				break;
-			}
-			case "S":
-			case "s": {
-				const isRel = cmd === "s";
-				const dx2 = nextNum();
-				const dy2 = nextNum();
-				const dx = nextNum();
-				const dy = nextNum();
-				const x2 = isRel ? currentX + dx2 : dx2;
-				const y2 = isRel ? currentY + dy2 : dy2;
-				const x = isRel ? currentX + dx : dx;
-				const y = isRel ? currentY + dy : dy;
-				let x1 = currentX;
-				let y1 = currentY;
-				if (/^[cs]$/i.test(lastCommand)) {
-					x1 = 2 * currentX - lastControlX;
-					y1 = 2 * currentY - lastControlY;
-				}
-				segments.push({
-					p0: {
-						x: currentX,
-						y: currentY
-					},
-					p1: {
-						x: x1,
-						y: y1
-					},
-					p2: {
-						x: x2,
-						y: y2
-					},
-					p3: {
-						x,
-						y
-					}
-				});
-				lastControlX = x2;
-				lastControlY = y2;
-				currentX = x;
-				currentY = y;
-				lastCommand = cmd;
-				break;
-			}
-			case "Q":
-			case "q": {
-				const isRel = cmd === "q";
-				const qx = nextNum();
-				const qy = nextNum();
-				const x = nextNum();
-				const y = nextNum();
-				const cx1 = isRel ? currentX + qx : qx;
-				const cy1 = isRel ? currentY + qy : qy;
-				const ex = isRel ? currentX + x : x;
-				const ey = isRel ? currentY + y : y;
-				const p1x = currentX + 2 / 3 * (cx1 - currentX);
-				const p1y = currentY + 2 / 3 * (cy1 - currentY);
-				const p2x = ex + 2 / 3 * (cx1 - ex);
-				const p2y = ey + 2 / 3 * (cy1 - ey);
-				segments.push({
-					p0: {
-						x: currentX,
-						y: currentY
-					},
-					p1: {
-						x: p1x,
-						y: p1y
-					},
-					p2: {
-						x: p2x,
-						y: p2y
-					},
-					p3: {
-						x: ex,
-						y: ey
-					}
-				});
-				lastControlX = cx1;
-				lastControlY = cy1;
-				currentX = ex;
-				currentY = ey;
-				lastCommand = cmd;
-				break;
-			}
-			case "A":
-			case "a": {
-				const rx = nextNum();
-				const ry = nextNum();
-				const rotation = nextNum();
-				const largeArc = nextNum() !== 0;
-				const sweep = nextNum() !== 0;
-				let x = nextNum();
-				let y = nextNum();
-				if (cmd === "a") {
-					x += currentX;
-					y += currentY;
-				}
-				segments.push(...svgArcToCubicBeziers(currentX, currentY, rx, ry, rotation, largeArc, sweep, x, y));
-				currentX = x;
-				currentY = y;
-				lastControlX = x;
-				lastControlY = y;
-				lastCommand = cmd;
-				break;
-			}
-			case "Z":
-			case "z":
-				if (currentX !== startX || currentY !== startY) {
-					segments.push({
-						p0: {
-							x: currentX,
-							y: currentY
-						},
-						p1: {
-							x: currentX + (startX - currentX) / 3,
-							y: currentY + (startY - currentY) / 3
-						},
-						p2: {
-							x: currentX + 2 * (startX - currentX) / 3,
-							y: currentY + 2 * (startY - currentY) / 3
-						},
-						p3: {
-							x: startX,
-							y: startY
-						}
-					});
-					currentX = startX;
-					currentY = startY;
-				}
-				lastCommand = cmd;
-				break;
-			default: break;
-		}
-	}
-	return segments;
+	node.startFrame = (typeof owner.startFrame === "number" ? owner.startFrame : 0) + (typeof src.startFrame === "number" ? src.startFrame : 0);
+	if (src.durationFrames === void 0 && owner.durationFrames !== void 0) node.durationFrames = owner.durationFrames;
+	if (Array.isArray(node.children)) node.children = hoistMattes(node.children);
+	self.matteId = id;
+	return [self, node];
 }
-/**
-* Universal path source converter to Cubic Bezier segments.
-*/
-function generatePathSegments(source) {
-	switch (source.type) {
-		case "bezier": return source.segments;
-		case "svg": return parseSvgPathToCubicBeziers(source.d);
-		case "ellipse": return ellipseToCubicBeziers(source.cx, source.cy, source.rx, source.ry, source.startAngleDeg ?? 0, source.endAngleDeg ?? 360);
-		case "wave": return waveToCubicBeziers(source.startX, source.startY, source.length, source.amplitude, source.frequency, source.phaseDeg ?? 0);
-	}
-}
-/**
-* Computes After Effects Range Selector weight for a single glyph index.
-*
-* @param index Normalized position of the glyph in the string (0.0 to 1.0)
-* @param start Start boundary (0.0 to 1.0)
-* @param end End boundary (0.0 to 1.0)
-* @param offset Window shift (-1.0 to 1.0)
-* @param shape Falloff curve
-* @param easeHigh Non-linear easing for high values
-* @param easeLow Non-linear easing for low values
-* @returns Weight in [0.0, 1.0]
-*/
-function computeRangeSelectorWeight(index, start, end, offset, shape, easeHigh = 0, easeLow = 0) {
-	const effStart = start + offset;
-	const effEnd = end + offset;
-	if (effEnd <= effStart) return 0;
-	const relativePos = (index - effStart) / (effEnd - effStart);
-	let baseWeight = 0;
-	switch (shape) {
-		case "square":
-			baseWeight = relativePos >= 0 && relativePos <= 1 ? 1 : 0;
-			break;
-		case "ramp_up":
-			baseWeight = Math.max(0, Math.min(1, relativePos));
-			break;
-		case "ramp_down":
-			baseWeight = 1 - Math.max(0, Math.min(1, relativePos));
-			break;
-		case "triangle":
-			if (relativePos < 0 || relativePos > 1) baseWeight = 0;
-			else if (relativePos < .5) baseWeight = relativePos * 2;
-			else baseWeight = (1 - relativePos) * 2;
-			break;
-		case "round":
-			if (relativePos < 0 || relativePos > 1) baseWeight = 0;
-			else baseWeight = .5 - .5 * Math.cos(relativePos * 2 * Math.PI);
-			break;
-		case "smooth":
-			if (relativePos <= 0) baseWeight = 0;
-			else if (relativePos >= 1) baseWeight = 1;
-			else baseWeight = relativePos * relativePos * (3 - 2 * relativePos);
-			break;
-	}
-	if (baseWeight > 0 && baseWeight < 1) {
-		if (easeHigh !== 0 && baseWeight > .5) baseWeight = .5 + .5 * ((baseWeight - .5) * 2) ** (easeHigh > 0 ? 1 + easeHigh * 3 : 1 / (1 - easeHigh * 3));
-		if (easeLow !== 0 && baseWeight <= .5) baseWeight = .5 * (baseWeight * 2) ** (easeLow > 0 ? 1 + easeLow * 3 : 1 / (1 - easeLow * 3));
-	}
-	return Math.max(0, Math.min(1, baseWeight));
-}
-/**
-* 1D Gradient deterministic hash noise for Wiggly Selectors.
-*/
-function deterministicWigglyNoise(seed, glyphIndex, phase, correlation) {
-	const coord = (glyphIndex * (1 - correlation) + correlation) * 12.9898 + phase + seed * 78.233;
-	const raw = Math.sin(coord) * 43758.5453;
-	return (raw - Math.floor(raw)) * 2 - 1;
-}
-/**
-* Deterministic pseudo-random number generator for seeded order shuffling.
-*/
-function getShuffledOrder(count, seed) {
-	let s = seed;
-	const nextRand = () => {
-		s = (s * 9301 + 49297) % 233280;
-		return s / 233280;
-	};
-	const arr = Array.from({ length: count }, (_, i) => i);
-	for (let i = arr.length - 1; i > 0; i--) {
-		const j = Math.floor(nextRand() * (i + 1));
-		const temp = arr[i];
-		arr[i] = arr[j];
-		arr[j] = temp;
-	}
-	return arr;
-}
-/**
-* Combines consecutive selector weights using After Effects Selector Mode logic.
-*/
-function evaluateSelectorCombination(prevWeight, currWeight, mode) {
-	switch (mode) {
-		case "add": return Math.max(0, Math.min(1, prevWeight + currWeight));
-		case "subtract": return Math.max(0, Math.min(1, prevWeight - currWeight));
-		case "intersect": return prevWeight * currWeight;
-		case "min": return Math.min(prevWeight, currWeight);
-		case "max": return Math.max(prevWeight, currWeight);
-		case "difference": return Math.abs(prevWeight - currWeight);
-	}
-}
-const SCRAMBLE_POOLS = {
-	ascii: "!@#$%^&*()_+{}[]:;<>,.?",
-	alphanumeric: "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789",
-	matrix: "010101<>[]{}+=*~#%&!?/\\:;|X0123456789",
-	binary: "01",
-	hex: "0123456789ABCDEF"
-};
-function getScramblePool(charset, customCharset) {
-	if (charset === "custom" && customCharset && customCharset.length > 0) return customCharset;
-	return SCRAMBLE_POOLS[charset] ?? SCRAMBLE_POOLS.alphanumeric;
-}
-/**
-* Evaluates typewriter visible character count and scramble state for frame `currentFrame`.
-*/
-function evaluateTypewriterState(fullText, currentFrame, startFrame, durationFrames, cadence = {
-	mode: "human",
-	jitter: .35,
-	commaPauseMultiplier: 3,
-	sentencePauseMultiplier: 5.5,
-	paragraphPauseMultiplier: 7
-}, scramble = {
-	enabled: false,
-	charset: "alphanumeric",
-	scrambleFramesPerChar: 8,
-	highlightProbability: .25
-}, blinkFrequency = 2, granularity = "character", progressOverride) {
-	if (progressOverride === void 0 && currentFrame < startFrame) return {
-		visibleChars: 0,
-		currentDisplayString: "",
-		isCursorVisible: false
-	};
-	const progress = progressOverride !== void 0 ? Math.max(0, Math.min(1, progressOverride)) : Math.min(1, (currentFrame - startFrame) / Math.max(1, durationFrames));
-	const elapsed = progressOverride !== void 0 ? progress * durationFrames : currentFrame - startFrame;
-	const totalChars = fullText.length;
-	let visibleCount = Math.floor(progress * totalChars);
-	if (granularity === "word") {
-		const tokens = fullText.split(/(\s+)/);
-		const wordIndices = [];
-		tokens.forEach((t, i) => {
-			if (t.trim().length > 0) wordIndices.push(i);
-		});
-		const visibleWords = Math.min(wordIndices.length, Math.floor(progress * (wordIndices.length + 1)));
-		if (visibleWords <= 0) visibleCount = 0;
-		else {
-			const lastIdx = wordIndices[Math.min(wordIndices.length - 1, visibleWords - 1)];
-			visibleCount = tokens.slice(0, lastIdx + 1).join("").length;
-		}
-	} else if (granularity === "line") {
-		const lines = fullText.split("\n");
-		const visibleLines = Math.min(lines.length, Math.floor(progress * (lines.length + 1)));
-		visibleCount = lines.slice(0, visibleLines).join("\n").length;
-	} else if (cadence.mode === "human" && progress < 1) {
-		let simulatedCharIndex = 0;
-		let simulatedElapsed = 0;
-		const baseFramesPerChar = durationFrames / Math.max(1, totalChars);
-		for (let i = 0; i < totalChars; i++) {
-			const char = fullText[i];
-			let multiplier = 1;
-			const commaMult = cadence.commaPauseMultiplier ?? 3;
-			const sentenceMult = cadence.sentencePauseMultiplier ?? 5.5;
-			const paraMult = cadence.paragraphPauseMultiplier ?? 7;
-			const jitter = cadence.jitter ?? .35;
-			if (char === "," || char === ";") multiplier = commaMult;
-			else if (char === "." || char === "!" || char === "?") multiplier = sentenceMult;
-			else if (char === "\n") multiplier = paraMult;
-			const jitterVal = 1 + Math.sin(i * 17.3 + 42) * .5 * jitter;
-			const charDuration = baseFramesPerChar * multiplier * jitterVal;
-			simulatedElapsed += charDuration;
-			if (simulatedElapsed <= elapsed) simulatedCharIndex = i + 1;
-			else break;
-		}
-		visibleCount = Math.min(totalChars, simulatedCharIndex);
-	}
-	let displayStr = fullText.slice(0, visibleCount);
-	if (scramble.enabled && visibleCount < totalChars && visibleCount > 0) {
-		const pool = getScramblePool(scramble.charset, scramble.customCharset);
-		const trailCount = Math.min(visibleCount, Math.max(1, scramble.scrambleFramesPerChar > 4 ? 3 : 2));
-		let scrambledTail = "";
-		for (let t = 0; t < trailCount; t++) {
-			const idx = Math.floor(Math.abs(Math.sin(currentFrame * 7 + t * 13)) * pool.length) % pool.length;
-			scrambledTail += pool[idx];
-		}
-		displayStr = displayStr.slice(0, displayStr.length - trailCount) + scrambledTail;
-	}
-	let isCursorVisible = true;
-	if (blinkFrequency > 0) {
-		const halfPeriodFrames = Math.max(1, Math.round(30 / (2 * blinkFrequency)));
-		isCursorVisible = Math.floor(elapsed / halfPeriodFrames) % 2 === 0;
-	}
-	return {
-		visibleChars: visibleCount,
-		currentDisplayString: displayStr,
-		isCursorVisible
-	};
+/** Returns the tree with every `matte` turned into a sibling matte layer. */
+function hoistMattes(nodes) {
+	return nodes.flatMap((n) => hoistOne(n));
 }
 /** number px | "auto" (intrinsic) | "fit" (shrink-wrap) | "fill" (parent extent). */
 const SizeSpecSchema = z.union([
@@ -3984,7 +1922,16 @@ const AnimatablePropSchema = z.enum([
 	"animationSpeed",
 	"wireframe",
 	"scaleX",
-	"scaleY"
+	"scaleY",
+	"emissive",
+	"emissiveIntensity",
+	"exposure"
+]);
+const MatteModeSchema = z.enum([
+	"alpha",
+	"alpha-inverted",
+	"luma",
+	"luma-inverted"
 ]);
 const MaterialTypeSchema = z.enum([
 	"lit",
@@ -4283,6 +2230,16 @@ const BaseNodeFields = {
 	dispersion: z.number().min(0).max(1).optional(),
 	fresnelPower: z.number().min(1).max(10).optional(),
 	envIntensity: z.number().min(0).max(10).optional(),
+	emissive: ColorSchema.optional(),
+	emissiveIntensity: z.number().min(0).optional(),
+	castShadow: z.boolean().optional(),
+	matte: z.object({
+		node: z.custom((v) => typeof v === "object" && v !== null),
+		mode: MatteModeSchema.optional()
+	}).optional(),
+	matteId: z.string().optional(),
+	matteOf: z.string().optional(),
+	matteMode: MatteModeSchema.optional(),
 	animation: LayerAnimationSchema.default({ tracks: [] }),
 	vision: z.unknown().optional(),
 	relighting: z.unknown().optional()
@@ -4445,8 +2402,34 @@ const LightTypeSchema = z.enum([
 	"ambient",
 	"directional",
 	"point",
-	"spot"
+	"spot",
+	"environment"
 ]);
+const EnvironmentPresetSchema = z.enum([
+	"studio",
+	"soft",
+	"sunset",
+	"night",
+	"neutral"
+]);
+const ToneMappingSchema = z.enum([
+	"neutral",
+	"agx",
+	"aces",
+	"none"
+]);
+const EnvironmentFogSchema = z.object({
+	color: ColorSchema,
+	start: z.number().min(0),
+	end: z.number().min(0),
+	opacity: z.number().min(0).max(1).optional()
+}).strict();
+const BloomConfigSchema = z.object({
+	intensity: z.number().min(0).max(10).optional(),
+	threshold: z.number().min(0).max(16).optional(),
+	knee: z.number().min(0).max(1).optional(),
+	radius: z.number().min(1).max(8).optional()
+}).strict();
 const LightNodeSchema = z.object({
 	id: z.string().min(1),
 	kind: z.literal("light"),
@@ -4468,6 +2451,20 @@ const LightNodeSchema = z.object({
 	decay: z.number().min(0).default(2),
 	angle: z.number().min(0).max(180).default(45),
 	penumbra: z.number().min(0).max(1).default(.2),
+	castShadow: z.boolean().optional(),
+	shadowSoftness: z.number().min(0).max(64).optional(),
+	shadowDarkness: z.number().min(0).max(1).optional(),
+	shadowMapSize: z.number().int().min(256).max(8192).optional(),
+	preset: EnvironmentPresetSchema.optional(),
+	top: ColorSchema.optional(),
+	horizon: ColorSchema.optional(),
+	bottom: ColorSchema.optional(),
+	softboxes: z.number().min(0).optional(),
+	rotation: z.number().optional(),
+	exposure: z.number().min(-16).max(16).optional(),
+	toneMapping: ToneMappingSchema.optional(),
+	fog: EnvironmentFogSchema.optional(),
+	bloom: z.union([z.boolean(), BloomConfigSchema]).optional(),
 	startFrame: z.number().int().min(0).default(0),
 	durationFrames: z.number().int().min(1).optional(),
 	animation: LayerAnimationSchema.default({ tracks: [] })
@@ -4596,6 +2593,11 @@ const TextFields = {
 		"center",
 		"end"
 	]).optional(),
+	direction: z.enum([
+		"ltr",
+		"rtl",
+		"auto"
+	]).optional(),
 	verticalAlign: z.enum([
 		"top",
 		"middle",
@@ -4640,6 +2642,7 @@ const MediaNodeSchema = z.object({
 		"fill",
 		"none"
 	]).default("contain"),
+	dpr: z.number().min(1).max(4).optional(),
 	borderRadius: z.number().min(0).optional(),
 	borderColor: ColorSchema.optional(),
 	borderWidth: z.number().min(0).optional(),
@@ -4662,6 +2665,11 @@ const MediaNodeSchema = z.object({
 		"center",
 		"end"
 	]).optional(),
+	direction: z.enum([
+		"ltr",
+		"rtl",
+		"auto"
+	]).optional(),
 	verticalAlign: z.enum([
 		"top",
 		"middle",
@@ -4761,7 +2769,10 @@ const Model3DNodeSchema = z.object({
 	scaleX: z.number().default(1),
 	scaleY: z.number().default(1),
 	audioDeform: z.record(z.string(), z.unknown()).optional(),
-	text3dOptions: z.unknown().optional()
+	color: ColorSchema.optional(),
+	colorTint: ColorSchema.optional(),
+	text3dOptions: z.unknown().optional(),
+	primitive3d: z.unknown().optional()
 }).strict();
 const LayoutNodeSchema = z.lazy(() => z.union([
 	FlexNodeSchema,
@@ -4798,6 +2809,10 @@ const CompositorProgramSchema = z.object({
 */
 /**
 * Camera Transition Type across scene boundaries.
+*
+* @deprecated Recorded on scenes but not rendered. Use framefields'
+* `Layer.sequence([...])` with `Transition.push` / `wipe` / `iris` /
+* `crossfade` / `zoom` / `whip`, which render as keyframes and mattes.
 */
 const SceneTransitionTypeSchema = z.enum([
 	"cut",
@@ -5014,11 +3029,12 @@ function applyStaggerToChildren(children, staggerFrames, direction = "forward",
 function nodeToVirtualMedia(node, resolveMedia, fps, inheritedOffset = 0, compDurationMs, inheritedDurationFrames) {
 	let children = [];
 	const sourceRef = node.src ?? node.inputHandleId;
-	const isDirectMediaSource = (s) => typeof s === "string" && (s.startsWith("http://") || s.startsWith("https://") || s.startsWith("file://") || s.startsWith("/") || s.startsWith("./") || s.startsWith("blob:") || s.startsWith("data:") || /\.(png|jpe?g|webp|gif|svg|mp4|webm|mov|mkv|mp3|wav|ogg|m4a|srt|vtt)$/i.test(s));
+	const isDirectMediaSource = (s) => typeof s === "string" && (s.startsWith("http://") || s.startsWith("https://") || s.startsWith("file://") || s.startsWith("/") || s.startsWith("./") || s.startsWith("blob:") || s.startsWith("data:") || /\.(png|jpe?g|webp|gif|svg|mp4|webm|mov|mkv|mp3|wav|ogg|m4a|srt|vtt|json|lottie)$/i.test(s));
 	let media;
 	if (node.kind === "media") {
 		if (resolveMedia) media = resolveMedia(node.inputHandleId);
 		if (!media && sourceRef && (isDirectMediaSource(sourceRef) || node.src)) media = createVirtualMedia(sourceRef, node.dataType ?? "Video");
+		if (!media && !resolveMedia && sourceRef && (sourceRef.includes(".") || sourceRef.includes("/"))) console.warn(`[Compositor] Media layer '${node.id ?? "?"}' source '${sourceRef}' could not be resolved.`);
 		if (media && node.crop) {
 			const cropRaw = node.crop;
 			const cropOp = typeof cropRaw.toOperation === "function" ? cropRaw.toOperation() : cropRaw;
@@ -5143,7 +3159,7 @@ function compositorToProgram(config, options) {
 			},
 			...(config.onRequestFrame || options.onRequestFrame) && { onRequestFrame: config.onRequestFrame ?? options.onRequestFrame }
 		},
-		children: config.layout.map((n) => nodeToVirtualMedia(n, resolveMedia, fps, 0, durationMs))
+		children: hoistMattes(config.layout).map((n) => nodeToVirtualMedia(n, resolveMedia, fps, 0, durationMs))
 	};
 	const effectsList = Array.isArray(options.effects) ? options.effects : Array.isArray(config.effects) ? config.effects : [];
 	for (const eff of effectsList) {
@@ -5184,5 +3200,5 @@ function collectNodeOps(nodes) {
 }
 
 //#endregion
-export { TextPathBuilder as $, MaterialTypeSchema as A, evaluateAnimationAtFrame as At, SelectorUnitsSchema as B, evaluateVolumetricFormation as Bt, KineticMarqueeConfigSchema as C, computeLayoutSync as Ct, LightTypeSchema as D, deterministicWigglyNoise as Dt, LightNodeSchema as E, computeStaggerDelay as Et, SceneDefinitionSchema as F, evaluateSelectorCombination as Ft, SpringPhysicsSchema as G, initLayout as Gt, ShapeNodeSchema as H, generatePathSegments as Ht, SceneTransitionTypeSchema as I, evaluateSkewMatrix as It, TextAnimatorBuilder as J, sampleCurveGeometry as Jt, TextAnchorConfigSchema as K, parseSvgPathToCubicBeziers as Kt, SelectorBasedOnSchema as L, evaluateSpringProgress as Lt, Model3DNodeSchema as M, evaluateCubicBezierDerivative as Mt, ParticleDissolveConfigSchema as N, evaluateExpressionSelector as Nt, LineSpacingDynamicsSchema as O, distanceToCurveParameter as Ot, Scene as P, evaluateMarqueeOffset as Pt, TextNodeSchema as Q, SelectorModeSchema as R, evaluateTrackAtFrame as Rt, GlyphAnchorPointSchema as S, computeLayout as St, LayoutNodeSchema as T, computeRangeSelectorWeight as Tt, SkewPropertiesSchema as U, getScramblePool as Ut, Sequence as V, generateArcLengthLUT as Vt, Spatial3DPropertiesSchema as W, getShuffledOrder as Wt, TextCursorConfigSchema as X, waveToCubicBeziers as Xt, TextAnimatorSchema as Y, samplePathChainGeometry as Yt, TextCursorStyleSchema as Z, EnhancedTextNodeSchema as _, calculateSequenceTimeline as _t, AnchorPresetSchema as a, TextSignalSelectorSchema as at, FlexNodeSchema as b, computeAnchorPivotOffset as bt, BoxNodeSchema as c, TextWigglySelectorSchema as ct, CarrierHandoffConfigSchema as d, VariableFontAxesSchema as dt, TextPathOptionsSchema as et, ChromaticGlitchConfigSchema as f, Vec2Schema as ft, DynamicStrokePropertiesSchema as g, buildPathLUT as gt, CubicBezierSegmentSchema as h, applyStaggerToChildren as ht, AnchorGroupingSchema as i, TextSelectorSchema as it, MediaNodeSchema as j, evaluateCubicBezier as jt, LongShadowConfigSchema as k, ellipseToCubicBeziers as kt, CameraAnimation as l, TypewriterAnimatorSchema as lt, CompositorProgramSchema as m, VolumetricFormationModeSchema as mt, AdvancedTextAnimatorBuilder as n, TextRangeSelectorSchema as nt, AnimatableGlyphPropsSchema as o, TextSpanMarkSchema as ot, ColorStopSchema as p, VolumetricFormationConfigSchema as pt, TextAnimator as q, sampleAudioSpectrumScale as qt, AdvancedTextAnimatorSchema as r, TextScrambleConfigSchema as rt, AudioSpectrumTypographySchema as s, TextSpanSchema as st, AETextAnimatorSchema as t, TextPathSourceSchema as tt, CameraNodeSchema as u, TypingCadenceSchema as ut, ExpressionSelectorSchema as v, collectNodeOps as vt, LayerAnimation as w, computeLineLeadingDisplacement as wt, GlyphAnchorGroupingSchema as x, computeCarrierContinuity as xt, ExtendedGlyphPropertiesSchema as y, compositorToProgram as yt, SelectorShapeSchema as z, evaluateTypewriterState as zt };
-//# sourceMappingURL=program-xRfFoPxe.mjs.map
+export { applyStaggerToChildren as A, hoistMattes as B, ShapeNodeSchema as C, TextSpanMarkSchema as D, TextNodeSchema as E, computeLayout as F, lintComposition as H, computeLayoutSync as I, computeStaggerDelay as L, collectNodeOps as M, compositorToProgram as N, TextSpanSchema as O, computeCarrierContinuity as P, evaluateAnimationAtFrame as R, Sequence as S, TextAnimatorSchema as T, mergeAnimationTracks as U, initLayout as V, MediaNodeSchema as _, CarrierHandoffConfigSchema as a, SceneDefinitionSchema as b, EnvironmentFogSchema as c, LayerAnimation as d, LayoutNodeSchema as f, MatteModeSchema as g, MaterialTypeSchema as h, CameraNodeSchema as i, calculateSequenceTimeline as j, ToneMappingSchema as k, EnvironmentPresetSchema as l, LightTypeSchema as m, BoxNodeSchema as n, ColorStopSchema as o, LightNodeSchema as p, CameraAnimation as r, CompositorProgramSchema as s, BloomConfigSchema as t, FlexNodeSchema as u, Model3DNodeSchema as v, TextAnimator as w, SceneTransitionTypeSchema as x, Scene as y, evaluateTrackAtFrame as z };
+//# sourceMappingURL=program-BqFVw5Mu.mjs.map