framefields 2.0.11 → 2.1.0

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

@@ -1,6 +1,6 @@
-import { Bt as parseCssColor, Lt as mixColors, Vt as parseCssGradient, ht as createVirtualMedia, l as Color, wt as getActiveMediaMetadata } from "./dist-CbG3QxDw.mjs";
-import { t as ColorSchema } from "./dist-BYqNNwsl.mjs";
-import { rt as signalRegistry } from "./dist-Cxi68OuY.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";
 
@@ -1725,2348 +1725,94 @@ function lintComposition(config) {
 			return;
 		}
 		if (node.kind === "camera") return;
-		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);
-	};
-	const visitLevel = (nodes, backdrop, atRoot) => {
-		let known = backdrop;
-		for (const n of byZ(nodes)) {
-			visit(n, known, atRoot);
-			if (paints(n)) known = null;
-		}
-	};
-	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];
-	}
-	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];
-}
-/** Returns the tree with every `matte` turned into a sibling matte layer. */
-function hoistMattes(nodes) {
-	return nodes.flatMap((n) => hoistOne(n));
-}
-/**
-* 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.
-*/
-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",
-	"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"
-]);
-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
-	};
-	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
-	};
-	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;
-	}
-	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;
+		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 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 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);
 			}
 		}
-		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;
+		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);
 		}
-		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
+		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);
 	};
-}
-/**
-* 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 visitLevel = (nodes, backdrop, atRoot) => {
+		let known = backdrop;
+		for (const n of byZ(nodes)) {
+			visit(n, known, atRoot);
+			if (paints(n)) known = null;
 		}
-	}];
-	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;
-}
-/**
-* 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;
+	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;
 }
-/**
-* 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 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"
 	};
-	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);
+	if (GEOMETRY.every((k) => src[k] === void 0)) {
+		for (const k of GEOMETRY) if (typeof owner[k] === "number") node[k] = owner[k];
 	}
+	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];
 }
-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([
@@ -4847,6 +2593,11 @@ const TextFields = {
 		"center",
 		"end"
 	]).optional(),
+	direction: z.enum([
+		"ltr",
+		"rtl",
+		"auto"
+	]).optional(),
 	verticalAlign: z.enum([
 		"top",
 		"middle",
@@ -4891,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(),
@@ -4913,6 +2665,11 @@ const MediaNodeSchema = z.object({
 		"center",
 		"end"
 	]).optional(),
+	direction: z.enum([
+		"ltr",
+		"rtl",
+		"auto"
+	]).optional(),
 	verticalAlign: z.enum([
 		"top",
 		"middle",
@@ -5272,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;
@@ -5442,5 +3200,5 @@ function collectNodeOps(nodes) {
 }
 
 //#endregion
-export { TextAnimatorSchema as $, mergeAnimationTracks as $t, LightTypeSchema as A, computeRangeSelectorWeight as At, SceneTransitionTypeSchema as B, evaluateSelectorCombination as Bt, FlexNodeSchema as C, collectNodeOps as Ct, LayerAnimation as D, computeLayout as Dt, KineticMarqueeConfigSchema as E, computeCarrierContinuity as Et, MediaNodeSchema as F, evaluateAnimationAtFrame as Ft, Sequence as G, evaluateVolumetricFormation as Gt, SelectorModeSchema as H, evaluateSpringProgress as Ht, Model3DNodeSchema as I, evaluateCubicBezier as It, Spatial3DPropertiesSchema as J, getScramblePool as Jt, ShapeNodeSchema as K, generateArcLengthLUT as Kt, ParticleDissolveConfigSchema as L, evaluateCubicBezierDerivative as Lt, LongShadowConfigSchema as M, deterministicWigglyNoise as Mt, MaterialTypeSchema as N, distanceToCurveParameter as Nt, LayoutNodeSchema as O, computeLayoutSync as Ot, MatteModeSchema as P, ellipseToCubicBeziers as Pt, TextAnimatorBuilder as Q, lintComposition as Qt, Scene as R, evaluateExpressionSelector as Rt, ExtendedGlyphPropertiesSchema as S, calculateSequenceTimeline as St, GlyphAnchorPointSchema as T, computeAnchorPivotOffset as Tt, SelectorShapeSchema as U, evaluateTrackAtFrame as Ut, SelectorBasedOnSchema as V, evaluateSkewMatrix as Vt, SelectorUnitsSchema as W, evaluateTypewriterState as Wt, TextAnchorConfigSchema as X, hoistMattes as Xt, SpringPhysicsSchema as Y, getShuffledOrder as Yt, TextAnimator as Z, initLayout as Zt, DynamicStrokePropertiesSchema as _, Vec2Schema as _t, AnchorPresetSchema as a, TextPathSourceSchema as at, EnvironmentPresetSchema as b, applyStaggerToChildren as bt, BloomConfigSchema as c, TextSelectorSchema as ct, CameraNodeSchema as d, TextSpanSchema as dt, parseSvgPathToCubicBeziers as en, TextCursorConfigSchema as et, CarrierHandoffConfigSchema as f, TextWigglySelectorSchema as ft, CubicBezierSegmentSchema as g, VariableFontAxesSchema as gt, CompositorProgramSchema as h, TypingCadenceSchema as ht, AnchorGroupingSchema as i, waveToCubicBeziers as in, TextPathOptionsSchema as it, LineSpacingDynamicsSchema as j, computeStaggerDelay as jt, LightNodeSchema as k, computeLineLeadingDisplacement as kt, BoxNodeSchema as l, TextSignalSelectorSchema as lt, ColorStopSchema as m, TypewriterAnimatorSchema as mt, AdvancedTextAnimatorBuilder as n, sampleCurveGeometry as nn, TextNodeSchema as nt, AnimatableGlyphPropsSchema as o, TextRangeSelectorSchema as ot, ChromaticGlitchConfigSchema as p, ToneMappingSchema as pt, SkewPropertiesSchema as q, generatePathSegments as qt, AdvancedTextAnimatorSchema as r, samplePathChainGeometry as rn, TextPathBuilder as rt, AudioSpectrumTypographySchema as s, TextScrambleConfigSchema as st, AETextAnimatorSchema as t, sampleAudioSpectrumScale as tn, TextCursorStyleSchema as tt, CameraAnimation as u, TextSpanMarkSchema as ut, EnhancedTextNodeSchema as v, VolumetricFormationConfigSchema as vt, GlyphAnchorGroupingSchema as w, compositorToProgram as wt, ExpressionSelectorSchema as x, buildPathLUT as xt, EnvironmentFogSchema as y, VolumetricFormationModeSchema as yt, SceneDefinitionSchema as z, evaluateMarqueeOffset as zt };
-//# sourceMappingURL=program-BmNKgzja.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