@glissade/core 0.39.0-pre.1 → 0.40.0-pre.0

package/dist/track.js

@@ -0,0 +1,1194 @@
+//#region src/easing.ts
+/**
+* Time-mirror of an ease, so a segment played BACKWARD eases identically to the
+* forward segment (used by `retime`'s reverse/pingpong). The built-in eases pair
+* exactly — `easeInX ↔ easeOutX`, and `easeInOutX`/`linear` self-mirror — and a
+* `cubicBezier` mirrors by point reflection (`[x1,y1,x2,y2] → [1−x2,1−y2,1−x1,1−y1]`,
+* the analytic reverse of a bézier ease). Springs are causal and a custom-named
+* ease has no known inverse, so both throw fail-loud rather than mis-animate.
+*/
+function mirrorEase(spec) {
+	if (spec === void 0) return void 0;
+	if (typeof spec === "string") {
+		if (spec === "linear") return "linear";
+		if (spec.startsWith("easeInOut")) return spec;
+		if (spec.startsWith("easeIn")) return `easeOut${spec.slice(6)}`;
+		if (spec.startsWith("easeOut")) return `easeIn${spec.slice(7)}`;
+		throw new Error(`retime: cannot time-mirror the custom ease '${spec}' for reverse/pingpong — reverse only the built-in eases or a cubicBezier, or retime with { speed } / { shift }`);
+	}
+	if (spec.kind === "cubicBezier") {
+		const [x1, y1, x2, y2] = spec.pts;
+		return {
+			kind: "cubicBezier",
+			pts: [
+				1 - x2,
+				1 - y2,
+				1 - x1,
+				1 - y1
+			]
+		};
+	}
+	throw new Error("retime: cannot reverse/pingpong a spring ease (springs are causal) — retime the spring segment with { speed } / { shift }, or author the reverse explicitly");
+}
+const c1 = 1.70158;
+const c2 = c1 * 1.525;
+const c3 = 2.70158;
+const c4 = 2 * Math.PI / 3;
+const c5 = 2 * Math.PI / 4.5;
+function bounceOut(t) {
+	const n1 = 7.5625;
+	const d1 = 2.75;
+	if (t < 1 / d1) return n1 * t * t;
+	if (t < 2 / d1) return n1 * (t -= 1.5 / d1) * t + .75;
+	if (t < 2.5 / d1) return n1 * (t -= 2.25 / d1) * t + .9375;
+	return n1 * (t -= 2.625 / d1) * t + .984375;
+}
+const easings = {
+	linear: (t) => t,
+	easeInQuad: (t) => t * t,
+	easeOutQuad: (t) => 1 - (1 - t) * (1 - t),
+	easeInOutQuad: (t) => t < .5 ? 2 * t * t : 1 - (-2 * t + 2) ** 2 / 2,
+	easeInCubic: (t) => t ** 3,
+	easeOutCubic: (t) => 1 - (1 - t) ** 3,
+	easeInOutCubic: (t) => t < .5 ? 4 * t ** 3 : 1 - (-2 * t + 2) ** 3 / 2,
+	easeInQuart: (t) => t ** 4,
+	easeOutQuart: (t) => 1 - (1 - t) ** 4,
+	easeInOutQuart: (t) => t < .5 ? 8 * t ** 4 : 1 - (-2 * t + 2) ** 4 / 2,
+	easeInQuint: (t) => t ** 5,
+	easeOutQuint: (t) => 1 - (1 - t) ** 5,
+	easeInOutQuint: (t) => t < .5 ? 16 * t ** 5 : 1 - (-2 * t + 2) ** 5 / 2,
+	easeInSine: (t) => 1 - Math.cos(t * Math.PI / 2),
+	easeOutSine: (t) => Math.sin(t * Math.PI / 2),
+	easeInOutSine: (t) => -(Math.cos(Math.PI * t) - 1) / 2,
+	easeInExpo: (t) => t === 0 ? 0 : 2 ** (10 * t - 10),
+	easeOutExpo: (t) => t === 1 ? 1 : 1 - 2 ** (-10 * t),
+	easeInOutExpo: (t) => t === 0 ? 0 : t === 1 ? 1 : t < .5 ? 2 ** (20 * t - 10) / 2 : (2 - 2 ** (-20 * t + 10)) / 2,
+	easeInCirc: (t) => 1 - Math.sqrt(1 - t * t),
+	easeOutCirc: (t) => Math.sqrt(1 - (t - 1) * (t - 1)),
+	easeInOutCirc: (t) => t < .5 ? (1 - Math.sqrt(1 - (2 * t) ** 2)) / 2 : (Math.sqrt(1 - (-2 * t + 2) ** 2) + 1) / 2,
+	easeInBack: (t) => c3 * t ** 3 - c1 * t * t,
+	easeOutBack: (t) => 1 + c3 * (t - 1) ** 3 + c1 * (t - 1) ** 2,
+	easeInOutBack: (t) => t < .5 ? (2 * t) ** 2 * (3.5949095 * 2 * t - c2) / 2 : ((2 * t - 2) ** 2 * (3.5949095 * (t * 2 - 2) + c2) + 2) / 2,
+	easeInElastic: (t) => t === 0 ? 0 : t === 1 ? 1 : -(2 ** (10 * t - 10)) * Math.sin((t * 10 - 10.75) * c4),
+	easeOutElastic: (t) => t === 0 ? 0 : t === 1 ? 1 : 2 ** (-10 * t) * Math.sin((t * 10 - .75) * c4) + 1,
+	easeInOutElastic: (t) => t === 0 ? 0 : t === 1 ? 1 : t < .5 ? -(2 ** (20 * t - 10) * Math.sin((20 * t - 11.125) * c5)) / 2 : 2 ** (-20 * t + 10) * Math.sin((20 * t - 11.125) * c5) / 2 + 1,
+	easeInBounce: (t) => 1 - bounceOut(1 - t),
+	easeOutBounce: bounceOut,
+	easeInOutBounce: (t) => t < .5 ? (1 - bounceOut(1 - 2 * t)) / 2 : (1 + bounceOut(2 * t - 1)) / 2
+};
+function bounceOutD(t) {
+	const n1 = 7.5625;
+	const d1 = 2.75;
+	if (t < 1 / d1) return 2 * n1 * t;
+	if (t < 2 / d1) return 2 * n1 * (t - 1.5 / d1);
+	if (t < 2.5 / d1) return 2 * n1 * (t - 2.25 / d1);
+	return 2 * n1 * (t - 2.625 / d1);
+}
+const LN2 = Math.LN2;
+/**
+* Analytic derivatives d(u) of every named ease (§B.6) — closed-form, used
+* for reading velocity off in-flight curves at interruption time. Property-
+* tested against central differences at interior points.
+*/
+const easingDerivatives = {
+	linear: () => 1,
+	easeInQuad: (t) => 2 * t,
+	easeOutQuad: (t) => 2 * (1 - t),
+	easeInOutQuad: (t) => t < .5 ? 4 * t : 4 * (1 - t),
+	easeInCubic: (t) => 3 * t ** 2,
+	easeOutCubic: (t) => 3 * (1 - t) ** 2,
+	easeInOutCubic: (t) => t < .5 ? 12 * t ** 2 : 12 * (1 - t) ** 2,
+	easeInQuart: (t) => 4 * t ** 3,
+	easeOutQuart: (t) => 4 * (1 - t) ** 3,
+	easeInOutQuart: (t) => t < .5 ? 32 * t ** 3 : 32 * (1 - t) ** 3,
+	easeInQuint: (t) => 5 * t ** 4,
+	easeOutQuint: (t) => 5 * (1 - t) ** 4,
+	easeInOutQuint: (t) => t < .5 ? 80 * t ** 4 : 80 * (1 - t) ** 4,
+	easeInSine: (t) => Math.PI / 2 * Math.sin(t * Math.PI / 2),
+	easeOutSine: (t) => Math.PI / 2 * Math.cos(t * Math.PI / 2),
+	easeInOutSine: (t) => Math.PI / 2 * Math.sin(Math.PI * t),
+	easeInExpo: (t) => t === 0 ? 0 : 10 * LN2 * 2 ** (10 * t - 10),
+	easeOutExpo: (t) => t === 1 ? 0 : 10 * LN2 * 2 ** (-10 * t),
+	easeInOutExpo: (t) => t === 0 || t === 1 ? 0 : t < .5 ? 10 * LN2 * 2 ** (20 * t - 10) : 10 * LN2 * 2 ** (-20 * t + 10),
+	easeInCirc: (t) => t / Math.sqrt(1 - t * t),
+	easeOutCirc: (t) => (1 - t) / Math.sqrt(1 - (t - 1) * (t - 1)),
+	easeInOutCirc: (t) => t < .5 ? 2 * t / Math.sqrt(1 - 4 * t * t) : (2 - 2 * t) / Math.sqrt(1 - (-2 * t + 2) ** 2),
+	easeInBack: (t) => 3 * c3 * t ** 2 - 2 * c1 * t,
+	easeOutBack: (t) => 3 * c3 * (t - 1) ** 2 + 2 * c1 * (t - 1),
+	easeInOutBack: (t) => t < .5 ? 12 * 3.5949095 * t ** 2 - 4 * c2 * t : 3 * 3.5949095 * (2 * t - 2) ** 2 + 2 * c2 * (2 * t - 2),
+	easeInElastic: (t) => {
+		if (t === 0 || t === 1) return 0;
+		const theta = (t * 10 - 10.75) * c4;
+		const amp = 2 ** (10 * t - 10);
+		return -(10 * LN2 * amp * Math.sin(theta) + amp * 10 * c4 * Math.cos(theta));
+	},
+	easeOutElastic: (t) => {
+		if (t === 0 || t === 1) return 0;
+		const phi = (t * 10 - .75) * c4;
+		const amp = 2 ** (-10 * t);
+		return -10 * LN2 * amp * Math.sin(phi) + amp * 10 * c4 * Math.cos(phi);
+	},
+	easeInOutElastic: (t) => {
+		if (t === 0 || t === 1) return 0;
+		const psi = (20 * t - 11.125) * c5;
+		if (t < .5) {
+			const amp = 2 ** (20 * t - 10);
+			return -(20 * LN2 * amp * Math.sin(psi) + amp * 20 * c5 * Math.cos(psi)) / 2;
+		}
+		const amp = 2 ** (-20 * t + 10);
+		return (-20 * LN2 * amp * Math.sin(psi) + amp * 20 * c5 * Math.cos(psi)) / 2;
+	},
+	easeInBounce: (t) => bounceOutD(1 - t),
+	easeOutBounce: bounceOutD,
+	easeInOutBounce: (t) => t < .5 ? bounceOutD(1 - 2 * t) : bounceOutD(2 * t - 1)
+};
+/** Default property-tween ease (Motion Canvas precedent). */
+const DEFAULT_EASE = "easeInOutCubic";
+function bezierKernel(p1x, p1y, p2x, p2y) {
+	const ax = 3 * p1x - 3 * p2x + 1;
+	const bx = 3 * p2x - 6 * p1x;
+	const cx = 3 * p1x;
+	const ay = 3 * p1y - 3 * p2y + 1;
+	const by = 3 * p2y - 6 * p1y;
+	const cy = 3 * p1y;
+	const sampleX = (u) => ((ax * u + bx) * u + cx) * u;
+	const sampleY = (u) => ((ay * u + by) * u + cy) * u;
+	const sampleDX = (u) => (3 * ax * u + 2 * bx) * u + cx;
+	const sampleDY = (u) => (3 * ay * u + 2 * by) * u + cy;
+	const solveU = (x) => {
+		let u = x;
+		for (let i = 0; i < 8; i++) {
+			const err = sampleX(u) - x;
+			if (Math.abs(err) < 1e-7) return u;
+			const d = sampleDX(u);
+			if (Math.abs(d) < 1e-6) break;
+			u -= err / d;
+		}
+		let lo = 0;
+		let hi = 1;
+		u = x;
+		while (hi - lo > 1e-7) {
+			if (sampleX(u) < x) lo = u;
+			else hi = u;
+			u = (lo + hi) / 2;
+		}
+		return u;
+	};
+	return {
+		sampleY,
+		sampleDX,
+		sampleDY,
+		solveU
+	};
+}
+/**
+* CSS-style cubic bézier where x is time and y is progress. Newton's method
+* with a bisection fallback for the flat-derivative regions.
+*/
+function cubicBezier(p1x, p1y, p2x, p2y) {
+	const k = bezierKernel(p1x, p1y, p2x, p2y);
+	return (t) => {
+		if (t <= 0) return 0;
+		if (t >= 1) return 1;
+		return k.sampleY(k.solveU(t));
+	};
+}
+/** Analytic dy/dx of a cubic bézier ease: y'(s)/x'(s) at the solved parameter (§B.6). */
+function cubicBezierDerivative(p1x, p1y, p2x, p2y) {
+	const k = bezierKernel(p1x, p1y, p2x, p2y);
+	return (t) => {
+		const u = k.solveU(Math.min(1, Math.max(0, t)));
+		const dx = k.sampleDX(u);
+		if (Math.abs(dx) < 1e-9) return 0;
+		return k.sampleDY(u) / dx;
+	};
+}
+var UnknownEasingError = class extends Error {
+	constructor(name) {
+		super(`unknown easing '${name}'; register it via easings or use cubicBezier/spring`);
+		this.name = "UnknownEasingError";
+	}
+};
+function namedEasing(name) {
+	const fn = easings[name];
+	if (!fn) throw new UnknownEasingError(name);
+	return fn;
+}
+//#endregion
+//#region src/spring.ts
+const DEFAULT_SETTLE_TOLERANCE = .005;
+function params(cfg) {
+	const mass = cfg.mass ?? 1;
+	if (!(cfg.stiffness > 0) || !(cfg.damping > 0) || !(mass > 0)) throw new RangeError("spring stiffness, damping, and mass must all be > 0");
+	return {
+		w0: Math.sqrt(cfg.stiffness / mass),
+		zeta: cfg.damping / (2 * Math.sqrt(cfg.stiffness * mass))
+	};
+}
+/** Raw closed-form spring velocity at time t — d/dt of rawValue's three branches. */
+function rawDerivative(cfg, t) {
+	if (t <= 0) return 0;
+	const { w0, zeta } = params(cfg);
+	if (Math.abs(zeta - 1) < 1e-9) return w0 * w0 * t * Math.exp(-w0 * t);
+	if (zeta < 1) {
+		const wd = w0 * Math.sqrt(1 - zeta * zeta);
+		return Math.exp(-zeta * w0 * t) * (w0 * w0 / wd) * Math.sin(wd * t);
+	}
+	const s = Math.sqrt(zeta * zeta - 1);
+	const r1 = -w0 * (zeta - s);
+	const r2 = -w0 * (zeta + s);
+	return r1 * r2 * (Math.exp(r1 * t) - Math.exp(r2 * t)) / (r1 - r2);
+}
+/** Raw closed-form spring position at time t (seconds). Approaches 1, may overshoot. */
+function rawValue(cfg, t) {
+	if (t <= 0) return 0;
+	const { w0, zeta } = params(cfg);
+	if (Math.abs(zeta - 1) < 1e-9) return 1 - Math.exp(-w0 * t) * (1 + w0 * t);
+	if (zeta < 1) {
+		const wd = w0 * Math.sqrt(1 - zeta * zeta);
+		return 1 - Math.exp(-zeta * w0 * t) * (Math.cos(wd * t) + zeta * w0 / wd * Math.sin(wd * t));
+	}
+	const s = Math.sqrt(zeta * zeta - 1);
+	const r1 = -w0 * (zeta - s);
+	const r2 = -w0 * (zeta + s);
+	return 1 + (r2 * Math.exp(r1 * t) - r1 * Math.exp(r2 * t)) / (r1 - r2);
+}
+/**
+* Settle duration: the earliest time after which |x - 1| stays within
+* settleTolerance. Closed-form via the decay envelope for the underdamped
+* case; bisection on the monotone tail otherwise. Deterministic.
+*/
+function duration(cfg, opts) {
+	const tol = opts?.settleTolerance ?? DEFAULT_SETTLE_TOLERANCE;
+	const { w0, zeta } = params(cfg);
+	if (zeta < 1) {
+		const wd = w0 * Math.sqrt(1 - zeta * zeta);
+		const amp = Math.sqrt(1 + (zeta * w0 / wd) ** 2);
+		return Math.log(amp / tol) / (zeta * w0);
+	}
+	let hi = 1 / w0;
+	while (1 - rawValue(cfg, hi) > tol) hi *= 2;
+	let lo = 0;
+	for (let i = 0; i < 64 && hi - lo > 1e-9; i++) {
+		const mid = (lo + hi) / 2;
+		if (1 - rawValue(cfg, mid) > tol) lo = mid;
+		else hi = mid;
+	}
+	return hi;
+}
+/**
+* Spring progress at local time t, affinely rescaled so value(duration) = 1
+* exactly — the raw form only approaches 1, and an unscaled curve would snap
+* at the key (§2.7 "endpoint continuity"). May exceed 1 (overshoot).
+*/
+function value(cfg, t, opts) {
+	const d = duration(cfg, opts);
+	return rawValue(cfg, Math.min(t, d)) / rawValue(cfg, d);
+}
+function retarget(cfg, x0, v0) {
+	const { w0, zeta } = params(cfg);
+	let value0;
+	let velocity0;
+	let envelope;
+	if (Math.abs(zeta - 1) < 1e-9) {
+		const b = v0 + w0 * x0;
+		value0 = (tau) => tau <= 0 ? x0 : Math.exp(-w0 * tau) * (x0 + b * tau);
+		velocity0 = (tau) => tau <= 0 ? v0 : Math.exp(-w0 * tau) * (v0 - w0 * b * tau);
+		envelope = (tau) => Math.exp(-w0 * tau) * (Math.abs(x0) + Math.abs(b) * tau);
+	} else if (zeta < 1) {
+		const wd = w0 * Math.sqrt(1 - zeta * zeta);
+		const c2v = (v0 + zeta * w0 * x0) / wd;
+		const amp = Math.hypot(x0, c2v);
+		value0 = (tau) => tau <= 0 ? x0 : Math.exp(-zeta * w0 * tau) * (x0 * Math.cos(wd * tau) + c2v * Math.sin(wd * tau));
+		velocity0 = (tau) => tau <= 0 ? v0 : Math.exp(-zeta * w0 * tau) * (v0 * Math.cos(wd * tau) - (w0 * w0 * x0 + zeta * w0 * v0) / wd * Math.sin(wd * tau));
+		envelope = (tau) => Math.exp(-zeta * w0 * tau) * amp;
+	} else {
+		const s = Math.sqrt(zeta * zeta - 1);
+		const rp = w0 * (-zeta + s);
+		const rm = w0 * (-zeta - s);
+		const cp = (v0 - rm * x0) / (rp - rm);
+		const cm = (rp * x0 - v0) / (rp - rm);
+		value0 = (tau) => tau <= 0 ? x0 : cp * Math.exp(rp * tau) + cm * Math.exp(rm * tau);
+		velocity0 = (tau) => tau <= 0 ? v0 : cp * rp * Math.exp(rp * tau) + cm * rm * Math.exp(rm * tau);
+		envelope = (tau) => Math.abs(cp) * Math.exp(rp * tau) + Math.abs(cm) * Math.exp(rm * tau);
+	}
+	const settleTime = (tol) => {
+		const eps = tol ?? Math.abs(x0) * .005 + 1e-6;
+		if (envelope(0) <= eps && Math.abs(v0) < 1e-12) return 0;
+		let hi = 1 / w0;
+		let guard = 0;
+		while (envelope(hi) > eps && guard++ < 64) hi *= 2;
+		let lo = 0;
+		for (let i = 0; i < 64 && hi - lo > 1e-9; i++) {
+			const mid = (lo + hi) / 2;
+			if (Math.max(envelope(mid), envelope(mid * 1.05 + 1e-6)) > eps) lo = mid;
+			else hi = mid;
+		}
+		return hi;
+	};
+	return {
+		value: value0,
+		velocity: velocity0,
+		settleTime
+	};
+}
+const spring = Object.assign((cfg) => {
+	params(cfg);
+	return {
+		kind: "spring",
+		stiffness: cfg.stiffness,
+		damping: cfg.damping,
+		mass: cfg.mass ?? 1
+	};
+}, {
+	duration,
+	value,
+	retarget
+});
+/**
+* Named spring feels (react-spring conventions, mass 1) — a vocabulary instead
+* of hand-tuned stiffness/damping. Use `spring(springPresets.wobbly)` or
+* `springTo(t, a, b, springPresets.gentle)`.
+*/
+const springPresets = {
+	default: {
+		stiffness: 170,
+		damping: 26
+	},
+	gentle: {
+		stiffness: 120,
+		damping: 14
+	},
+	wobbly: {
+		stiffness: 180,
+		damping: 12
+	},
+	stiff: {
+		stiffness: 210,
+		damping: 20
+	},
+	slow: {
+		stiffness: 280,
+		damping: 60
+	},
+	molasses: {
+		stiffness: 280,
+		damping: 120
+	}
+};
+/**
+* The spring as a normalized easing over a segment whose length must equal
+* spring.duration(cfg) (validated at the document layer, §2.7).
+*/
+function springEasing(cfg) {
+	const d = duration(cfg);
+	return (p) => value(cfg, p * d);
+}
+/**
+* Analytic d/dp of springEasing (§B.6): oscillator derivative × the affine
+* rescale factor × duration (chain rule p → t = p·D). Flat past p=1,
+* matching value()'s clamp (right-derivative convention).
+*/
+function springEasingDerivative(cfg) {
+	const d = duration(cfg);
+	const scale = d / rawValue(cfg, d);
+	return (p) => p >= 1 ? 0 : rawDerivative(cfg, p * d) * scale;
+}
+//#endregion
+//#region src/devWarning.ts
+let devWarn = (msg) => {
+	globalThis.console?.warn(`[glissade] ${msg}`);
+};
+function setDevWarning(fn) {
+	devWarn = fn;
+}
+/** Internal: emit through the configurable channel. */
+function emitDevWarning(message) {
+	devWarn(message);
+}
+//#endregion
+//#region src/color.ts
+const HEX_RE = /^#([0-9a-f]{3}|[0-9a-f]{4}|[0-9a-f]{6}|[0-9a-f]{8})$/i;
+const RGB_RE = /^rgba?\(\s*([\d.]+)\s*[, ]\s*([\d.]+)\s*[, ]\s*([\d.]+)\s*(?:[,/]\s*([\d.]+%?)\s*)?\)$/i;
+var ColorParseError = class extends Error {
+	constructor(input) {
+		super(`cannot parse color '${input}' (supported: #rgb[a], #rrggbb[aa], rgb()/rgba())`);
+		this.name = "ColorParseError";
+	}
+};
+function parseColor(input) {
+	const hex = HEX_RE.exec(input);
+	if (hex) {
+		let h = hex[1];
+		if (h.length <= 4) h = [...h].map((c) => c + c).join("");
+		const n = parseInt(h, 16);
+		if (h.length === 6) return {
+			r: n >> 16,
+			g: n >> 8 & 255,
+			b: n & 255,
+			a: 1
+		};
+		return {
+			r: n >>> 24 & 255,
+			g: n >>> 16 & 255,
+			b: n >>> 8 & 255,
+			a: (n & 255) / 255
+		};
+	}
+	const rgb = RGB_RE.exec(input);
+	if (rgb) {
+		const alphaRaw = rgb[4];
+		const a = alphaRaw === void 0 ? 1 : alphaRaw.endsWith("%") ? parseFloat(alphaRaw) / 100 : parseFloat(alphaRaw);
+		return {
+			r: parseFloat(rgb[1]),
+			g: parseFloat(rgb[2]),
+			b: parseFloat(rgb[3]),
+			a
+		};
+	}
+	throw new ColorParseError(input);
+}
+function formatColor(c) {
+	const clampByte = (v) => Math.min(255, Math.max(0, Math.round(v)));
+	const hex = (v) => clampByte(v).toString(16).padStart(2, "0");
+	const base = `#${hex(c.r)}${hex(c.g)}${hex(c.b)}`;
+	const a = Math.min(1, Math.max(0, c.a));
+	return a >= 1 ? base : `${base}${hex(a * 255)}`;
+}
+function srgbToLinear(c) {
+	const v = c / 255;
+	return v <= .04045 ? v / 12.92 : ((v + .055) / 1.055) ** 2.4;
+}
+function linearToSrgb(v) {
+	return (v <= .0031308 ? v * 12.92 : 1.055 * v ** (1 / 2.4) - .055) * 255;
+}
+function rgbaToOklab(c) {
+	const r = srgbToLinear(c.r);
+	const g = srgbToLinear(c.g);
+	const b = srgbToLinear(c.b);
+	const l = Math.cbrt(.4122214708 * r + .5363325363 * g + .0514459929 * b);
+	const m = Math.cbrt(.2119034982 * r + .6806995451 * g + .1073969566 * b);
+	const s = Math.cbrt(.0883024619 * r + .2817188376 * g + .6299787005 * b);
+	return {
+		L: .2104542553 * l + .793617785 * m - .0040720468 * s,
+		a: 1.9779984951 * l - 2.428592205 * m + .4505937099 * s,
+		b: .0259040371 * l + .7827717662 * m - .808675766 * s,
+		alpha: c.a
+	};
+}
+function oklabToRgba(c) {
+	const l = (c.L + .3963377774 * c.a + .2158037573 * c.b) ** 3;
+	const m = (c.L - .1055613458 * c.a - .0638541728 * c.b) ** 3;
+	const s = (c.L - .0894841775 * c.a - 1.291485548 * c.b) ** 3;
+	return {
+		r: linearToSrgb(4.0767416621 * l - 3.3077115913 * m + .2309699292 * s),
+		g: linearToSrgb(-1.2684380046 * l + 2.6097574011 * m - .3413193965 * s),
+		b: linearToSrgb(-.0041960863 * l - .7034186147 * m + 1.707614701 * s),
+		a: c.alpha
+	};
+}
+/** Interpolate two CSS color strings in OKLab; t may extrapolate. */
+function lerpColor(from, to, t) {
+	const a = rgbaToOklab(parseColor(from));
+	const b = rgbaToOklab(parseColor(to));
+	const mix = (x, y) => x + (y - x) * t;
+	return formatColor(oklabToRgba({
+		L: mix(a.L, b.L),
+		a: mix(a.a, b.a),
+		b: mix(a.b, b.b),
+		alpha: mix(a.alpha, b.alpha)
+	}));
+}
+//#endregion
+//#region src/valueTypes.ts
+/**
+* Value-type registry with pluggable per-type interpolation (DESIGN.md §2.2).
+* `extrapolates` declares whether a type's lerp accepts easedT outside [0,1]
+* (spring overshoot); non-extrapolating types clamp.
+*/
+const registry = /* @__PURE__ */ new Map();
+function registerValueType(vt) {
+	registry.set(vt.id, vt);
+}
+var UnknownValueTypeError = class extends Error {
+	constructor(id) {
+		super(`unknown value type '${id}'; register it via registerValueType()`);
+		this.name = "UnknownValueTypeError";
+	}
+};
+function getValueType(id) {
+	const vt = registry.get(id);
+	if (!vt) throw new UnknownValueTypeError(id);
+	return vt;
+}
+/**
+* The ids of every currently-registered value type, in registration order
+* (the built-ins first, then any custom `registerValueType` additions). The
+* introspection seam `describe()` reads to list `valueTypes` from the REAL
+* registry — so the manifest can't drift from what `evaluate()` can actually
+* interpolate. Pure read; never touched by evaluate().
+*/
+function listValueTypes() {
+	return [...registry.keys()];
+}
+/**
+* Resolve a value-type id to its REPRESENTATION (the bind guard's compatibility
+* key, §2.2): a type's `repr` (the built-in it's representationally compatible
+* with), else the id itself. SINGLE-HOP — `repr` is never chained, so a custom
+* type's repr must be a base type. An UNREGISTERED id resolves to itself (the
+* guard's job is repr-compat, not existence — `getValueType` enforces that).
+*/
+function reprOf(id) {
+	return registry.get(id)?.repr ?? id;
+}
+const numberType = {
+	id: "number",
+	lerp: (a, b, t) => a + (b - a) * t,
+	extrapolates: true,
+	equals: Object.is,
+	add: (a, b) => a + b,
+	sub: (a, b) => a - b,
+	scale: (a, k) => a * k,
+	defaultHandoff: "spring"
+};
+const vec2Equals = (a, b) => a[0] === b[0] && a[1] === b[1];
+const vec2Type = {
+	id: "vec2",
+	lerp: (a, b, t) => [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t],
+	extrapolates: true,
+	equals: vec2Equals,
+	add: (a, b) => [a[0] + b[0], a[1] + b[1]],
+	sub: (a, b) => [a[0] - b[0], a[1] - b[1]],
+	scale: (a, k) => [a[0] * k, a[1] * k],
+	defaultHandoff: "spring"
+};
+/** vec2 swept along a circular arc: polar lerp of radius + shortest-path angle (§2.2). */
+const vec2ArcType = {
+	id: "vec2-arc",
+	repr: "vec2",
+	lerp: (a, b, t) => {
+		const ra = Math.hypot(a[0], a[1]);
+		const rb = Math.hypot(b[0], b[1]);
+		const angA = Math.atan2(a[1], a[0]);
+		let dAng = Math.atan2(b[1], b[0]) - angA;
+		while (dAng > Math.PI) dAng -= 2 * Math.PI;
+		while (dAng < -Math.PI) dAng += 2 * Math.PI;
+		const r = ra + (rb - ra) * t;
+		const ang = angA + dAng * t;
+		return [r * Math.cos(ang), r * Math.sin(ang)];
+	},
+	extrapolates: true,
+	equals: vec2Equals,
+	defaultHandoff: "blend-from-frozen"
+};
+const colorType = {
+	id: "color",
+	lerp: lerpColor,
+	extrapolates: true,
+	equals: (a, b) => a === b,
+	defaultHandoff: "blend-from-frozen"
+};
+/** Discrete types: hold-only by construction (§2.2); lerp snaps at t=1. */
+function discrete(id) {
+	return {
+		id,
+		lerp: (a, b, t) => t >= 1 ? b : a,
+		extrapolates: false,
+		equals: (a, b) => Object.is(a, b),
+		defaultHandoff: "cut"
+	};
+}
+const stringType = discrete("string");
+const booleanType = discrete("boolean");
+const lerpV = (a, b, t) => [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t];
+/** Topology must match for a morph (contour count, closed flags, vertex counts). */
+function pathTopologyMatches(a, b) {
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) {
+		const ca = a[i];
+		const cb = b[i];
+		if (ca.closed !== cb.closed || ca.v.length !== cb.v.length) return false;
+	}
+	return true;
+}
+let warnedPathTopology = false;
+/**
+* Path morphing (§2.2): pairwise lerp of anchors and tangents — exactly how
+* lottie-web morphs, so imported animations are pixel-faithful. Mismatched
+* topology snaps (hold a, then b at t ≥ 1) with a one-time dev warning; the
+* de Casteljau normalization fallback for arbitrary native morphs is tracked
+* future work. Lerp-only: offsets are not well-defined under mismatched
+* topology, so no add/sub/scale — handoffs blend from the frozen value.
+*/
+const pathType = {
+	id: "path",
+	lerp: (a, b, t) => {
+		if (!pathTopologyMatches(a, b)) {
+			if (!warnedPathTopology) {
+				warnedPathTopology = true;
+				emitDevWarning("path lerp with mismatched topology (contour/vertex counts or closed flags differ): snapping instead of morphing — supply matched vertex counts (§2.2)");
+			}
+			return t >= 1 ? b : a;
+		}
+		return a.map((ca, i) => {
+			const cb = b[i];
+			return {
+				closed: ca.closed,
+				v: ca.v.map((p, j) => lerpV(p, cb.v[j], t)),
+				in: ca.in.map((p, j) => lerpV(p, cb.in[j], t)),
+				out: ca.out.map((p, j) => lerpV(p, cb.out[j], t))
+			};
+		});
+	},
+	extrapolates: false,
+	equals: (a, b) => {
+		if (a === b) return true;
+		if (!pathTopologyMatches(a, b)) return false;
+		const eq = (x, y) => x[0] === y[0] && x[1] === y[1];
+		return a.every((ca, i) => {
+			const cb = b[i];
+			return ca.v.every((p, j) => eq(p, cb.v[j])) && ca.in.every((p, j) => eq(p, cb.in[j])) && ca.out.every((p, j) => eq(p, cb.out[j]));
+		});
+	},
+	defaultHandoff: "blend-from-frozen"
+};
+const fontAxisKeys = (a) => Object.keys(a).sort();
+const fontAxesKeysMatch = (a, b) => {
+	const ka = fontAxisKeys(a);
+	const kb = fontAxisKeys(b);
+	return ka.length === kb.length && ka.every((k, i) => k === kb[i]);
+};
+let warnedFontAxes = false;
+/**
+* Variable-font axis map (§3.6) — `{ wght: 700, opsz: 14 }`, the ANIMATABLE
+* counterpart to the static `fontVariationSettings` string. Lerps PER AXIS. Both
+* keyframes must declare the SAME axis tags; a mismatched axis set SNAPS (holds
+* `a`, then `b` at t≥1) + a one-time dev-warning — the same topology rule as
+* path/paint, which prevents the silent-NaN class. No add/sub/scale (a structured
+* map carries no linear offset); handoffs blend from the frozen value.
+*/
+const fontAxesType = {
+	id: "fontAxes",
+	lerp: (a, b, t) => {
+		if (!fontAxesKeysMatch(a, b)) {
+			if (!warnedFontAxes) {
+				warnedFontAxes = true;
+				emitDevWarning("fontAxes lerp with mismatched axis tags (the two keyframes declare different axes): snapping instead of interpolating — give both keyframes the SAME axis set (§3.6)");
+			}
+			return t >= 1 ? b : a;
+		}
+		const out = {};
+		for (const k of Object.keys(a)) out[k] = a[k] + (b[k] - a[k]) * t;
+		return out;
+	},
+	extrapolates: false,
+	equals: (a, b) => {
+		if (a === b) return true;
+		if (!fontAxesKeysMatch(a, b)) return false;
+		return Object.keys(a).every((k) => a[k] === b[k]);
+	},
+	defaultHandoff: "blend-from-frozen"
+};
+const lerpN = (a, b, t) => a + (b - a) * t;
+const lerpPt = (a, b, t) => [lerpN(a[0], b[0], t), lerpN(a[1], b[1], t)];
+/** Same hue at alpha 0 — a transparent stand-in so an appearing/disappearing
+* `bg` (mesh baseline) fades through alpha instead of popping at the boundary.
+* `parseColor` THROWS on a non-hex/non-canonical CSS color (hsl/named/oklch);
+* since this runs inside `lerp` during evaluate() it must NEVER throw — fall
+* back to holding the PRESENT color so the bg snaps in/out instead of crashing
+* the whole frame. */
+function transparentOf(color) {
+	try {
+		return formatColor({
+			...parseColor(color),
+			a: 0
+		});
+	} catch {
+		return color;
+	}
+}
+/** `lerpColor` that NEVER throws inside `lerp` (evaluate()): on an unparseable
+* color (hsl/named/oklch — `parseColor` only knows hex/rgb) it SNAPS (holds `a`,
+* then `b` at t≥1) instead of crashing the frame. Byte-identical to `lerpColor`
+* for parseable colors, so it does not move any golden. */
+function safeLerpColor(a, b, t) {
+	try {
+		return lerpColor(a, b, t);
+	} catch {
+		return t >= 1 ? b : a;
+	}
+}
+/** Lift a solid color to a uniform gradient matching `shape` (every stop = color),
+* so a color↔gradient tween fades smoothly instead of snapping. */
+function liftColor(color, shape) {
+	const stops = shape.stops.map((s) => ({
+		offset: s.offset,
+		color
+	}));
+	const interp = shape.interpolation ? { interpolation: shape.interpolation } : {};
+	return shape.kind === "radial" ? {
+		kind: "radial",
+		stops,
+		...shape.center ? { center: shape.center } : {},
+		...shape.radius !== void 0 ? { radius: shape.radius } : {},
+		...interp
+	} : {
+		kind: "linear",
+		stops,
+		...shape.from ? { from: shape.from } : {},
+		...shape.to ? { to: shape.to } : {},
+		...interp
+	};
+}
+let warnedPaintShape = false;
+function paintSnap(t, a, b, message = "paint lerp across mismatched gradient shapes (different kind or stop count): snapping instead of interpolating — match the kind + stop count on both keyframes (§2.2)") {
+	if (!warnedPaintShape) {
+		warnedPaintShape = true;
+		emitDevWarning(message);
+	}
+	return t >= 1 ? b : a;
+}
+const stopsEqual = (a, b) => a.length === b.length && a.every((s, i) => s.offset === b[i].offset && s.color === b[i].color);
+/**
+* Gradient paint morphing (§2.2): a solid color lifts to a uniform gradient to
+* meet the other side, then matched-kind/matched-stop-count gradients lerp their
+* stops (offset + oklab color) and geometry pairwise; a mismatched kind or stop
+* count snaps (hold a, then b at t ≥ 1) with a one-time dev warning. Lerp-only —
+* no offsets under mismatch — so handoffs blend from the frozen value.
+*/
+const paintType = {
+	id: "paint",
+	lerp: (a, b, t) => {
+		if (a.kind === "color" && b.kind === "color") return {
+			kind: "color",
+			color: lerpColor(a.color, b.color, t)
+		};
+		if (a.kind === "mesh" && b.kind === "mesh") {
+			if (a.points.length !== b.points.length) return paintSnap(t, a, b);
+			if (a.interpolation !== b.interpolation) return paintSnap(t, a, b, `paint lerp across mismatched mesh interpolation modes ('${a.interpolation ?? "smooth"}' → '${b.interpolation ?? "smooth"}'): snapping instead of interpolating — the blend kernel is discrete, so it switches once at the boundary; match \`interpolation\` on both keyframes to morph the points (§3 Paint)`);
+			const points = a.points.map((pa, i) => {
+				const pb = b.points[i];
+				return {
+					pos: lerpPt(pa.pos, pb.pos, t),
+					color: lerpColor(pa.color, pb.color, t)
+				};
+			});
+			const bg = a.bg !== void 0 || b.bg !== void 0 ? { bg: safeLerpColor(a.bg ?? transparentOf(b.bg), b.bg ?? transparentOf(a.bg), t) } : {};
+			return {
+				kind: "mesh",
+				points,
+				...a.interpolation ? { interpolation: a.interpolation } : {},
+				...bg
+			};
+		}
+		if (a.kind === "mesh" || b.kind === "mesh") return paintSnap(t, a, b);
+		let A = a;
+		let B = b;
+		if (A.kind === "color" && B.kind !== "color") A = liftColor(A.color, B);
+		else if (B.kind === "color" && A.kind !== "color") B = liftColor(B.color, A);
+		if (A.kind === "color" || B.kind === "color" || A.kind !== B.kind || A.stops.length !== B.stops.length) return paintSnap(t, a, b);
+		const stops = A.stops.map((sa, i) => ({
+			offset: lerpN(sa.offset, B.stops[i].offset, t),
+			color: lerpColor(sa.color, B.stops[i].color, t)
+		}));
+		const interp = A.interpolation ? { interpolation: A.interpolation } : {};
+		if (A.kind === "radial" && B.kind === "radial") return {
+			kind: "radial",
+			stops,
+			...A.center && B.center ? { center: lerpPt(A.center, B.center, t) } : A.center ? { center: A.center } : {},
+			...A.radius !== void 0 && B.radius !== void 0 ? { radius: lerpN(A.radius, B.radius, t) } : A.radius !== void 0 ? { radius: A.radius } : {},
+			...interp
+		};
+		if (A.kind === "linear" && B.kind === "linear") return {
+			kind: "linear",
+			stops,
+			...A.from && B.from ? { from: lerpPt(A.from, B.from, t) } : A.from ? { from: A.from } : {},
+			...A.to && B.to ? { to: lerpPt(A.to, B.to, t) } : A.to ? { to: A.to } : {},
+			...interp
+		};
+		return paintSnap(t, a, b);
+	},
+	extrapolates: false,
+	equals: (a, b) => {
+		if (a === b) return true;
+		if (a.kind !== b.kind) return false;
+		if (a.kind === "color") return b.kind === "color" && a.color === b.color;
+		if (a.kind === "mesh") {
+			if (b.kind !== "mesh") return false;
+			if (a.interpolation !== b.interpolation || a.bg !== b.bg) return false;
+			if (a.points.length !== b.points.length) return false;
+			return a.points.every((p, i) => {
+				const q = b.points[i];
+				return p.color === q.color && p.pos[0] === q.pos[0] && p.pos[1] === q.pos[1];
+			});
+		}
+		if (b.kind === "color" || b.kind === "mesh") return false;
+		if (!stopsEqual(a.stops, b.stops)) return false;
+		if (a.interpolation !== b.interpolation) return false;
+		if (a.kind === "radial" && b.kind === "radial") return JSON.stringify(a.center) === JSON.stringify(b.center) && a.radius === b.radius;
+		if (a.kind === "linear" && b.kind === "linear") return JSON.stringify(a.from) === JSON.stringify(b.from) && JSON.stringify(a.to) === JSON.stringify(b.to);
+		return false;
+	},
+	defaultHandoff: "blend-from-frozen"
+};
+var ValueTypeInferenceError = class extends Error {
+	constructor(value) {
+		super(`cannot infer a value type for ${JSON.stringify(value)}; register a custom type`);
+		this.name = "ValueTypeInferenceError";
+	}
+};
+const isContour = (c) => typeof c === "object" && c !== null && typeof c.closed === "boolean" && Array.isArray(c.v) && Array.isArray(c.in) && Array.isArray(c.out);
+const isPaint = (v) => typeof v === "object" && v !== null && (v.kind === "color" || v.kind === "linear" || v.kind === "radial" || v.kind === "mesh");
+/** Infer a registered type id from a sample value (builder + bake authoring surfaces). */
+function inferValueType(value) {
+	if (typeof value === "number") return "number";
+	if (typeof value === "boolean") return "boolean";
+	if (isPaint(value)) return "paint";
+	if (Array.isArray(value) && value.length === 2 && value.every((v) => typeof v === "number")) return "vec2";
+	if (Array.isArray(value) && value.length > 0 && value.every(isContour)) return "path";
+	if (typeof value === "string") try {
+		parseColor(value);
+		return "color";
+	} catch {
+		return "string";
+	}
+	throw new ValueTypeInferenceError(value);
+}
+registerValueType(numberType);
+registerValueType(vec2Type);
+registerValueType(vec2ArcType);
+registerValueType(colorType);
+registerValueType(stringType);
+registerValueType(booleanType);
+registerValueType(pathType);
+registerValueType(paintType);
+registerValueType(fontAxesType);
+//#endregion
+//#region src/track.ts
+/**
+* Track & keyframe model (DESIGN.md §2.2) and sampling (§2.4): binary search
+* per track with a last-segment cursor — sanctioned memoization, semantics
+* identical to a cold search (property-tested).
+*/
+let exprCompiler = null;
+/** Register the expr compiler (called on `@glissade/core/expr` import). */
+function setExprCompiler(fn) {
+	exprCompiler = fn;
+}
+const NO_EXPR = "expr tracks need `import '@glissade/core/expr'`";
+var TrackValidationError = class extends Error {
+	constructor(target, message) {
+		super(`track '${target}': ${message}`);
+		this.name = "TrackValidationError";
+	}
+};
+const TARGET_SHAPE = /^[^/]+\/.+$/;
+const TARGET_MSG = "target must be '<nodeId>/<prop.path>' (e.g. 'circle/opacity')";
+function validateTrack(track) {
+	const vt = getValueType(track.type);
+	if (!TARGET_SHAPE.test(track.target)) throw new TrackValidationError(track.target, TARGET_MSG);
+	if (track.expr !== void 0) {
+		if (track.type !== "number") throw new TrackValidationError(track.target, `an expr track must be type 'number' (got '${track.type}')`);
+		if (exprCompiler) try {
+			exprCompiler(track.expr);
+		} catch (e) {
+			throw new TrackValidationError(track.target, `invalid expr: ${e instanceof Error ? e.message : String(e)}`);
+		}
+		return;
+	}
+	if (track.keys.length === 0) throw new TrackValidationError(track.target, "must have at least one key");
+	if (vt.defaultHandoff === "cut") {
+		for (const k of track.keys) if (k.interp !== "hold") k.interp = "hold";
+	}
+	const repr = vt.repr ?? vt.id;
+	if (repr === "number" || repr === "vec2") {
+		for (const k of track.keys) if (!(repr === "number" ? typeof k.value === "number" && Number.isFinite(k.value) : Array.isArray(k.value) && k.value.length === 2 && k.value.every((n) => typeof n === "number" && Number.isFinite(n)))) {
+			const got = typeof k.value === "function" ? "a function (a signal accessor? call it — e.g. node.height(), not node.height)" : typeof k.value === "object" ? JSON.stringify(k.value) : String(k.value);
+			throw new TrackValidationError(track.target, `${repr} keyframe at t=${k.t} must be ${repr === "number" ? "a finite number" : "a [x, y] of finite numbers"}, got ${got}`);
+		}
+	}
+	for (let i = 1; i < track.keys.length; i++) {
+		const prev = track.keys[i - 1];
+		const cur = track.keys[i];
+		if (cur.t <= prev.t) throw new TrackValidationError(track.target, `keys must be strictly increasing in t (key[${i}] at t=${cur.t} after t=${prev.t})`);
+	}
+}
+function key(t, value, easeOrOpts) {
+	if (easeOrOpts === void 0) return {
+		t,
+		value
+	};
+	if (typeof easeOrOpts === "string" || "kind" in easeOrOpts) return {
+		t,
+		value,
+		ease: easeOrOpts
+	};
+	const opts = easeOrOpts;
+	const k = {
+		t,
+		value
+	};
+	if (opts.ease !== void 0) k.ease = opts.ease;
+	if (opts.interp !== void 0) k.interp = opts.interp;
+	if (opts.id !== void 0) k.id = opts.id;
+	if (opts.derived !== void 0) k.derived = opts.derived;
+	return k;
+}
+/**
+* The settle-ON-the-beat helper: a spring key must sit at prev.t +
+* spring.duration(cfg) (§2.7), so beat-anchored authoring otherwise means
+* hand-computing the launch time. springTo returns the [launch, settle] key
+* pair with the arithmetic done — spread it into a raw track():
+*   track('x/width', 'number', [...springTo(beats.start('drop'), 0, 320, cfg)])
+*/
+function springTo(endT, from, to, cfg) {
+	const d = spring.duration(cfg);
+	if (endT - d < 0) throw new TrackValidationError("springTo", `this spring needs ${d.toFixed(3)}s to settle — endT must be ≥ its duration (got ${endT})`);
+	return [key(endT - d, from), key(endT, to, spring(cfg))];
+}
+/**
+* Cascade a set of tracks by shifting each one's key times — the classic
+* stagger for animating a list of nodes with a delay between them. `delay` is
+* the per-index gap in seconds, or a function of the index for non-linear
+* cascades. Pure: returns new tracks, leaving the inputs untouched.
+*
+*   stagger(items.map((it, i) => track(`${it.id}/opacity`, 'number',
+*     [key(0, 0), key(0.3, 1, 'easeOutCubic')])), 0.08)
+*/
+function stagger(tracks, delay) {
+	const at = typeof delay === "function" ? delay : (i) => i * delay;
+	return tracks.map((tr, i) => {
+		const d = at(i);
+		return {
+			...tr,
+			keys: tr.keys.map((k) => ({
+				...k,
+				t: k.t + d
+			}))
+		};
+	});
+}
+/** Minimal reversed copy of a key schedule: mirror times about [t0,tn], reverse
+* the value order, and time-mirror each segment's ease so it plays identically
+* backward. Throws on `hold` segments (asymmetric — can't reverse cleanly). */
+function reversedKeys(keys) {
+	const n = keys.length;
+	if (n < 2) return keys.map((k) => ({
+		t: k.t,
+		value: k.value
+	}));
+	const t0 = keys[0].t;
+	const tn = keys[n - 1].t;
+	const out = [];
+	for (let j = 0; j < n; j++) {
+		const src = keys[n - 1 - j];
+		const k = {
+			t: t0 + tn - src.t,
+			value: src.value
+		};
+		if (j >= 1) {
+			const oldArrival = keys[n - j];
+			if (oldArrival.interp === "hold") throw new TrackValidationError("retime", "cannot reverse/pingpong a track with a hold segment (a hold is asymmetric in time) — retime it with { speed } / { shift }, or author the reversed schedule explicitly");
+			const m = mirrorEase(oldArrival.ease);
+			if (m !== void 0) k.ease = m;
+		}
+		out.push(k);
+	}
+	return out;
+}
+/**
+* Retime a set of tracks by remapping their key TIMES — slow-mo/fast (`speed`),
+* delay/advance (`shift`), `reverse`, or `pingpong` — as a pure build-time
+* transform. Because it rewrites the schedule into an ordinary `Track[]` (no
+* runtime clock warp, no cross-frame state), evaluate() stays a pure function of
+* time and the result is golden-stable and O(log keys) scrubbable like any doc.
+* Reverse/pingpong time-mirror each segment's ease exactly for the built-in
+* eases and cubicBezier; springs and hold segments fail loud (they're causal /
+* asymmetric). Returns NEW tracks; the inputs are untouched.
+*
+*   retime(move, { speed: 0.5 })            // half speed
+*   retime(move, { reverse: true })         // play it backward
+*   retime(move, { pingpong: true })        // there and back
+*/
+function retime(tracks, spec) {
+	const speed = spec.speed ?? 1;
+	if (!(speed > 0) || !Number.isFinite(speed)) throw new TrackValidationError("retime", `speed must be a finite number > 0 (got ${speed})`);
+	if (spec.reverse && spec.pingpong) throw new TrackValidationError("retime", "pass reverse OR pingpong, not both");
+	const shift = spec.shift ?? 0;
+	return tracks.map((tr) => {
+		let keys = tr.keys.map((k) => ({
+			...k,
+			t: k.t / speed
+		}));
+		if (spec.reverse) keys = reversedKeys(keys);
+		if (spec.pingpong && keys.length >= 2) {
+			const t0 = keys[0].t;
+			const tn = keys[keys.length - 1].t;
+			const back = reversedKeys(keys).map((k) => ({
+				...k,
+				t: k.t + (tn - t0)
+			}));
+			keys = [...keys, ...back.slice(1)];
+		}
+		if (shift !== 0) keys = keys.map((k) => ({
+			...k,
+			t: k.t + shift
+		}));
+		return {
+			...tr,
+			keys
+		};
+	});
+}
+function track(target, type, keys, opts) {
+	const tr = {
+		target,
+		type,
+		keys
+	};
+	if (opts?.editable !== void 0) tr.editable = opts.editable;
+	validateTrack(tr);
+	return tr;
+}
+/**
+* Expr (0.40): build a raw formula-driven numeric track — `{ target, type:
+* 'number', keys: [], expr }`. The public `exprTrack()` (on `@glissade/core/expr`,
+* which also registers the evaluator) wraps this + validates. Kept here (base) so
+* `tl.expr` can emit a track without dragging the evaluator onto the embed.
+*/
+function makeExprTrack(target, formula) {
+	const tr = {
+		target,
+		type: "number",
+		keys: [],
+		expr: formula
+	};
+	validateTrack(tr);
+	return tr;
+}
+function resolveEase(spec) {
+	if (spec === void 0) return namedEasing("linear");
+	if (typeof spec === "string") return namedEasing(spec);
+	if (spec.kind === "cubicBezier") return cubicBezier(...spec.pts);
+	return springEasing(spec);
+}
+const warnedNumericDerivative = /* @__PURE__ */ new Set();
+/**
+* Analytic d(u) for an ease spec (§B.6). Custom-registered eases without a
+* derivative fall back to a symmetric difference with a one-time dev warning.
+*/
+function resolveEaseDerivative(spec) {
+	if (spec === void 0) return easingDerivatives["linear"];
+	if (typeof spec === "string") {
+		const d = easingDerivatives[spec];
+		if (d) return d;
+		const fn = namedEasing(spec);
+		if (!warnedNumericDerivative.has(spec)) {
+			warnedNumericDerivative.add(spec);
+			emitDevWarning(`easing '${spec}' has no registered derivative; velocity uses a numeric fallback — register one in easingDerivatives for exact interruption handoff`);
+		}
+		const h = 1 / 1024;
+		return (u) => (fn(Math.min(1, u + h)) - fn(Math.max(0, u - h))) / (Math.min(1, u + h) - Math.max(0, u - h));
+	}
+	if (spec.kind === "cubicBezier") return cubicBezierDerivative(...spec.pts);
+	return springEasingDerivative(spec);
+}
+const samplerStates = /* @__PURE__ */ new WeakMap();
+function state(tr) {
+	let s = samplerStates.get(tr);
+	if (!s) {
+		s = {
+			cursor: 1,
+			easeCache: new Array(tr.keys.length)
+		};
+		samplerStates.set(tr, s);
+	}
+	return s;
+}
+function easeFor(tr, s, i) {
+	let fn = s.easeCache[i];
+	if (!fn) {
+		fn = resolveEase(tr.keys[i].ease);
+		s.easeCache[i] = fn;
+	}
+	return fn;
+}
+/**
+* Find i such that keys[i-1].t <= t < keys[i].t, i.e. the index of the
+* arrival key of the segment containing t. Returns 0 if t < first key,
+* keys.length if t >= last key.
+*/
+function findSegment(keys, t, hint) {
+	const n = keys.length;
+	for (let i = Math.max(1, hint - 1); i <= Math.min(n - 1, hint + 1); i++) if (keys[i - 1].t <= t && t < keys[i].t) return i;
+	if (t < keys[0].t) return 0;
+	if (t >= keys[n - 1].t) return n;
+	let lo = 1;
+	let hi = n - 1;
+	while (lo < hi) {
+		const mid = lo + hi >> 1;
+		if (keys[mid].t <= t) lo = mid + 1;
+		else hi = mid;
+	}
+	return lo;
+}
+/**
+* Analytic track derivative at time t, in value-units per second of local
+* track time (v2 addendum §B.3/§B.6 conventions, pinned):
+* (a) at a key boundary, velocity is the RIGHT derivative;
+* (b) hold segments and the clamped regions outside the keys have v = 0;
+* (c) types without sub/scale operators return null (no kinetic velocity).
+*/
+function velocityAt(tr, t) {
+	const vt = getValueType(tr.type);
+	if (!vt.sub || !vt.scale) return null;
+	const keys = tr.keys;
+	const n = keys.length;
+	const s = state(tr);
+	const i = findSegment(keys, t, s.cursor);
+	const zero = vt.scale(vt.sub(keys[0].value, keys[0].value), 0);
+	if (i === 0 || i >= n) return zero;
+	const arrival = keys[i];
+	if (arrival.interp === "hold") return zero;
+	const prev = keys[i - 1];
+	const segDur = arrival.t - prev.t;
+	const p = (t - prev.t) / segDur;
+	if (!vt.extrapolates) {
+		const eased = easeFor(tr, s, i)(p);
+		if (eased < 0 || eased > 1) return zero;
+	}
+	const d = resolveEaseDerivative(arrival.ease)(p);
+	return vt.scale(vt.sub(arrival.value, prev.value), d / segDur);
+}
+/** Pure sample of a track at time t (§2.4). */
+function sampleTrack(tr, t) {
+	if (tr.expr !== void 0) {
+		const s = state(tr);
+		if (!exprCompiler) throw new TrackValidationError(tr.target, NO_EXPR);
+		s.exprEval ??= exprCompiler(tr.expr);
+		return s.exprEval(t);
+	}
+	const keys = tr.keys;
+	const n = keys.length;
+	const s = state(tr);
+	const i = findSegment(keys, t, s.cursor);
+	if (i === 0) return keys[0].value;
+	if (i >= n) return keys[n - 1].value;
+	s.cursor = i;
+	const arrival = keys[i];
+	const prev = keys[i - 1];
+	if (arrival.interp === "hold") return prev.value;
+	const vt = getValueType(tr.type);
+	const p = (t - prev.t) / (arrival.t - prev.t);
+	let easedT = easeFor(tr, s, i)(p);
+	if (!vt.extrapolates && (easedT < 0 || easedT > 1)) {
+		if (!s.warnedClamp) {
+			s.warnedClamp = true;
+			emitDevWarning(`track '${tr.target}' (type '${tr.type}') clamped an out-of-range eased value — non-extrapolating types can't overshoot, so a spring/overshooting ease on this track is flattened`);
+		}
+		easedT = Math.min(1, Math.max(0, easedT));
+	}
+	return vt.lerp(prev.value, arrival.value, easedT);
+}
+//#endregion
+export { vec2Type as A, springEasing as B, paintType as C, stringType as D, reprOf as E, parseColor as F, cubicBezier as G, springPresets as H, rgbaToOklab as I, easings as J, cubicBezierDerivative as K, emitDevWarning as L, formatColor as M, lerpColor as N, vec2ArcType as O, oklabToRgba as P, setDevWarning as R, numberType as S, registerValueType as T, DEFAULT_EASE as U, springEasingDerivative as V, UnknownEasingError as W, namedEasing as Y, colorType as _, resolveEaseDerivative as a, inferValueType as b, setExprCompiler as c, track as d, validateTrack as f, booleanType as g, ValueTypeInferenceError as h, resolveEase as i, ColorParseError as j, vec2Equals as k, springTo as l, UnknownValueTypeError as m, key as n, retime as o, velocityAt as p, easingDerivatives as q, makeExprTrack as r, sampleTrack as s, TrackValidationError as t, stagger as u, fontAxesType as v, pathType as w, listValueTypes as x, getValueType as y, spring as z };