@glissade/core 0.1.0

package/dist/index.js

@@ -0,0 +1,1331 @@
+//#region src/signal.ts
+let activeConsumer = null;
+let readPhaseDepth = 0;
+var WriteDuringEvaluationError = class extends Error {
+	constructor() {
+		super("signal.set() during evaluation: the read phase is pure (DESIGN.md §2.1). Drivers write the playhead before evaluation begins; stateful animation belongs in bake().");
+		this.name = "WriteDuringEvaluationError";
+	}
+};
+var CircularDependencyError = class extends Error {
+	constructor() {
+		super("circular signal dependency detected");
+		this.name = "CircularDependencyError";
+	}
+};
+/** Begin the pure read phase; any signal write until {@link endReadPhase} throws. */
+function beginReadPhase() {
+	readPhaseDepth++;
+}
+function endReadPhase() {
+	if (readPhaseDepth === 0) throw new Error("endReadPhase() without matching beginReadPhase()");
+	readPhaseDepth--;
+}
+function inReadPhase() {
+	return readPhaseDepth > 0;
+}
+var SignalNode = class {
+	value;
+	/** Compute function; null for plain writable sources. Binding installs one. */
+	fn;
+	equals;
+	version = 0;
+	state;
+	computing = false;
+	deps = [];
+	depVersions = [];
+	dependents = /* @__PURE__ */ new Set();
+	subscribers = /* @__PURE__ */ new Set();
+	constructor(init) {
+		this.fn = init.fn ?? null;
+		this.value = init.value;
+		this.equals = init.equals ?? Object.is;
+		this.state = this.fn ? 2 : 0;
+	}
+	get() {
+		if (activeConsumer) activeConsumer.addDep(this);
+		this.updateIfNecessary();
+		return this.value;
+	}
+	peek() {
+		this.updateIfNecessary();
+		return this.value;
+	}
+	set(next) {
+		if (readPhaseDepth > 0) throw new WriteDuringEvaluationError();
+		if (this.fn) this.detachFn();
+		this.writeValue(next);
+	}
+	/**
+	* Sanctioned entry write (the playhead at evaluate() entry, DESIGN.md §2.5).
+	* Identical to set() but exempt from the phase guard; not part of the public
+	* signal surface.
+	*/
+	forceSet(next) {
+		if (this.fn) this.detachFn();
+		this.writeValue(next);
+	}
+	/** Rewire this signal's source to a computation (timeline binding, §2.4). */
+	bindSource(fn) {
+		if (readPhaseDepth > 0) throw new WriteDuringEvaluationError();
+		this.fn = fn;
+		this.state = 2;
+		this.invalidateDependents(2);
+	}
+	/** Remove a bound source, freezing the signal at its last value. */
+	unbindSource() {
+		if (readPhaseDepth > 0) throw new WriteDuringEvaluationError();
+		if (!this.fn) return;
+		this.updateIfNecessary();
+		this.detachFn();
+	}
+	get isBound() {
+		return this.fn !== null;
+	}
+	subscribe(cb) {
+		this.subscribers.add(cb);
+		return () => this.subscribers.delete(cb);
+	}
+	addDep(dep) {
+		if (this.deps[this.deps.length - 1] !== dep) {
+			this.deps.push(dep);
+			this.depVersions.push(-1);
+			dep.dependents.add(this);
+		}
+	}
+	detachFn() {
+		this.fn = null;
+		this.clearDeps();
+		this.state = 0;
+	}
+	writeValue(next) {
+		if (this.version > 0 || this.value !== void 0) {
+			if (this.equals(this.value, next)) return;
+		}
+		this.value = next;
+		this.version++;
+		this.invalidateDependents(2);
+	}
+	invalidateDependents(level) {
+		for (const d of [...this.dependents]) d.markStale(level);
+		if (this.subscribers.size > 0) for (const cb of [...this.subscribers]) cb();
+	}
+	markStale(level) {
+		if (this.state >= level) return;
+		const wasClean = this.state === 0;
+		this.state = level;
+		if (wasClean) this.invalidateDependents(1);
+	}
+	updateIfNecessary() {
+		if (this.fn === null || this.state === 0) return;
+		if (this.computing) throw new CircularDependencyError();
+		if (this.state === 1) {
+			this.state = 0;
+			for (let i = 0; i < this.deps.length; i++) {
+				const dep = this.deps[i];
+				dep.updateIfNecessary();
+				if (dep.version !== this.depVersions[i]) {
+					this.state = 2;
+					break;
+				}
+			}
+		}
+		if (this.state === 2) this.recompute();
+		this.state = 0;
+	}
+	recompute() {
+		this.clearDeps();
+		const prevConsumer = activeConsumer;
+		activeConsumer = this;
+		this.computing = true;
+		let next;
+		try {
+			next = this.fn();
+		} finally {
+			this.computing = false;
+			activeConsumer = prevConsumer;
+		}
+		for (let i = 0; i < this.deps.length; i++) this.depVersions[i] = this.deps[i].version;
+		if (!(this.version > 0 || this.value !== void 0) || !this.equals(this.value, next)) {
+			this.value = next;
+			this.version++;
+		}
+	}
+	clearDeps() {
+		for (const dep of this.deps) dep.dependents.delete(this);
+		this.deps = [];
+		this.depVersions = [];
+	}
+};
+function makeCallable(node, extra) {
+	const sig = (() => node.get());
+	sig["peek"] = () => node.peek();
+	sig["subscribe"] = (cb) => node.subscribe(cb);
+	extra(sig);
+	return sig;
+}
+function signal(initial, options) {
+	const node = new SignalNode({
+		value: initial,
+		equals: options?.equals
+	});
+	return makeCallable(node, (sig) => {
+		sig["set"] = (v) => node.set(v);
+		sig["forceSet"] = (v) => node.forceSet(v);
+		sig["bindSource"] = (fn) => node.bindSource(fn);
+		sig["unbindSource"] = () => node.unbindSource();
+		Object.defineProperty(sig, "isBound", { get: () => node.isBound });
+	});
+}
+function computed(fn, options) {
+	return makeCallable(new SignalNode({
+		fn,
+		equals: options?.equals
+	}), () => {});
+}
+/** Run `fn` without registering dependencies on the active consumer. */
+function untracked(fn) {
+	const prev = activeConsumer;
+	activeConsumer = null;
+	try {
+		return fn();
+	} finally {
+		activeConsumer = prev;
+	}
+}
+//#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;
+}
+const numberType = {
+	id: "number",
+	lerp: (a, b, t) => a + (b - a) * t,
+	extrapolates: true,
+	equals: Object.is
+};
+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
+};
+const colorType = {
+	id: "color",
+	lerp: lerpColor,
+	extrapolates: true,
+	equals: (a, b) => a === b
+};
+/** 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)
+	};
+}
+const stringType = discrete("string");
+const booleanType = discrete("boolean");
+var ValueTypeInferenceError = class extends Error {
+	constructor(value) {
+		super(`cannot infer a value type for ${JSON.stringify(value)}; register a custom type`);
+		this.name = "ValueTypeInferenceError";
+	}
+};
+/** 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 (Array.isArray(value) && value.length === 2 && value.every((v) => typeof v === "number")) return "vec2";
+	if (typeof value === "string") try {
+		parseColor(value);
+		return "color";
+	} catch {
+		return "string";
+	}
+	throw new ValueTypeInferenceError(value);
+}
+registerValueType(numberType);
+registerValueType(vec2Type);
+registerValueType(colorType);
+registerValueType(stringType);
+registerValueType(booleanType);
+//#endregion
+//#region src/vec2Signal.ts
+/**
+* Compound Vec2 signal (DESIGN.md §2.1): sub-signals are real signals, the
+* parent read derives from them, and tracks may target either level — a
+* sub-signal binding takes precedence for its component (§2.2).
+*/
+function vec2Signal(initial) {
+	const [ix, iy] = Array.isArray(initial) ? initial : [initial.x, initial.y];
+	const x = signal(ix);
+	const y = signal(iy);
+	const compound = signal(null, { equals: (a, b) => a === null || b === null ? a === b : a[0] === b[0] && a[1] === b[1] });
+	const baseX = signal(ix);
+	const baseY = signal(iy);
+	x.bindSource(() => {
+		const c = compound();
+		return c === null ? baseX() : c[0];
+	});
+	y.bindSource(() => {
+		const c = compound();
+		return c === null ? baseY() : c[1];
+	});
+	const value = computed(() => [x(), y()], { equals: (a, b) => a[0] === b[0] && a[1] === b[1] });
+	const sig = (() => value());
+	sig["peek"] = () => value.peek();
+	sig["subscribe"] = (cb) => value.subscribe(cb);
+	sig["set"] = (v) => {
+		compound.set(null);
+		baseX.set(v[0]);
+		baseY.set(v[1]);
+	};
+	sig["bindSource"] = (fn) => compound.bindSource(() => fn());
+	sig["unbindSource"] = () => {
+		compound.unbindSource();
+		compound.set(null);
+	};
+	Object.defineProperty(sig, "x", {
+		value: x,
+		enumerable: true
+	});
+	Object.defineProperty(sig, "y", {
+		value: y,
+		enumerable: true
+	});
+	return sig;
+}
+//#endregion
+//#region src/easing.ts
+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
+};
+/** Default property-tween ease (Motion Canvas precedent). */
+const DEFAULT_EASE = "easeInOutCubic";
+/**
+* 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 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 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 (t) => {
+		if (t <= 0) return 0;
+		if (t >= 1) return 1;
+		return sampleY(solveU(t));
+	};
+}
+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 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);
+}
+const spring = Object.assign((cfg) => {
+	params(cfg);
+	return {
+		kind: "spring",
+		stiffness: cfg.stiffness,
+		damping: cfg.damping,
+		mass: cfg.mass ?? 1
+	};
+}, {
+	duration,
+	value
+});
+/**
+* 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);
+}
+//#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).
+*/
+var TrackValidationError = class extends Error {
+	constructor(target, message) {
+		super(`track '${target}': ${message}`);
+		this.name = "TrackValidationError";
+	}
+};
+function validateTrack(track) {
+	getValueType(track.type);
+	if (track.keys.length === 0) throw new TrackValidationError(track.target, "must have at least one key");
+	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})`);
+	}
+	if (!/^[^/]+\/.+$/.test(track.target)) throw new TrackValidationError(track.target, "target must be '<nodeId>/<prop.path>' (e.g. 'circle/opacity')");
+}
+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;
+}
+function track(target, type, keys, opts) {
+	const tr = {
+		target,
+		type,
+		keys
+	};
+	if (opts?.editable !== void 0) tr.editable = opts.editable;
+	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 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;
+}
+/** Pure sample of a track at time t (§2.4). */
+function sampleTrack(tr, 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 = Math.min(1, Math.max(0, easedT));
+	return vt.lerp(prev.value, arrival.value, easedT);
+}
+//#endregion
+//#region src/timeline.ts
+/**
+* The Timeline document (DESIGN.md §2.3) — the serializable animation source
+* of truth — and its compiler: child flattening (add/sync), same-target
+* coalescing (last-insertion-wins, §2.2), duration computation, validation.
+*/
+function timeline$1(init) {
+	const doc = {
+		version: 1,
+		tracks: init.tracks ?? []
+	};
+	if (init.duration !== void 0) doc.duration = init.duration;
+	if (init.fps !== void 0) doc.fps = init.fps;
+	if (init.posterTime !== void 0) doc.posterTime = init.posterTime;
+	if (init.labels !== void 0) doc.labels = init.labels;
+	if (init.markers !== void 0) doc.markers = init.markers;
+	if (init.children !== void 0) doc.children = init.children;
+	if (init.audio !== void 0) doc.audio = init.audio;
+	if (init.assets !== void 0) doc.assets = init.assets;
+	return doc;
+}
+var TimelineValidationError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "TimelineValidationError";
+	}
+};
+/** Spring key rule (§2.7): a spring-eased key's t must equal prev.t + spring.duration(cfg). */
+function validateSpringKeys(tr) {
+	for (let i = 1; i < tr.keys.length; i++) {
+		const k = tr.keys[i];
+		if (k.ease && typeof k.ease === "object" && k.ease.kind === "spring") {
+			const expected = tr.keys[i - 1].t + spring.duration(k.ease);
+			if (Math.abs(k.t - expected) > 1e-6) throw new TimelineValidationError(`track '${tr.target}': spring-eased key at t=${k.t} must sit at prev.t + spring.duration (${expected.toFixed(6)}); the builder computes this automatically`);
+		}
+	}
+}
+let devWarn = (msg) => {
+	globalThis.console?.warn(`[glissade] ${msg}`);
+};
+function setDevWarning(fn) {
+	devWarn = fn;
+}
+/** Internal: emit through the configurable dev-warning channel. */
+function emitDevWarning(message) {
+	devWarn(message);
+}
+function rebaseKeys(keys, at, timeScale) {
+	return keys.map((k) => ({
+		...k,
+		t: at + k.t / timeScale
+	}));
+}
+function flatten(doc, at, timeScale, opaque, out) {
+	for (const tr of doc.tracks) {
+		validateTrack(tr);
+		validateSpringKeys(tr);
+		out.push({
+			track: {
+				...tr,
+				keys: rebaseKeys(tr.keys, at, timeScale)
+			},
+			opaque
+		});
+	}
+	for (const child of doc.children ?? []) {
+		const scale = child.mode === "sync" ? child.timeScale ?? 1 : 1;
+		if (child.mode === "add" && child.timeScale !== void 0) throw new TimelineValidationError("timeScale is only valid on mode:'sync' children (§2.3)");
+		if (scale <= 0) throw new TimelineValidationError("sync timeScale must be > 0");
+		flatten(child.timeline, at + child.at / timeScale, timeScale * scale, opaque || child.mode === "sync", out);
+	}
+}
+/**
+* Coalesce same-target tracks: later insertion wins where key ranges overlap
+* (§2.2/§2.6 decided rule), with a dev warning. Earlier keys inside the later
+* track's [first.t, last.t] span are dropped.
+*/
+function coalesce(entries) {
+	const byTarget = /* @__PURE__ */ new Map();
+	for (const { track: tr } of entries) {
+		const existing = byTarget.get(tr.target);
+		if (!existing) {
+			byTarget.set(tr.target, {
+				...tr,
+				keys: [...tr.keys]
+			});
+			continue;
+		}
+		if (existing.type !== tr.type) throw new TimelineValidationError(`target '${tr.target}' has conflicting value types '${existing.type}' and '${tr.type}'`);
+		const start = tr.keys[0].t;
+		const end = tr.keys[tr.keys.length - 1].t;
+		const existingStart = existing.keys[0].t;
+		const existingEnd = existing.keys[existing.keys.length - 1].t;
+		const kept = existing.keys.filter((k) => k.t < start || k.t > end);
+		if (existingStart <= end && start <= existingEnd) devWarn(`overlapping tracks for '${tr.target}' in [${start}, ${end}]: later insertion wins (${existing.keys.length - kept.length} earlier key(s) dropped)`);
+		existing.keys = [...kept, ...tr.keys].sort((a, b) => a.t - b.t);
+	}
+	return byTarget;
+}
+function childExtent(child) {
+	const scale = child.mode === "sync" ? child.timeScale ?? 1 : 1;
+	return child.at + computeDuration(child.timeline) / scale;
+}
+function computeDuration(doc) {
+	if (doc.duration !== void 0) return doc.duration;
+	let max = 0;
+	for (const tr of doc.tracks) {
+		const last = tr.keys[tr.keys.length - 1];
+		if (last) max = Math.max(max, last.t);
+	}
+	for (const m of doc.markers ?? []) max = Math.max(max, m.t);
+	for (const child of doc.children ?? []) max = Math.max(max, childExtent(child));
+	return max;
+}
+function compileTimeline(doc) {
+	if (doc.version !== 1) throw new TimelineValidationError(`unsupported timeline document version ${String(doc.version)}`);
+	const flat = [];
+	flatten(doc, 0, 1, false, flat);
+	const tracks = coalesce(flat);
+	const labels = { ...doc.labels };
+	const markers = [...doc.markers ?? []];
+	const audio = [...doc.audio ?? []];
+	const visitChildren = (children, at, scale) => {
+		for (const child of children ?? []) {
+			const base = at + child.at / scale;
+			const childScale = scale * (child.mode === "sync" ? child.timeScale ?? 1 : 1);
+			for (const [name, t] of Object.entries(child.timeline.labels ?? {})) if (!(name in labels)) labels[name] = base + t / childScale;
+			for (const m of child.timeline.markers ?? []) markers.push({
+				...m,
+				t: base + m.t / childScale
+			});
+			for (const clip of child.timeline.audio ?? []) audio.push({
+				...clip,
+				at: base + clip.at / childScale,
+				...childScale !== 1 ? { playbackRate: (clip.playbackRate ?? 1) * childScale } : {}
+			});
+			visitChildren(child.timeline.children, base, childScale);
+		}
+	};
+	visitChildren(doc.children, 0, 1);
+	markers.sort((a, b) => a.t - b.t);
+	audio.sort((a, b) => a.at - b.at);
+	return {
+		duration: computeDuration(doc),
+		labels,
+		markers,
+		tracks,
+		audio
+	};
+}
+//#endregion
+//#region src/targetRef.ts
+/**
+* Target references (DESIGN.md §2.6): the builder accepts either a canonical
+* target string ('circle/opacity') or a property signal that carries its own
+* path — attached by the scene package at node construction via TARGET_PATH.
+*/
+const TARGET_PATH = Symbol.for("glissade.targetPath");
+var UnresolvableTargetError = class extends Error {
+	constructor() {
+		super("tween target is not addressable: pass a target string (\"node/prop\") or a property signal of a node that has an explicit id (§3.1 — anonymous nodes cannot be track targets)");
+		this.name = "UnresolvableTargetError";
+	}
+};
+function resolveTweenTarget(target) {
+	if (typeof target === "string") return target;
+	const path = target[TARGET_PATH];
+	if (typeof path !== "string") throw new UnresolvableTargetError();
+	return path;
+}
+//#endregion
+//#region src/builder.ts
+/**
+* The fluent timeline builder (DESIGN.md §2.6): imperative-LOOKING chains that
+* compile to the declarative Timeline document. Nothing executes at play time.
+*
+* Position grammar (GSAP-proven): absolute `1.5`; `'+=0.5'`/`'-=0.2'` from the
+* previous insertion's END; `'<'`/`'>'` previous START/END; `'label'`,
+* `'label+=0.3'`. Implicit from-values resolve in a finalize pass in t-order
+* against the complete document — never sampled live (the GSAP invalidate()
+* bug class, §2.6), with the build-time signal value as the t-order base.
+*/
+var PositionError = class extends Error {
+	constructor(pos, detail) {
+		super(`invalid position '${pos}': ${detail}`);
+		this.name = "PositionError";
+	}
+};
+function peekBase(target) {
+	return typeof target !== "string" && typeof target.peek === "function" ? target.peek() : void 0;
+}
+/** Callbacks registered via .call(), keyed by the produced document. */
+const timelineCallbacks = /* @__PURE__ */ new WeakMap();
+function getTimelineCallbacks(doc) {
+	return timelineCallbacks.get(doc) ?? /* @__PURE__ */ new Map();
+}
+function buildTimeline(build, init = {}) {
+	const insertions = [];
+	const labels = { ...init.labels };
+	const children = [];
+	const markers = [];
+	const callbacks = /* @__PURE__ */ new Map();
+	let prevStart = 0;
+	let prevEnd = 0;
+	let callCount = 0;
+	function resolvePosition(at) {
+		if (at === void 0) return prevEnd;
+		if (typeof at === "number") return at;
+		if (at === "<") return prevStart;
+		if (at === ">") return prevEnd;
+		const rel = /^([+-])=([\d.]+)$/.exec(at);
+		if (rel) return prevEnd + (rel[1] === "+" ? 1 : -1) * parseFloat(rel[2]);
+		const labelRel = /^([^+\-=]+?)(?:([+-])=([\d.]+))?$/.exec(at);
+		if (labelRel) {
+			const name = labelRel[1];
+			if (!(name in labels)) throw new PositionError(at, `unknown label '${name}' (labels must be declared before use)`);
+			const offset = labelRel[2] ? (labelRel[2] === "+" ? 1 : -1) * parseFloat(labelRel[3]) : 0;
+			return labels[name] + offset;
+		}
+		throw new PositionError(at, "expected a number, '<', '>', '+=x', '-=x', or 'label[+=x]'");
+	}
+	const builder = {
+		to(target, value, opts = {}) {
+			const ease = opts.ease ?? "easeInOutCubic";
+			const isSpring = typeof ease === "object" && ease.kind === "spring";
+			const duration = isSpring ? spring.duration(ease) : opts.duration ?? 1;
+			if (isSpring && opts.duration !== void 0) throw new TimelineValidationError("a spring ease determines its duration (spring.duration(cfg)); do not pass duration with a spring");
+			const start = resolvePosition(opts.at);
+			const ins = {
+				kind: "tween",
+				target: resolveTweenTarget(target),
+				value,
+				duration,
+				ease,
+				at: opts.at,
+				baseValue: peekBase(target),
+				editable: false,
+				start
+			};
+			if (opts.from !== void 0) ins.explicitFrom = opts.from;
+			insertions.push(ins);
+			prevStart = start;
+			prevEnd = start + duration;
+			return builder;
+		},
+		fromTo(target, from, to, opts = {}) {
+			builder.to(target, to, opts);
+			insertions[insertions.length - 1].explicitFrom = from;
+			return builder;
+		},
+		set(target, value, opts = {}) {
+			const start = resolvePosition(opts.at);
+			insertions.push({
+				kind: "set",
+				target: resolveTweenTarget(target),
+				value,
+				duration: 0,
+				ease: "linear",
+				at: opts.at,
+				baseValue: peekBase(target),
+				editable: false,
+				start
+			});
+			prevStart = start;
+			prevEnd = start;
+			return builder;
+		},
+		label(name, at) {
+			labels[name] = at === void 0 ? prevEnd : resolvePosition(at);
+			return builder;
+		},
+		add(child, at, opts = {}) {
+			const start = at === void 0 ? prevEnd : resolvePosition(at);
+			const mode = opts.mode ?? "add";
+			const entry = {
+				timeline: child,
+				at: start,
+				mode,
+				_pos: at
+			};
+			if (opts.timeScale !== void 0) entry.timeScale = opts.timeScale;
+			children.push(entry);
+			const scale = mode === "sync" ? opts.timeScale ?? 1 : 1;
+			prevStart = start;
+			prevEnd = start + compileTimeline(child).duration / scale;
+			return builder;
+		},
+		call(fn, at) {
+			const t = at === void 0 ? prevEnd : resolvePosition(at);
+			const name = `call:${callCount++}`;
+			markers.push({
+				t,
+				name
+			});
+			callbacks.set(name, fn);
+			return builder;
+		},
+		editable() {
+			const last = insertions[insertions.length - 1];
+			if (!last) throw new TimelineValidationError(".editable() requires a preceding insertion");
+			last.editable = true;
+			return builder;
+		}
+	};
+	build(builder);
+	const byTarget = /* @__PURE__ */ new Map();
+	for (const ins of insertions) {
+		let list = byTarget.get(ins.target);
+		if (!list) {
+			list = [];
+			byTarget.set(ins.target, list);
+		}
+		list.push(ins);
+	}
+	const tracks = [];
+	for (const [target, list] of byTarget) {
+		list.sort((a, b) => a.start - b.start);
+		const keys = [];
+		const editable = list.some((i) => i.editable);
+		let prevValue = list.find((i) => i.baseValue !== void 0)?.baseValue;
+		const first = list[0];
+		if (first.kind === "tween" && first.explicitFrom === void 0 && prevValue === void 0) emitDevWarning(`'${target}': first tween has no resolvable from-value (string targets have no base) — the track sits at its end state before the tween. Anchor it with { from }, fromTo(), or set(..., { at: 0 }).`);
+		for (const ins of list) {
+			if (ins.kind === "set") {
+				keys.push({
+					t: ins.start,
+					value: ins.value,
+					interp: "hold"
+				});
+				prevValue = ins.value;
+				continue;
+			}
+			const from = ins.explicitFrom !== void 0 ? ins.explicitFrom : prevValue;
+			const lastKey = keys[keys.length - 1];
+			if (from !== void 0 && (!lastKey || lastKey.t < ins.start)) {
+				const fromKey = {
+					t: ins.start,
+					value: from
+				};
+				if (ins.explicitFrom === void 0) fromKey.derived = true;
+				if (!lastKey || ins.start > lastKey.t) keys.push(fromKey);
+			}
+			keys.push({
+				t: ins.start + ins.duration,
+				value: ins.value,
+				ease: ins.ease
+			});
+			prevValue = ins.value;
+		}
+		const deduped = [];
+		for (const k of keys.sort((a, b) => a.t - b.t)) {
+			const last = deduped[deduped.length - 1];
+			if (last && last.t === k.t) deduped[deduped.length - 1] = k;
+			else deduped.push(k);
+		}
+		const tr = {
+			target,
+			type: inferValueType(list[0].value),
+			keys: deduped
+		};
+		if (editable) tr.editable = true;
+		tracks.push(tr);
+	}
+	const doc = timeline$1({
+		...init,
+		tracks,
+		labels,
+		...markers.length ? { markers } : {},
+		...children.length ? { children: children.map(({ _pos, ...c }) => c) } : {}
+	});
+	if (callbacks.size) timelineCallbacks.set(doc, callbacks);
+	return doc;
+}
+function timeline(arg, init) {
+	return typeof arg === "function" ? buildTimeline(arg, init) : timeline$1(arg);
+}
+//#endregion
+//#region src/binding.ts
+/**
+* Playhead + timeline binding (DESIGN.md §2.4): animated properties are not
+* written each frame — binding rewires each targeted signal's source to
+* `() => sampleTrack(track, playhead())`, so evaluation stays pull-only and
+* unchanged samples don't propagate dirtiness.
+*/
+function createPlayhead(initial = 0) {
+	return signal(initial);
+}
+var UnboundTargetError = class extends Error {
+	constructor(target) {
+		super(`timeline targets '${target}' but no property signal resolves to it`);
+		this.name = "UnboundTargetError";
+	}
+};
+/**
+* Bind a compiled timeline's tracks to property signals. `resolve` returns
+* the signal for a target path, or undefined — which is a compile-time-style
+* error (§2.2: unbound tracks are build errors, not silent no-ops).
+*/
+function bindTimeline(compiled, resolve, playhead = createPlayhead()) {
+	const bound = [];
+	for (const [target, tr] of compiled.tracks) {
+		const sig = resolve(target);
+		if (!sig) throw new UnboundTargetError(target);
+		sig.bindSource(() => sampleTrack(tr, playhead()));
+		bound.push(sig);
+	}
+	return {
+		playhead,
+		unbind: () => {
+			for (const sig of bound) sig.unbindSource();
+		}
+	};
+}
+/**
+* The evaluation entry discipline (§2.5): the playhead write is the sanctioned
+* entry mutation, then the read phase begins and `read` must be pure.
+*/
+function evaluateAt(playhead, t, read) {
+	playhead.forceSet(t);
+	beginReadPhase();
+	try {
+		return read();
+	} finally {
+		endReadPhase();
+	}
+}
+//#endregion
+//#region src/rng.ts
+/** Returns a deterministic [0,1) generator for the given integer seed. */
+function random(seed) {
+	let a = seed >>> 0;
+	return () => {
+		a = a + 2654435769 | 0;
+		let t = a ^ a >>> 16;
+		t = Math.imul(t, 569420461);
+		t = t ^ t >>> 15;
+		t = Math.imul(t, 1935289751);
+		t = t ^ t >>> 15;
+		return (t >>> 0) / 4294967296;
+	};
+}
+//#endregion
+//#region src/bake.ts
+/**
+* bake() (DESIGN.md §2.8): stateful simulation as a compilation step. Run the
+* stepper ONCE — fixed dt, seeded RNG — and emit ordinary frame-indexed
+* Tracks; rendering stays a pure lookup and the §2.5 contract survives.
+* The checkpointed variant trades memory for bounded re-simulation.
+*/
+var BakeError = class extends Error {
+	constructor(detail) {
+		super(`bake(): ${detail}`);
+		this.name = "BakeError";
+	}
+};
+function emit(acc, sampled, t) {
+	for (const [path, value] of Object.entries(sampled)) {
+		let a = acc.get(path);
+		if (!a) {
+			a = {
+				keys: [],
+				type: inferValueType(value)
+			};
+			acc.set(path, a);
+		}
+		a.keys.push({
+			t,
+			value
+		});
+	}
+}
+function toTracks(acc) {
+	return [...acc.entries()].map(([target, a]) => ({
+		target,
+		type: a.type,
+		keys: a.keys
+	}));
+}
+function bake(cfg) {
+	if (!(cfg.fps > 0) || !(cfg.duration >= 0)) throw new BakeError("fps must be > 0 and duration >= 0");
+	const rng = random(cfg.seed ?? 0);
+	const dt = 1 / cfg.fps;
+	const frames = Math.round(cfg.duration * cfg.fps);
+	let world = cfg.setup(rng);
+	const acc = /* @__PURE__ */ new Map();
+	emit(acc, cfg.sample(world), 0);
+	for (let f = 1; f <= frames; f++) {
+		world = cfg.step(world, dt, rng) ?? world;
+		emit(acc, cfg.sample(world), f * dt);
+	}
+	return toTracks(acc);
+}
+function bakeCheckpointed(cfg) {
+	if (!(cfg.every >= 1)) throw new BakeError("checkpoint interval `every` must be >= 1 frame");
+	const dt = 1 / cfg.fps;
+	const totalFrames = Math.round(cfg.duration * cfg.fps);
+	let draws = 0;
+	const baseRng = random(cfg.seed ?? 0);
+	const countingRng = () => {
+		draws++;
+		return baseRng();
+	};
+	const rngAt = (targetDraws) => {
+		const r = random(cfg.seed ?? 0);
+		for (let i = 0; i < targetDraws; i++) r();
+		return r;
+	};
+	let world = cfg.setup(countingRng);
+	const checkpoints = [{
+		snap: cfg.snapshot(world),
+		rngDraws: draws
+	}];
+	let simulatedTo = 0;
+	/** Advance the master simulation, recording a checkpoint every K frames. */
+	function ensureSimulatedTo(frame) {
+		while (simulatedTo < Math.min(frame, totalFrames)) {
+			world = cfg.step(world, dt, countingRng) ?? world;
+			simulatedTo++;
+			if (simulatedTo % cfg.every === 0) checkpoints.push({
+				snap: cfg.snapshot(world),
+				rngDraws: draws
+			});
+		}
+	}
+	return {
+		frames: totalFrames,
+		bakeRange(fromFrame, toFrame) {
+			if (fromFrame < 0 || toFrame > totalFrames || fromFrame > toFrame) throw new BakeError(`range ${fromFrame}..${toFrame} outside 0..${totalFrames}`);
+			const cpFrame = Math.floor(fromFrame / cfg.every) * cfg.every;
+			ensureSimulatedTo(cpFrame);
+			const cp = checkpoints[cpFrame / cfg.every];
+			let w = cfg.restore(cp.snap);
+			const rng = rngAt(cp.rngDraws);
+			let frame = cpFrame;
+			const acc = /* @__PURE__ */ new Map();
+			if (frame >= fromFrame) emit(acc, cfg.sample(w), frame * dt);
+			while (frame < toFrame) {
+				w = cfg.step(w, dt, rng) ?? w;
+				frame++;
+				if (frame >= fromFrame) emit(acc, cfg.sample(w), frame * dt);
+			}
+			return toTracks(acc);
+		}
+	};
+}
+//#endregion
+//#region src/sidecar.ts
+/**
+* The editor sidecar (DESIGN.md §6.2): code declares scene structure and
+* programmatic tracks; the studio owns keyframe data persisted as a sidecar
+* document next to the scene module, merged at track granularity. Versioned
+* independently of the API (§7.4) — breaking it orphans users' files.
+*/
+var SidecarVersionError = class extends Error {
+	constructor(version) {
+		super(`unsupported sidecar version ${String(version)}; this build reads sidecarVersion 1`);
+		this.name = "SidecarVersionError";
+	}
+};
+function emptySidecar() {
+	return {
+		sidecarVersion: 1,
+		tracks: []
+	};
+}
+/**
+* Editor-edit normalization (§2.7 invariant): a spring-eased key's t is
+* intrinsic — prev.t + spring.duration(cfg) — so after any retime, sort and
+* re-pin spring keys to their predecessors. Dragging a spring key itself
+* therefore snaps back; retiming its predecessor carries it along. Returns a
+* new array. Colliding keys are NUDGED apart (+1ms), never deleted — an
+* editor must not silently destroy keyframe data on an exact-t collision.
+*/
+function normalizeEditedKeys(keys) {
+	const out = keys.map((k) => ({ ...k })).sort((a, b) => a.t - b.t);
+	for (let pass = 0; pass < 2; pass++) {
+		for (let i = 1; i < out.length; i++) {
+			const ease = out[i].ease;
+			if (ease && typeof ease === "object" && ease.kind === "spring") out[i].t = out[i - 1].t + spring.duration(ease);
+		}
+		out.sort((a, b) => a.t - b.t);
+	}
+	for (let i = 1; i < out.length; i++) if (out[i].t <= out[i - 1].t) out[i].t = out[i - 1].t + .001;
+	return out;
+}
+/**
+* Merge rules (§6.2, schema-drift resolution):
+* - a sidecar track whose target exists in code REPLACES that track's keys
+*   (the editor owns it; `editable` is preserved on the result);
+* - a sidecar track with no code counterpart is ADDED (editor-created track);
+* - sidecar tracks targeting nothing the scene can bind fail later at
+*   bindTimeline with UnboundTargetError — surfaced, never silently dropped;
+* - code tracks without sidecar counterparts pass through untouched.
+* The input documents are not mutated.
+*/
+function mergeSidecar(code, sidecar) {
+	if (!sidecar) return code;
+	if (sidecar.sidecarVersion !== 1) throw new SidecarVersionError(sidecar.sidecarVersion);
+	const overlay = new Map(sidecar.tracks.map((t) => [t.target, t]));
+	const tracks = code.tracks.map((t) => {
+		const replacement = overlay.get(t.target);
+		if (!replacement) return t;
+		overlay.delete(t.target);
+		return {
+			...t,
+			keys: replacement.keys.map((k) => ({ ...k })),
+			editable: true
+		};
+	});
+	for (const added of overlay.values()) tracks.push({
+		...added,
+		keys: added.keys.map((k) => ({ ...k })),
+		editable: true
+	});
+	const merged = {
+		...code,
+		tracks
+	};
+	if (sidecar.labels && Object.keys(sidecar.labels).length > 0) merged.labels = {
+		...code.labels,
+		...sidecar.labels
+	};
+	return merged;
+}
+//#endregion
+export { BakeError, CircularDependencyError, ColorParseError, DEFAULT_EASE, PositionError, SidecarVersionError, TARGET_PATH, TimelineValidationError, TrackValidationError, UnboundTargetError, UnknownEasingError, UnknownValueTypeError, UnresolvableTargetError, ValueTypeInferenceError, WriteDuringEvaluationError, bake, bakeCheckpointed, beginReadPhase, bindTimeline, booleanType, buildTimeline, colorType, compileTimeline, computed, createPlayhead, cubicBezier, easings, emptySidecar, endReadPhase, evaluateAt, formatColor, getTimelineCallbacks, getValueType, inReadPhase, inferValueType, key, lerpColor, mergeSidecar, namedEasing, normalizeEditedKeys, numberType, oklabToRgba, parseColor, random, registerValueType, resolveEase, resolveTweenTarget, rgbaToOklab, sampleTrack, setDevWarning, signal, spring, springEasing, stringType, timeline, track, untracked, validateTrack, vec2Equals, vec2Signal, vec2Type };