coily 0.15.0 → 0.16.0

package/dist/{system-Br_cPnaN.js → system-WejqGkfv.js}

@@ -1,10 +1,10 @@
-import { a as RESOLVED, c as isNumber, i as State, l as isRecord, n as OverdampedSolver, o as invariant, r as UnderdampedSolver, s as isArray, t as CriticallyDampedSolver, u as isRecordOrArray } from "./solver-CVXOTDkZ.js";
+import { a as RESOLVED, c as isNumber, i as State, l as isRecord, n as OverdampedSolver, o as invariant, r as UnderdampedSolver, s as isArray, t as CriticallyDampedSolver, u as isRecordOrArray } from "./solver-CAXuxdKj.js";
 //#region src/flush-queue.ts
 /**
-* Defers callbacks while inside a batch or tick: `request` runs the
-* callback immediately at depth 0 and queues it — deduplicated — until
-* the outermost exit otherwise. Composite springs use it to coalesce
-* per-channel events into composite ones.
+* Defers callbacks while inside a batch or tick. At depth 0, `request`
+* runs the callback immediately. Otherwise it queues the callback, once
+* per callback, until the outermost exit. Composite springs use it to
+* merge per-channel events into composite ones.
 */
 var FlushQueue = class {
 	#callbacks = /* @__PURE__ */ new Set();
@@ -33,717 +33,224 @@ var FlushQueue = class {
 	}
 };
 //#endregion
-//#region src/config.ts
+//#region src/shape-tree.ts
+function joinPath(path, key) {
+	return path ? `${path}.${key}` : String(key);
+}
+function describePath(path) {
+	return path ? `'${path}'` : "the root";
+}
+/** The sentinel a resolver returns to descend into a node instead of covering it. */
+const BRANCH = Symbol("branch");
+/** The standard scatter leaf guard: partial numeric shapes take only finite numbers at channels. */
+function acceptNumber(input, path) {
+	invariant(isNumber(input) && Number.isFinite(input), () => `Expected a finite number for channel '${path}'`);
+	return input;
+}
 /**
-* Immutable, resolved spring parameters. Whatever `defineSpring` input
-* shape produced it, a config carries concrete `mass`, `tension`,
-* `damping`, and `precision`, plus the quantities derived from them.
-* Instances are frozen and safe to share between springs; to change a
-* spring's behavior, assign a new config via `spring.config`.
+* The canonical numeric `LeafParser`: finite-number leaves built through
+* `factory`, named "channels" in structural errors.
 */
-var SpringDefinition = class SpringDefinition {
-	/** The config for springs created without one: critically damped, settling in about 500ms. */
-	static default = new SpringDefinition({
-		dampingRatio: 1,
-		duration: 500
-	});
-	/** Mass of the moving value, as provided or derived. */
-	mass;
-	/** Spring stiffness, as provided or derived. */
-	tension;
-	/** Friction strength, as provided or derived. */
-	damping;
-	/** Decimal places of the resting threshold — see `restingMagnitude`. */
-	precision;
-	/**
-	* Velocity multiplier applied when the value crosses the target, as
-	* provided or resolved from its named form. 1 (`'passthrough'`) leaves
-	* the motion untouched, 0 (`'stop'`) ends it at the target, negative
-	* values rebound.
-	*/
-	arrival;
-	/** Oscillation rate with no damping: `sqrt(tension / mass)`, in radians per second. */
-	naturalFrequency;
-	/** The damping at which bounce disappears: `2 * mass * naturalFrequency`. */
-	criticalDamping;
-	/**
-	* `damping / criticalDamping`. Below 1 the spring overshoots and
-	* bounces, at 1 it settles fastest without overshooting, above 1 it
-	* settles slower.
-	*/
-	dampingRatio;
-	/** Resting threshold in value units: half a unit in the last `precision` place. */
-	restingMagnitude;
-	constructor(input) {
-		const raw = input;
-		const mass = raw.mass;
-		const tension = raw.tension;
-		const damping = raw.damping;
-		const bounce = raw.bounce;
-		const duration = raw.duration !== void 0 ? raw.duration / 1e3 : void 0;
-		const displacement = raw.displacement ?? 1;
-		const precision = raw.precision ?? 2;
-		const arrival = raw.arrival;
-		for (const key of Object.keys(raw)) {
-			if (key === "arrival") continue;
-			const value = raw[key];
-			if (value !== void 0) invariant(Number.isFinite(value), () => `Invalid ${key}: expected a finite number`);
-		}
-		if (mass !== void 0) invariant(mass > 0, "Mass must be greater than 0");
-		if (tension !== void 0) invariant(tension > 0, "Tension must be greater than 0");
-		if (damping !== void 0) invariant(damping >= 0, "Damping must be greater than or equal to 0");
-		if (bounce !== void 0) invariant(bounce >= -1 && bounce <= 1, "Bounce must be between -1 and 1");
-		invariant(raw.dampingRatio === void 0 || bounce === void 0, "Provide either dampingRatio or bounce, not both");
-		const dampingRatio = raw.dampingRatio ?? (bounce !== void 0 ? Math.max(1e-4, 1 - bounce) : void 0);
-		if (dampingRatio !== void 0) invariant(dampingRatio >= 0, "Damping ratio must be greater than or equal to 0");
-		if (duration !== void 0) invariant(duration > 0, "Duration must be greater than 0");
-		invariant(displacement !== 0, "Displacement must not be 0");
-		invariant(precision >= 0, "Precision must be greater than or equal to 0");
-		invariant(arrival === void 0 || arrival === "passthrough" || arrival === "stop" || typeof arrival === "number" && Number.isFinite(arrival) && arrival >= -1 && arrival <= 1, "Arrival must be 'passthrough', 'stop', or a number between -1 and 1");
-		this.precision = precision;
-		this.restingMagnitude = .5 / 10 ** precision;
-		if (arrival === void 0 || arrival === "passthrough") this.arrival = 1;
-		else if (arrival === "stop") this.arrival = 0;
-		else this.arrival = arrival === 0 ? 0 : arrival;
-		const hasM = mass !== void 0;
-		const hasK = tension !== void 0;
-		const hasC = damping !== void 0;
-		const hasZ = dampingRatio !== void 0;
-		const hasT = duration !== void 0;
-		if (hasK && hasC && !hasZ && !hasT) {
-			this.mass = mass ?? 1;
-			this.tension = tension;
-			this.damping = damping;
-		} else if (hasK && hasZ && !hasC && !hasT) {
-			this.mass = mass ?? 1;
-			this.tension = tension;
-			this.damping = 2 * dampingRatio * Math.sqrt(this.mass * tension);
-		} else if (hasC && hasZ && !hasK && !hasT) {
-			invariant(dampingRatio > 0, "dampingRatio must be > 0 to derive tension");
-			this.mass = mass ?? 1;
-			this.tension = damping ** 2 / (4 * dampingRatio ** 2 * this.mass);
-			this.damping = damping;
-		} else if (hasK && hasC && hasZ && !hasT) {
-			invariant(!hasM, "mass is derived when tension, damping, and dampingRatio are all provided");
-			invariant(dampingRatio > 0, "dampingRatio must be > 0 to derive mass");
-			this.mass = damping ** 2 / (4 * dampingRatio ** 2 * tension);
-			this.tension = tension;
-			this.damping = damping;
-		} else if (hasZ && hasT) {
-			const threshold = .005;
-			const x0 = Math.abs(displacement);
-			invariant(x0 > threshold, "displacement must be greater than the precision threshold");
-			invariant(dampingRatio > 0, "dampingRatio must be > 0 for duration-based config");
-			const wn = restUnits(dampingRatio, x0 / threshold) / duration;
-			if (!hasK && !hasC) {
-				this.mass = mass ?? 1;
-				this.tension = wn ** 2 * this.mass;
-				this.damping = 2 * dampingRatio * this.mass * wn;
-			} else if (hasK && !hasC) {
-				invariant(!hasM, "mass is derived in duration-based configs with tension");
-				this.mass = tension / wn ** 2;
-				this.tension = tension;
-				this.damping = 2 * dampingRatio * this.mass * wn;
-			} else if (hasC && !hasK) {
-				invariant(!hasM, "mass is derived in duration-based configs with damping");
-				this.mass = damping / (2 * dampingRatio * wn);
-				this.tension = wn ** 2 * this.mass;
-				this.damping = damping;
-			} else throw new Error("Invalid spring config: provide one of the supported input shapes.");
-		} else throw new Error("Invalid spring config: provide one of the supported input shapes.");
-		this.naturalFrequency = Math.sqrt(this.tension / this.mass);
-		this.criticalDamping = 2 * this.mass * this.naturalFrequency;
-		this.dampingRatio = this.damping / this.criticalDamping;
-		Object.freeze(this);
+function channelParser(factory) {
+	return {
+		match(value, path) {
+			if (!isNumber(value)) return void 0;
+			invariant(Number.isFinite(value), () => `Invalid value at '${path}': channel values must be finite`);
+			return factory(value, path);
+		},
+		mismatch: (path) => `Invalid value at '${path}': expected a number or a nested shape of numbers`,
+		empty: (path) => `Invalid value at ${describePath(path)}: a shape must contain at least one channel`
+	};
+}
+var LeafNode = class LeafNode {
+	path;
+	leaf;
+	constructor(leaf, path) {
+		this.path = path;
+		this.leaf = leaf;
 	}
-	/**
-	* Computes when a spring with this config comes to rest from `state`,
-	* in ms.
-	*
-	* The time is solved from the motion's decay bound rather than
-	* estimated: the spring is resting at the first tick at or after it.
-	* An underdamped spring can also rest earlier — its rest amplitude
-	* pulses, and a frame that samples a dip inside the resting threshold
-	* rests there — so read the value as "no later than", tight in
-	* practice. See
-	* https://github.com/tkofh/coily/blob/main/PRECISION.md.
-	*
-	* Returns 0 when `state` is already inside the resting threshold.
-	* Returns Infinity when the motion never settles: a `dampingRatio` of
-	* 0 whose `arrival` neither stops nor slows it. When `arrival` is 0
-	* the result is capped at the first target crossing, where such a
-	* spring rests exactly; other multipliers fold their per-crossing
-	* velocity loss into the time.
-	*/
-	computeTimeRemaining(state) {
-		const { position, velocity } = state;
-		if (Math.abs(position) + Math.abs(velocity) / this.naturalFrequency <= this.restingMagnitude) return 0;
-		const crossing = this.arrival === 0 ? firstCrossing(this, position, velocity) * 1e3 : Infinity;
-		return Math.min(restTime(this, position, velocity) * 1e3, crossing);
+	mirror(read, slots, carrier, key) {
+		carrier[key] = read(this.leaf);
+		slots.push({
+			leaf: this.leaf,
+			key,
+			carrier
+		});
+	}
+	scatter(input, accept, apply) {
+		const value = accept(input, this.path);
+		if (apply !== null) apply(this.leaf, value);
+	}
+	zip(theirs, fn) {
+		invariant(theirs instanceof LeafNode, () => `Shape mismatch at ${describePath(this.path)}`);
+		if (fn !== null) fn(this.leaf, theirs.leaf);
+	}
+	broadcast(input, resolve, apply, _label) {
+		const resolved = resolve(input, this.path);
+		invariant(resolved !== BRANCH, `Cannot descend into channel '${this.path}'`);
+		if (apply !== null) apply(this.leaf, resolved);
+	}
+	cover(value, apply) {
+		apply(this.leaf, value);
 	}
 };
-function solveEntry(f, threshold, peak) {
-	let low = 0;
-	let high = Math.max(peak, 1e-6);
-	while (f(high) > threshold) {
-		low = high;
-		high *= 2;
+var ListNode = class ListNode {
+	path;
+	children;
+	constructor(children, path) {
+		this.path = path;
+		this.children = children;
 	}
-	for (let i = 0; i < 60; i++) {
-		const mid = (low + high) / 2;
-		if (f(mid) > threshold) low = mid;
-		else high = mid;
+	mirror(read, slots, carrier, key) {
+		const mine = [];
+		carrier[key] = mine;
+		const slotcarrier = mine;
+		for (let i = 0; i < this.children.length; i++) this.children[i].mirror(read, slots, slotcarrier, i);
 	}
-	return high;
-}
-function restTime(config, position, velocity) {
-	const { naturalFrequency, dampingRatio, restingMagnitude, arrival } = config;
-	if (dampingRatio < 1) {
-		const sigma = dampingRatio * naturalFrequency;
-		const wd = naturalFrequency * Math.sqrt(1 - dampingRatio ** 2);
-		const R = Math.hypot(position, (velocity + sigma * position) / wd);
-		const drop = Math.log(R * Math.sqrt(2 + 2 * dampingRatio) / restingMagnitude);
-		const plain = sigma > 0 ? drop / sigma : Infinity;
-		const strength = Math.abs(arrival);
-		if (strength === 0 || strength === 1) return plain;
-		const first = firstCrossing(config, position, velocity);
-		if (plain <= first) return plain;
-		const loss = -Math.log(strength) * wd / Math.PI;
-		return (drop + loss * first) / (sigma + loss);
+	scatter(input, accept, apply) {
+		invariant(isArray(input), () => `Expected an array at ${describePath(this.path)}`);
+		invariant(input.length <= this.children.length, `Unknown channel '${joinPath(this.path, this.children.length)}'`);
+		for (let i = 0; i < input.length; i++) {
+			if (input[i] === void 0) continue;
+			this.children[i].scatter(input[i], accept, apply);
+		}
 	}
-	if (dampingRatio === 1) {
-		const a0 = Math.abs(position) + Math.abs(velocity) / naturalFrequency;
-		const beta = 2 * Math.abs(velocity + naturalFrequency * position);
-		return solveEntry((t) => Math.exp(-naturalFrequency * t) * (a0 + beta * t), restingMagnitude, beta > 0 ? Math.max(0, 1 / naturalFrequency - a0 / beta) : 0);
+	zip(theirs, fn) {
+		invariant(theirs instanceof ListNode && theirs.children.length === this.children.length, () => `Shape mismatch at ${describePath(this.path)}`);
+		for (let i = 0; i < this.children.length; i++) this.children[i].zip(theirs.children[i], fn);
 	}
-	const wd = naturalFrequency * Math.sqrt(dampingRatio ** 2 - 1);
-	const slow = dampingRatio * naturalFrequency - wd;
-	const fast = dampingRatio * naturalFrequency + wd;
-	const slowAmplitude = Math.abs(velocity + fast * position) / (2 * wd) * (1 + slow / naturalFrequency);
-	const fastAmplitude = Math.abs(velocity + slow * position) / (2 * wd) * (1 + fast / naturalFrequency);
-	return solveEntry((t) => slowAmplitude * Math.exp(-slow * t) + fastAmplitude * Math.exp(-fast * t), restingMagnitude, 0);
-}
-function restUnits(dampingRatio, ratio) {
-	if (dampingRatio < 1) return Math.log(ratio * Math.sqrt(2 / (1 - dampingRatio))) / dampingRatio;
-	if (dampingRatio === 1) return solveEntry((u) => Math.exp(-u) * (1 + 2 * u), 1 / ratio, .5);
-	const wd = Math.sqrt(dampingRatio ** 2 - 1);
-	const slow = dampingRatio - wd;
-	const fast = dampingRatio + wd;
-	const slowAmplitude = fast / (2 * wd) * (1 + slow);
-	const fastAmplitude = slow / (2 * wd) * (1 + fast);
-	return solveEntry((u) => slowAmplitude * Math.exp(-slow * u) + fastAmplitude * Math.exp(-fast * u), 1 / ratio, 0);
-}
-function firstCrossing(config, position, velocity) {
-	const { naturalFrequency, dampingRatio } = config;
-	if (dampingRatio < 1) {
-		const wd = naturalFrequency * Math.sqrt(1 - dampingRatio ** 2);
-		const c2 = (velocity + dampingRatio * naturalFrequency * position) / wd;
-		let theta = Math.atan2(-position, c2) % Math.PI;
-		if (theta <= 0) theta += Math.PI;
-		return theta / wd;
+	broadcast(input, resolve, apply, label) {
+		const resolved = resolve(input, this.path);
+		if (resolved !== BRANCH) {
+			if (apply !== null) this.cover(resolved, apply);
+			return;
+		}
+		invariant(isArray(input), () => `Expected an array at ${describePath(this.path)} in ${label}`);
+		invariant(input.length <= this.children.length, () => `Unknown channel '${joinPath(this.path, this.children.length)}' in ${label}`);
+		for (let i = 0; i < input.length; i++) {
+			if (input[i] === void 0) continue;
+			this.children[i].broadcast(input[i], resolve, apply, label);
+		}
 	}
-	if (dampingRatio === 1) {
-		const t = -position / (velocity + naturalFrequency * position);
-		return t > 0 ? t : Infinity;
-	}
-	const wd = naturalFrequency * Math.sqrt(dampingRatio ** 2 - 1);
-	const theta = Math.atanh(-position * wd / (velocity + dampingRatio * naturalFrequency * position));
-	return theta > 0 ? theta / wd : Infinity;
-}
-function defineSpring(input) {
-	return new SpringDefinition(input);
-}
-//#endregion
-//#region src/emitter.ts
-/** Minimal fixed-event emitter behind motions and composite springs. */
-var Emitter = class {
-	#update = [];
-	#start = [];
-	#stop = [];
-	#dispose = [];
-	on(type, handler) {
-		this.#list(type).push(handler);
-		return () => {
-			this.off(type, handler);
-		};
-	}
-	off(type, handler) {
-		const list = this.#list(type);
-		if (handler) list.splice(list.indexOf(handler) >>> 0, 1);
-		else list.length = 0;
-	}
-	clear() {
-		this.#update.length = 0;
-		this.#start.length = 0;
-		this.#stop.length = 0;
-		this.#dispose.length = 0;
-	}
-	emit(type) {
-		const list = this.#list(type);
-		if (list.length === 1) list[0]();
-		else if (list.length > 1) for (const handler of list.slice()) handler();
-	}
-	#list(type) {
-		switch (type) {
-			case "update": return this.#update;
-			case "start": return this.#start;
-			case "stop": return this.#stop;
-			case "dispose": return this.#dispose;
-		}
+	cover(value, apply) {
+		for (const child of this.children) child.cover(value, apply);
 	}
 };
-//#endregion
-//#region src/motion.ts
-let nextMotionId = 0;
-/**
-* One spring simulation in displacement space: position is measured from
-* the target (0 means settled), so retargeting is a rebase performed by
-* the owning `Spring`. Picks the closed-form solver for the config's
-* damping regime and emits update/start/stop/dispose events.
-*/
-var Motion = class {
-	/** Monotone creation id: breaks ties wherever motions need a deterministic order. */
-	_id = nextMotionId++;
-	/** Tick-pass marker written by `MotionSet` so a motion re-added mid-pass isn't ticked twice. */
-	_pass = 0;
-	/**
-	* Frame marker written by `MotionSet`: sub-steps share one frame, and
-	* the first advance in it queues the motion for the settle sweep.
-	*/
-	_frame = 0;
-	/**
-	* Dependency rank written by `FollowGraph`: motions the follow graph
-	* touches count up from 0, leaders before followers; -1 marks a motion
-	* outside the graph.
-	*/
-	_rank = -1;
-	/**
-	* The edge this motion follows through, or null. Written by
-	* `FollowGraph` on edge add/remove so the tick's hot loop reads a
-	* field instead of a map.
-	*/
-	_edge = null;
-	/**
-	* A first-order-hold ramp slope in value units per second, armed by a
-	* ramped `recouple` immediately before the `_advance` that consumes
-	* it (read-and-clear; no user code runs between the two). 0 means the
-	* target holds still across the step — every path but a ramped
-	* recouple.
-	*/
-	_ramp = 0;
-	/**
-	* The edges reading this motion, or null when none. Written by
-	* `FollowGraph` with the rank cache, so it can lag a mid-pass edge
-	* change until the next recompute; the tick tolerates stale entries.
-	*/
-	_followers = null;
-	respectsReducedMotion = true;
-	#config;
-	#state;
-	#underdampedSolver = null;
-	#criticallyDampedSolver = null;
-	#overdampedSolver = null;
-	#currentSolver = null;
-	#needsUpdate = false;
-	#needsReset = false;
-	#running;
-	#emitter;
-	constructor(config, position, velocity) {
-		this.#config = config;
-		this.#state = new State(config, position, velocity);
-		this.#emitter = new Emitter();
-		this.#running = !this.#state.isResting;
-		this.#updateSolver();
-	}
-	get position() {
-		return this.#state.position;
-	}
-	set position(value) {
-		this.#state.position = value;
-		this.#needsReset = true;
-		this.#syncStart();
-	}
-	get velocity() {
-		return this.#state.velocity;
-	}
-	set velocity(value) {
-		this.#state.velocity = value;
-		this.#needsReset = true;
-		this.#syncStart();
-	}
-	get timeRemaining() {
-		return this.#config.computeTimeRemaining(this.#state);
+var RecordNode = class RecordNode {
+	path;
+	children;
+	constructor(children, path) {
+		this.path = path;
+		this.children = children;
 	}
-	get isResting() {
-		return this.#state.isResting;
+	mirror(read, slots, carrier, key) {
+		const mine = {};
+		carrier[key] = mine;
+		for (const [childKey, child] of this.children) child.mirror(read, slots, mine, childKey);
 	}
-	configure(config) {
-		this.#config = config;
-		this.#state.configure(config);
-		this.#needsUpdate = true;
-		this.#syncStart();
+	scatter(input, accept, apply) {
+		invariant(isRecord(input), () => `Expected an object at ${describePath(this.path)}`);
+		for (const key of Object.keys(input)) {
+			const value = input[key];
+			if (value === void 0) continue;
+			const child = this.children.get(key);
+			invariant(child !== void 0, () => `Unknown channel '${joinPath(this.path, key)}'`);
+			child.scatter(value, accept, apply);
+		}
 	}
-	tick(dt, emit = true) {
-		this._advance(dt);
-		if (emit) this._settleFrame();
-		else this.#reconcileRunning();
+	zip(theirs, fn) {
+		invariant(theirs instanceof RecordNode && theirs.children.size === this.children.size, () => `Shape mismatch at ${describePath(this.path)}`);
+		for (const [key, child] of this.children) {
+			const their = theirs.children.get(key);
+			invariant(their !== void 0, () => `Shape mismatch at ${describePath(this.path)}`);
+			child.zip(their, fn);
+		}
 	}
-	/**
-	* Advances the simulation and emits nothing. The tick pass advances
-	* every motion through this, then delivers the frame's events with
-	* `_settleFrame`; the synchronous `tick` wraps the two.
-	*
-	* A pending `_ramp` integrates the step against a target moving at
-	* that slope instead of holding still: one affine transform around
-	* the unchanged solver. With the target at `p(t) = p0 + g*t`, the
-	* displacement u = x - p(t) obeys the homogeneous equation shifted by
-	* the constant u_ss = -(2*zeta/wn)*g = -(damping/tension)*g, so the
-	* solver ticks w = u - u_ss exactly and the results shift back.
-	* Measuring u from the moving target makes the ramp endpoint and the
-	* new target coincide — the armer assigns the target, no rebase
-	* arithmetic exists. The ramp is an argument of the step, never
-	* persistent solver state: g = 0 takes the plain step below, so a
-	* motion that never ramps steps bit-exactly like an isolated spring.
-	*/
-	_advance(dt) {
-		invariant(this.#currentSolver, "Cannot tick a disposed motion");
-		const g = this._ramp;
-		if (g !== 0) {
-			this._ramp = 0;
-			const state = this.#state;
-			const shift = this.#config.damping / this.#config.tension * g;
-			state.position += shift;
-			state.velocity -= g;
-			if (this.#needsUpdate) {
-				this.#updateSolver();
-				this.#needsUpdate = false;
-			} else this.#currentSolver.configure();
-			this.#currentSolver.tick(dt);
-			state.position -= shift;
-			state.velocity += g;
-			this.#needsReset = true;
-			if (state.isResting) {
-				state.position = 0;
-				state.velocity = 0;
-			}
+	broadcast(input, resolve, apply, label) {
+		const resolved = resolve(input, this.path);
+		if (resolved !== BRANCH) {
+			if (apply !== null) this.cover(resolved, apply);
 			return;
 		}
-		if (this.#needsUpdate) {
-			this.#updateSolver();
-			this.#needsUpdate = false;
-			this.#needsReset = false;
-		} else if (this.#needsReset) {
-			this.#currentSolver.configure();
-			this.#needsReset = false;
-		}
-		this.#currentSolver.tick(dt);
-		if (this.#state.isResting) {
-			this.#state.position = 0;
-			this.#state.velocity = 0;
-			this.#needsReset = true;
-		}
-	}
-	/**
-	* Emits the frame's `update`, then reconciles `stop`/`start`. The tick
-	* pass calls this in dependency order after every motion has advanced,
-	* so update callbacks read frame-final values everywhere.
-	*/
-	_settleFrame() {
-		this.#emitter.emit("update");
-		this.#reconcileRunning();
-	}
-	#reconcileRunning() {
-		if (this.#state.isResting) {
-			if (this.#running) {
-				this.#running = false;
-				this.#emitter.emit("stop");
-			}
-		} else if (!this.#running) {
-			this.#running = true;
-			this.#emitter.emit("start");
+		invariant(isRecord(input), () => `Expected an object at ${describePath(this.path)} in ${label}`);
+		for (const key of Object.keys(input)) {
+			const value = input[key];
+			if (value === void 0) continue;
+			const child = this.children.get(key);
+			invariant(child !== void 0, () => `Unknown channel '${joinPath(this.path, key)}' in ${label}`);
+			child.broadcast(value, resolve, apply, label);
 		}
 	}
-	finish() {
-		this.position = 0;
-		this.velocity = 0;
-		this.tick(0);
-	}
-	/**
-	* The sub-step controller's shock signal, read by a follower's `plan`
-	* with this motion as its leader: deviation from the quasi-steady
-	* tracking manifold x = -(damping/tension) * v, where damping/tension
-	* is 2*zeta/wn. Near zero while chasing any smoothly moving target at
-	* any speed; the full displacement after a target teleport;
-	* (damping/tension) * |v| after a fling.
-	*/
-	_manifoldDeviation() {
-		const config = this.#config;
-		return Math.abs(this.#state.position + config.damping / config.tension * this.#state.velocity);
+	cover(value, apply) {
+		for (const child of this.children.values()) child.cover(value, apply);
 	}
-	/** Acceleration from current state, for `plan`'s kinematic bound on a shock frame. */
-	_acceleration() {
-		const config = this.#config;
-		return -(config.tension * this.#state.position + config.damping * this.#state.velocity) / config.mass;
+};
+/**
+* A shape parsed into a node tree, paired with its leaves flattened in
+* depth-first shape order. `parser.match` decides leaf or branch at every
+* position below the root. The root must already be a container, which
+* callers validate with their own message. Nested non-containers and
+* empty nodes throw through `parser.mismatch` and `parser.empty`.
+*
+* Traversals run through `root`, and `new ShapeView(root, read)` makes a
+* live view.
+*/
+var ShapeTree = class {
+	root;
+	leaves;
+	constructor(shape, parser) {
+		const leaves = [];
+		this.root = buildContainer(shape, "", parser, leaves);
+		this.leaves = leaves;
 	}
-	onUpdate(callback) {
-		return this.#emitter.on("update", callback);
+};
+function buildContainer(shape, path, parser, leaves) {
+	if (isArray(shape)) {
+		invariant(shape.length > 0, () => parser.empty(path));
+		return new ListNode(shape.map((child, i) => buildChild(child, joinPath(path, i), parser, leaves)), path);
 	}
-	onStart(callback) {
-		return this.#emitter.on("start", callback);
+	const keys = Object.keys(shape);
+	invariant(keys.length > 0, () => parser.empty(path));
+	const children = /* @__PURE__ */ new Map();
+	for (const key of keys) children.set(key, buildChild(shape[key], joinPath(path, key), parser, leaves));
+	return new RecordNode(children, path);
+}
+function buildChild(value, path, parser, leaves) {
+	const leaf = parser.match(value, path);
+	if (leaf !== void 0) {
+		leaves.push(leaf);
+		return new LeafNode(leaf, path);
 	}
-	onStop(callback) {
-		return this.#emitter.on("stop", callback);
+	invariant(isRecordOrArray(value), () => parser.mismatch(path));
+	return buildContainer(value, path, parser, leaves);
+}
+/**
+* A live view of a shape: `read(leaf)` at every leaf, mirrored into a stable
+* object. `refresh` rewrites the values in place through slots recorded at
+* construction, so per-frame reads do no traversal or allocation.
+*/
+var ShapeView = class {
+	root;
+	#read;
+	#slots = [];
+	constructor(root, read) {
+		this.#read = read;
+		const scratch = {};
+		root.mirror(read, this.#slots, scratch, "root");
+		this.root = scratch["root"];
 	}
-	onDispose(callback) {
-		return this.#emitter.on("dispose", callback);
-	}
-	dispose() {
-		this.#emitter.emit("dispose");
-		this.#emitter.clear();
-		this.#underdampedSolver = null;
-		this.#criticallyDampedSolver = null;
-		this.#overdampedSolver = null;
-		this.#currentSolver = null;
-	}
-	#syncStart() {
-		if (!this.#running && !this.#state.isResting) {
-			this.#running = true;
-			this.#emitter.emit("start");
-		}
-	}
-	#updateSolver() {
-		if (this.#config.dampingRatio < 1) {
-			this.#underdampedSolver ||= new UnderdampedSolver(this.#state);
-			this.#currentSolver = this.#underdampedSolver;
-		} else if (this.#config.dampingRatio === 1) {
-			this.#criticallyDampedSolver ||= new CriticallyDampedSolver(this.#state);
-			this.#currentSolver = this.#criticallyDampedSolver;
-		} else {
-			this.#overdampedSolver ||= new OverdampedSolver(this.#state);
-			this.#currentSolver = this.#overdampedSolver;
-		}
-		this.#currentSolver.configure(this.#config);
-	}
-};
-//#endregion
-//#region src/shape-tree.ts
-function joinPath(path, key) {
-	return path ? `${path}.${key}` : String(key);
-}
-function describePath(path) {
-	return path ? `'${path}'` : "the root";
-}
-/** The sentinel a resolver returns to descend into a node instead of covering it. */
-const BRANCH = Symbol("branch");
-/** The standard scatter leaf guard: partial numeric shapes take only finite numbers at channels. */
-function acceptNumber(input, path) {
-	invariant(isNumber(input) && Number.isFinite(input), () => `Expected a finite number for channel '${path}'`);
-	return input;
-}
-/**
-* The canonical numeric `LeafParser`: finite-number leaves built through
-* `factory`, named "channels" in structural errors. The default for value
-* shapes, whose leaves are all numbers.
-*/
-function channelParser(factory) {
-	return {
-		match(value, path) {
-			if (!isNumber(value)) return void 0;
-			invariant(Number.isFinite(value), () => `Invalid value at '${path}': channel values must be finite`);
-			return factory(value, path);
-		},
-		mismatch: (path) => `Invalid value at '${path}': expected a number or a nested shape of numbers`,
-		empty: (path) => `Invalid value at ${describePath(path)}: a shape must contain at least one channel`
-	};
-}
-var LeafNode = class LeafNode {
-	path;
-	leaf;
-	constructor(leaf, path) {
-		this.path = path;
-		this.leaf = leaf;
-	}
-	mirror(read, slots, carrier, key) {
-		carrier[key] = read(this.leaf);
-		slots.push({
-			leaf: this.leaf,
-			key,
-			carrier
-		});
-	}
-	scatter(input, accept, apply) {
-		apply(this.leaf, accept(input, this.path));
-	}
-	zip(theirs, fn) {
-		invariant(theirs instanceof LeafNode, () => `Shape mismatch at ${describePath(this.path)}`);
-		fn(this.leaf, theirs.leaf);
-	}
-	broadcast(input, resolve, apply, _label) {
-		const resolved = resolve(input, this.path);
-		invariant(resolved !== BRANCH, `Cannot descend into channel '${this.path}'`);
-		apply(this.leaf, resolved);
-	}
-	cover(value, apply) {
-		apply(this.leaf, value);
-	}
-};
-var ListNode = class ListNode {
-	path;
-	children;
-	constructor(children, path) {
-		this.path = path;
-		this.children = children;
-	}
-	mirror(read, slots, carrier, key) {
-		const mine = [];
-		carrier[key] = mine;
-		const slotcarrier = mine;
-		for (let i = 0; i < this.children.length; i++) this.children[i].mirror(read, slots, slotcarrier, i);
-	}
-	scatter(input, accept, apply) {
-		invariant(isArray(input), () => `Expected an array at ${describePath(this.path)}`);
-		invariant(input.length <= this.children.length, `Unknown channel '${joinPath(this.path, this.children.length)}'`);
-		for (let i = 0; i < input.length; i++) {
-			if (input[i] === void 0) continue;
-			this.children[i].scatter(input[i], accept, apply);
-		}
-	}
-	zip(theirs, fn) {
-		invariant(theirs instanceof ListNode && theirs.children.length === this.children.length, () => `Shape mismatch at ${describePath(this.path)}`);
-		for (let i = 0; i < this.children.length; i++) this.children[i].zip(theirs.children[i], fn);
-	}
-	broadcast(input, resolve, apply, label) {
-		const resolved = resolve(input, this.path);
-		if (resolved !== BRANCH) {
-			this.cover(resolved, apply);
-			return;
-		}
-		invariant(isArray(input), () => `Expected an array at ${describePath(this.path)} in ${label}`);
-		invariant(input.length <= this.children.length, () => `Unknown channel '${joinPath(this.path, this.children.length)}' in ${label}`);
-		for (let i = 0; i < input.length; i++) {
-			if (input[i] === void 0) continue;
-			this.children[i].broadcast(input[i], resolve, apply, label);
-		}
-	}
-	cover(value, apply) {
-		for (const child of this.children) child.cover(value, apply);
-	}
-};
-var RecordNode = class RecordNode {
-	path;
-	children;
-	constructor(children, path) {
-		this.path = path;
-		this.children = children;
-	}
-	mirror(read, slots, carrier, key) {
-		const mine = {};
-		carrier[key] = mine;
-		for (const [childKey, child] of this.children) child.mirror(read, slots, mine, childKey);
-	}
-	scatter(input, accept, apply) {
-		invariant(isRecord(input), () => `Expected an object at ${describePath(this.path)}`);
-		for (const key of Object.keys(input)) {
-			const value = input[key];
-			if (value === void 0) continue;
-			const child = this.children.get(key);
-			invariant(child !== void 0, () => `Unknown channel '${joinPath(this.path, key)}'`);
-			child.scatter(value, accept, apply);
-		}
-	}
-	zip(theirs, fn) {
-		invariant(theirs instanceof RecordNode && theirs.children.size === this.children.size, () => `Shape mismatch at ${describePath(this.path)}`);
-		for (const [key, child] of this.children) {
-			const their = theirs.children.get(key);
-			invariant(their !== void 0, () => `Shape mismatch at ${describePath(this.path)}`);
-			child.zip(their, fn);
-		}
-	}
-	broadcast(input, resolve, apply, label) {
-		const resolved = resolve(input, this.path);
-		if (resolved !== BRANCH) {
-			this.cover(resolved, apply);
-			return;
-		}
-		invariant(isRecord(input), () => `Expected an object at ${describePath(this.path)} in ${label}`);
-		for (const key of Object.keys(input)) {
-			const value = input[key];
-			if (value === void 0) continue;
-			const child = this.children.get(key);
-			invariant(child !== void 0, () => `Unknown channel '${joinPath(this.path, key)}' in ${label}`);
-			child.broadcast(value, resolve, apply, label);
-		}
-	}
-	cover(value, apply) {
-		for (const child of this.children.values()) child.cover(value, apply);
-	}
-};
-/**
-* A shape parsed into a node tree, paired with its leaves flattened in
-* depth-first shape order. `parser.match` decides leaf vs branch at every
-* position; the root must already be a container — callers validate that
-* (with their own message) before building. Nested non-containers and
-* empty nodes throw through `parser.mismatch`/`parser.empty`.
-*
-* Holds no behavior of its own: traversals run through `root`, and a live
-* view comes from `new ShapeView(root, read)`.
-*/
-var ShapeTree = class {
-	root;
-	leaves;
-	constructor(shape, parser) {
-		const leaves = [];
-		this.root = buildContainer(shape, "", parser, leaves);
-		this.leaves = leaves;
-	}
-};
-function buildContainer(shape, path, parser, leaves) {
-	if (isArray(shape)) {
-		invariant(shape.length > 0, () => parser.empty(path));
-		return new ListNode(shape.map((child, i) => buildChild(child, joinPath(path, i), parser, leaves)), path);
-	}
-	const keys = Object.keys(shape);
-	invariant(keys.length > 0, () => parser.empty(path));
-	const children = /* @__PURE__ */ new Map();
-	for (const key of keys) children.set(key, buildChild(shape[key], joinPath(path, key), parser, leaves));
-	return new RecordNode(children, path);
-}
-function buildChild(value, path, parser, leaves) {
-	const leaf = parser.match(value, path);
-	if (leaf !== void 0) {
-		leaves.push(leaf);
-		return new LeafNode(leaf, path);
-	}
-	invariant(isRecordOrArray(value), () => parser.mismatch(path));
-	return buildContainer(value, path, parser, leaves);
-}
-/**
-* A live view of a shape: `read(leaf)` at every leaf, mirrored into a stable
-* object — `refresh` rewrites the values in place through slots recorded at
-* construction, so per-frame reads do no traversal or allocation.
-*/
-var ShapeView = class {
-	root;
-	#read;
-	#slots = [];
-	constructor(root, read) {
-		this.#read = read;
-		const scratch = {};
-		root.mirror(read, this.#slots, scratch, "root");
-		this.root = scratch["root"];
-	}
-	/** Re-reads every leaf into the view. */
-	refresh() {
-		for (const slot of this.#slots) slot.carrier[slot.key] = this.#read(slot.leaf);
+	/** Re-reads every leaf into the view. */
+	refresh() {
+		for (const slot of this.#slots) slot.carrier[slot.key] = this.#read(slot.leaf);
 	}
 };
 //#endregion
 //#region src/spring-source.ts
 /**
-* The property key that brands a `SpringSource` and holds the channel its
-* followers read. A registry symbol (`Symbol.for('coily/spring-source')`),
-* so sources from one copy of coily are recognized by another when a
-* bundle duplicates the library.
+* The property key that brands a `SpringSource` and holds the api its
+* followers read. It is a registry symbol
+* (`Symbol.for('coily/spring-source')`), so one copy of coily
+* recognizes sources from another when a bundle duplicates the library.
 */
 const SpringSourceSymbol = Symbol.for("coily/spring-source");
 function isSpringSource(value) {
@@ -756,9 +263,9 @@ function recipeOf(source) {
 }
 /**
 * Registers a derived source's recipe. Every source built on other
-* sources must register at creation: `mapSpring` composition and
+* sources must register at creation. `mapSpring` composition and
 * `resolveLeaderMotions` both reach a derivation's roots through the
-* registry rather than through the wrapper object.
+* registry, not through the wrapper object.
 */
 function registerRecipe(source, recipe) {
 	RECIPES.set(source, recipe);
@@ -773,10 +280,8 @@ function sourceMismatch(path) {
 }
 /**
 * Parses a shape of sources into a live view, collecting subscription
-* roots along the way (a mapped leaf contributes its recipe's roots and
-* reads through its pipeline). Structure is validated once at creation;
-* reads refresh a stable mirror through the view's slots, so per-update
-* reads do no traversal or allocation.
+* roots into `roots`. A mapped leaf contributes its recipe's roots and
+* reads through its pipeline.
 */
 function compileShape(shape, roots) {
 	const { root } = new ShapeTree(shape, {
@@ -860,22 +365,21 @@ function mapSpring(source, map) {
 //#region src/follow-graph.ts
 const MOTION_BACKING = /* @__PURE__ */ new WeakMap();
 /**
-* Records what advances `source`: its own `Motion` for a scalar spring,
-* or the aggregated sources whose own registrations lead to motions (a
-* composite registers its channel springs). Called from the
-* `SpringSourceSymbol` brand getters on every api read — lazily, so
-* springs never used as sources stay out of the weak registry, and
-* idempotently, so repeated reads just overwrite the entry.
+* Records what advances `source`: its own `Motion` for a spring or a
+* ramp, or the aggregated sources that lead to motions (a composite's
+* channel springs). The `SpringSourceSymbol` brand getters call it on
+* every api read, not at construction, so springs never used as sources
+* stay out of the weak registry. A repeat call overwrites the entry.
 */
 function registerBacking(source, backing) {
 	MOTION_BACKING.set(source, backing);
 }
 /**
-* Resolves the motions behind `source`, deduplicated: every spring
-* reached through any chain of derivations — `mapSpring` pipelines,
-* `velocityOf`/`accelerationOf` wrappers, composite channels. A foreign
-* source resolves to nothing: it imposes no tick-ordering constraint and
-* couples through its emitter alone.
+* Resolves the deduplicated spring and ramp motions behind `source`,
+* through any chain of `mapSpring` pipelines, `velocityOf`,
+* `accelerationOf`, and `targetOf` wrappers, and composite channels. A
+* foreign source resolves to nothing and couples through its emitter
+* alone, with no tick-ordering constraint.
 */
 function resolveLeaderMotions(source) {
 	const leaders = /* @__PURE__ */ new Set();
@@ -898,17 +402,47 @@ function collectInto(source, leaders) {
 		}
 	}
 	if (backing === void 0) return;
-	if (backing instanceof Motion) leaders.add(backing);
-	else for (const part of backing) collectInto(part, leaders);
+	if (Array.isArray(backing)) for (const part of backing) collectInto(part, leaders);
+	else leaders.add(backing);
 }
 const NO_LEADERS = [];
 /**
-* The follow graph as a walkable structure: one edge per following
-* motion, and a cached dependency rank over every motion the edges
-* touch. `MotionSet` owns one; springs register and unregister edges as
-* follows are wired and torn down. What the tick reads per motion —
-* `_edge`, `_followers`, `_rank` — lives on the motions themselves;
-* this class is their writer.
+* The sub-step controller's history of one followed value: its last
+* observed value, `delta`, and `curvature`.
+*/
+var TargetTrail = class {
+	#previous;
+	#delta = 0;
+	#curvature = 0;
+	constructor(value) {
+		this.#previous = value;
+	}
+	/** The change between the last two observed values. */
+	get delta() {
+		return this.#delta;
+	}
+	/** The latest `delta` minus the one before it. 0 while the value moves in a straight line. */
+	get curvature() {
+		return this.#curvature;
+	}
+	/** Records this frame's value and returns the change since the last one. */
+	observe(value) {
+		const delta = value - this.#previous;
+		this.#curvature = delta - this.#delta;
+		this.#delta = delta;
+		this.#previous = value;
+		return delta;
+	}
+	/** Restarts the trail at `value` without recording a change. */
+	anchor(value) {
+		this.#previous = value;
+	}
+};
+/**
+* The follow graph: one edge per following motion, and a cached
+* dependency rank over every motion the edges touch. `MotionSet` owns
+* one. This class writes `edge`, `followers`, and `rank` onto the
+* motions, where the tick reads them.
 */
 var FollowGraph = class {
 	#edges = /* @__PURE__ */ new Map();
@@ -916,347 +450,963 @@ var FollowGraph = class {
 	#ranked = [];
 	/** Motions holding a follower list from the last recompute, so stale lists reset to null. */
 	#withFollowers = [];
-	/** Edge list mirroring the map, rebuilt with the ranks, so the per-frame plan pass iterates an array. */
+	/** The map's edges as an array for the per-frame plan pass, rebuilt with the ranks. */
 	#edgeList = [];
 	#dirty = false;
-	/** Whether no edges are registered, letting the tick skip ordering work entirely. */
+	/** Whether no edges are registered. The tick then skips all ordering work. */
 	get isEmpty() {
 		return this.#edges.size === 0;
 	}
-	/** Every registered edge, valid after `ensureOrder`; the plan pass walks this once per frame. */
+	/** Every registered edge, current as of the last `ensureOrder`. */
 	get edges() {
 		return this.#edgeList;
 	}
 	/**
-	* Registers `edge`, replacing any edge with the same follower: a
-	* spring follows at most one source at a time.
+	* Registers `edge`, replacing any edge with the same follower: a
+	* spring follows at most one source at a time.
+	*/
+	addEdge(edge) {
+		this.#edges.set(edge.follower, edge);
+		edge.follower.edge = edge;
+		this.#dirty = true;
+	}
+	/** Drops the edge whose follower is `follower`, if one is registered. */
+	removeEdge(follower) {
+		if (this.#edges.delete(follower)) {
+			follower.edge = null;
+			this.#dirty = true;
+		}
+	}
+	/**
+	* Recomputes ranks if an edge was added or removed since the last call.
+	* Afterward, motions the graph touches rank up from 0, every leader
+	* before its followers, and motions outside it hold -1. Cycle members
+	* rank in ascending creation id. Ranks depend on graph structure and
+	* creation order, never on wiring order.
+	*/
+	ensureOrder() {
+		if (!this.#dirty) return;
+		this.#dirty = false;
+		this.#recompute();
+	}
+	#recompute() {
+		for (const motion of this.#ranked) motion.rank = -1;
+		for (const motion of this.#withFollowers) motion.followers = null;
+		const withFollowers = [];
+		for (const edge of this.#edges.values()) for (const leader of edge.leaders) {
+			if (leader.followers === null) {
+				leader.followers = [];
+				withFollowers.push(leader);
+			}
+			leader.followers.push(edge);
+		}
+		this.#withFollowers = withFollowers;
+		const nodes = /* @__PURE__ */ new Set();
+		for (const [follower, edge] of this.#edges) {
+			nodes.add(follower);
+			for (const leader of edge.leaders) nodes.add(leader);
+		}
+		const roots = [...nodes].sort((a, b) => a.id - b.id);
+		const indexOf = /* @__PURE__ */ new Map();
+		const lowOf = /* @__PURE__ */ new Map();
+		const onStack = /* @__PURE__ */ new Set();
+		const stack = [];
+		const ranked = [];
+		const sccOf = /* @__PURE__ */ new Map();
+		let index = 0;
+		let rank = 0;
+		let scc = 0;
+		for (const root of roots) {
+			if (indexOf.has(root)) continue;
+			const frames = [{
+				node: root,
+				leaders: this.#leadersOf(root),
+				next: 0
+			}];
+			indexOf.set(root, index);
+			lowOf.set(root, index);
+			index++;
+			stack.push(root);
+			onStack.add(root);
+			while (frames.length > 0) {
+				const frame = frames.at(-1);
+				if (frame.next < frame.leaders.length) {
+					const leader = frame.leaders[frame.next++];
+					const seen = indexOf.get(leader);
+					if (seen === void 0) {
+						indexOf.set(leader, index);
+						lowOf.set(leader, index);
+						index++;
+						stack.push(leader);
+						onStack.add(leader);
+						frames.push({
+							node: leader,
+							leaders: this.#leadersOf(leader),
+							next: 0
+						});
+					} else if (onStack.has(leader)) lowOf.set(frame.node, Math.min(lowOf.get(frame.node), seen));
+				} else {
+					frames.pop();
+					const low = lowOf.get(frame.node);
+					const parent = frames.at(-1);
+					if (parent !== void 0) lowOf.set(parent.node, Math.min(lowOf.get(parent.node), low));
+					if (low === indexOf.get(frame.node)) {
+						const members = [];
+						let member;
+						do {
+							member = stack.pop();
+							onStack.delete(member);
+							members.push(member);
+						} while (member !== frame.node);
+						members.sort((a, b) => a.id - b.id);
+						for (const member of members) {
+							member.rank = rank++;
+							sccOf.set(member, scc);
+							ranked.push(member);
+						}
+						scc++;
+					}
+				}
+			}
+		}
+		this.#ranked = ranked;
+		const edgeList = [...this.#edges.values()];
+		for (const edge of edgeList) {
+			const home = sccOf.get(edge.follower);
+			edge.cyclic = edge.leaders.some((leader) => sccOf.get(leader) === home);
+		}
+		this.#edgeList = edgeList;
+	}
+	#leadersOf(motion) {
+		return this.#edges.get(motion)?.leaders ?? NO_LEADERS;
+	}
+};
+//#endregion
+//#region src/motion-set.ts
+function compareMotions(a, b) {
+	return a.rank - b.rank || a.id - b.id;
+}
+const MAX_SUBSTEPS = 8;
+/**
+* The worklist of an ordered pass: a binary min-heap over (rank,
+* creation id). It accepts duplicate pushes, and the tick's pass marker
+* drops the repeats at pop.
+*/
+var MotionHeap = class {
+	#items = [];
+	clear() {
+		this.#items.length = 0;
+	}
+	push(motion) {
+		const items = this.#items;
+		let hole = items.length;
+		items.push(motion);
+		while (hole > 0) {
+			const parent = hole - 1 >> 1;
+			if (compareMotions(items[parent], motion) <= 0) break;
+			items[hole] = items[parent];
+			hole = parent;
+		}
+		items[hole] = motion;
+	}
+	pop() {
+		const items = this.#items;
+		if (items.length === 0) return void 0;
+		const top = items[0];
+		const last = items.pop();
+		if (items.length > 0) {
+			let hole = 0;
+			for (;;) {
+				const left = 2 * hole + 1;
+				if (left >= items.length) break;
+				const right = left + 1;
+				const child = right < items.length && compareMotions(items[right], items[left]) < 0 ? right : left;
+				if (compareMotions(last, items[child]) <= 0) break;
+				items[hole] = items[child];
+				hole = child;
+			}
+			items[hole] = last;
+		}
+		return top;
+	}
+};
+/**
+* The set of motions the tick advances. A motion leaves when it rests and
+* re-enters on any write that disturbs it. A ramp is in the set only
+* while something watches it frame by frame. `onWake` fires when the set
+* becomes non-empty, waking a sleeping ticker.
+*/
+var MotionSet = class {
+	reduced = false;
+	onWake = null;
+	/**
+	* The coupling error budget, in value units: the local per-frame error
+	* the sub-step controller targets on each follow edge, floored by the
+	* follower's resting magnitude. `SpringSystem` validates and exposes it
+	* as the `couplingTolerance` option and property.
+	*/
+	couplingTolerance = .1;
+	flushes = new FlushQueue();
+	/** Follow edges registered by following springs, with the dependency rank over their motions. */
+	graph = new FollowGraph();
+	/**
+	* Motions a reduced-motion change must reach while out of the tick: a
+	* `'motion'` ramp that moves on the clock unwatched, or one holding
+	* still under reduced motion. Each member keeps its membership current.
+	*/
+	reducible = /* @__PURE__ */ new Set();
+	#motions = /* @__PURE__ */ new Set();
+	#heap = new MotionHeap();
+	#advanced = [];
+	/** The live pass worklist while an advance phase runs, so mid-phase wakes join it. */
+	#activeHeap = null;
+	/** Whether any tick is on the stack, settle sweep included. A reentrant advance must not share the pass structures. */
+	#inTick = false;
+	#debug;
+	#lastSize = 0;
+	#pass = 0;
+	/** Ordered-frame counter. Sub-steps share one id, so a motion joins the settle list once. */
+	#frame = 0;
+	/** Stepped time in seconds: the sum of every tick's `dt`, plus idle time the ticker credits. */
+	#clock = 0;
+	/** Counts ticks, so `advancing` can name the one in its advance phase. */
+	#ticks = 0;
+	#advancing = 0;
+	/**
+	* Returns the idle wall time, in seconds, the clock has not counted yet.
+	* Null when no ticker counts idle time. The ticker installs it, and
+	* moves the total in with `credit` on its first frame after starting or
+	* waking, and when it stops.
+	*/
+	idleTime = null;
+	constructor(debug = false) {
+		this.#debug = debug;
+	}
+	get size() {
+		return this.#motions.size;
+	}
+	/**
+	* The system clock in seconds, which ramps read their position from. It
+	* moves only forward: by each tick's `dt` when the advance phase ends,
+	* and by idle wall time while the ticker sleeps. Wall time is read once
+	* per microtask checkpoint, so the clock holds still through
+	* synchronous code.
+	*/
+	get time() {
+		const idle = this.idleTime;
+		return idle === null ? this.#clock : this.#clock + idle();
+	}
+	/**
+	* The id of the tick whose advance phase is running, or 0 between
+	* phases. A ramp steps a cached value through the sub-steps of the
+	* phase and reads its anchor formula everywhere else.
+	*/
+	get advancing() {
+		return this.#advancing;
+	}
+	/** Adds idle wall time to the clock, in seconds. */
+	credit(seconds) {
+		this.#clock += seconds;
+	}
+	add(motion) {
+		const motions = this.#motions;
+		const size = motions.size;
+		motions.add(motion);
+		if (motions.size === size) return;
+		this.#activeHeap?.push(motion);
+		if (size === 0) this.onWake?.();
+	}
+	remove(motion) {
+		this.#motions.delete(motion);
+	}
+	/**
+	* Whether the motion is in the set. A motion that rests mid-pass leaves
+	* before its own `endFrame`, so motions ask here rather than track it.
+	*/
+	has(motion) {
+		return this.#motions.has(motion);
+	}
+	/**
+	* Applies a reduced-motion change to the `reducible` registry first,
+	* because a ramp's jump retargets its followers, then to every moving
+	* motion, leaders before followers. A motion reached twice changes once.
+	*/
+	setReduced(reduced) {
+		this.reduced = reduced;
+		this.flushes.batch(() => {
+			for (const motion of this.reducible) motion.applyReducedMotion(reduced);
+			this.graph.ensureOrder();
+			const motions = [...this.#motions];
+			if (!this.graph.isEmpty) motions.sort(compareMotions);
+			for (const motion of motions) {
+				motion.applyReducedMotion(reduced);
+				if (motion.isResting) this.#motions.delete(motion);
+			}
+		});
+	}
+	tick(dt) {
+		const reentrant = this.#inTick;
+		this.#inTick = true;
+		this.flushes.enter();
+		try {
+			this.graph.ensureOrder();
+			if (this.graph.isEmpty) this.#tickUnordered(dt, reentrant);
+			else this.#tickOrdered(dt, reentrant);
+		} finally {
+			this.#inTick = reentrant;
+			this.flushes.exit();
+		}
+		if (this.#debug && this.#motions.size !== this.#lastSize) {
+			this.#lastSize = this.#motions.size;
+			console.log(`coily: ${this.#lastSize} active motions`);
+		}
+	}
+	/** The fast path with no follow edges. Nothing constrains the order, so insertion order serves. */
+	#tickUnordered(dt, reentrant) {
+		const previous = this.#advancing;
+		this.#advancing = ++this.#ticks;
+		const advanced = reentrant ? [] : this.#advanced;
+		advanced.length = 0;
+		try {
+			for (const motion of this.#motions) {
+				motion.advance(dt);
+				advanced.push(motion);
+				if (motion.isResting) this.#motions.delete(motion);
+			}
+		} finally {
+			this.#advancing = previous;
+		}
+		this.#clock += dt;
+		this.#settle(advanced);
+	}
+	#tickOrdered(dt, reentrant) {
+		const heap = reentrant ? new MotionHeap() : this.#heap;
+		const advanced = reentrant ? [] : this.#advanced;
+		const previous = this.#activeHeap;
+		this.#activeHeap = heap;
+		const previousAdvancing = this.#advancing;
+		this.#advancing = ++this.#ticks;
+		advanced.length = 0;
+		const frame = ++this.#frame;
+		let demand = 1;
+		if (!this.reduced) {
+			for (const edge of this.graph.edges) if (this.#shouldPlan(edge)) {
+				const k = edge.plan(dt);
+				if (k > demand) demand = k;
+			}
+		}
+		const K = Math.min(demand, MAX_SUBSTEPS);
+		const h = dt / K;
+		try {
+			for (let step = 0; step < K; step++) this.#advancePass(dt, h, step === 0, heap, advanced, frame);
+		} finally {
+			this.#activeHeap = previous;
+			this.#advancing = previousAdvancing;
+		}
+		this.#clock += dt;
+		this.#settle(advanced);
+	}
+	#advancePass(dt, h, first, heap, advanced, frame) {
+		this.#pass++;
+		heap.clear();
+		for (const motion of this.#motions) {
+			if (!first && motion.rank === -1) continue;
+			heap.push(motion);
+		}
+		for (let motion = heap.pop(); motion !== void 0; motion = heap.pop()) {
+			if (motion.pass === this.#pass) continue;
+			const edge = motion.edge;
+			if (edge !== null && this.#shouldRecouple(edge)) edge.recouple(h);
+			if (!this.#motions.has(motion)) continue;
+			motion.pass = this.#pass;
+			motion.advance(motion.rank === -1 ? dt : h);
+			if (motion.frame !== frame) {
+				motion.frame = frame;
+				advanced.push(motion);
+			}
+			if (motion.isResting) this.#motions.delete(motion);
+			const followers = motion.followers;
+			if (followers !== null) for (const out of followers) heap.push(out.follower);
+		}
+	}
+	#settle(advanced) {
+		for (const motion of advanced) motion.endFrame();
+	}
+	#shouldRecouple(edge) {
+		for (const leader of edge.leaders) if (leader.pass === this.#pass || this.#motions.has(leader)) return true;
+		return false;
+	}
+	#shouldPlan(edge) {
+		for (const leader of edge.leaders) if (this.#motions.has(leader)) return true;
+		return false;
+	}
+};
+//#endregion
+//#region src/config.ts
+/**
+* Resolved spring parameters, frozen and safe to share between springs.
+* Whatever `defineSpring` input shape produced it, a config has concrete
+* `mass`, `tension`, `damping`, `precision`, and `arrival`, plus the
+* quantities derived from them. To change a spring's behavior, assign a
+* new config to `spring.config`.
+*/
+var SpringDefinition = class SpringDefinition {
+	/** The config for springs created without one: critically damped, settling in about 500ms. */
+	static default = new SpringDefinition({
+		dampingRatio: 1,
+		duration: 500
+	});
+	/** Mass of the moving value, as provided or derived. */
+	mass;
+	/** Spring stiffness, as provided or derived. */
+	tension;
+	/** Friction strength, as provided or derived. */
+	damping;
+	/** Decimal places of the resting threshold. See `restingMagnitude`. */
+	precision;
+	/**
+	* Velocity multiplier applied each time the value crosses the target.
+	* `'passthrough'` resolves to 1, which leaves the motion untouched.
+	* `'stop'` resolves to 0, which ends it at the target. Negative values
+	* rebound.
+	*/
+	arrival;
+	/** Oscillation rate with no damping: `sqrt(tension / mass)`, in radians per second. */
+	naturalFrequency;
+	/** The damping at which bounce disappears: `2 * mass * naturalFrequency`. */
+	criticalDamping;
+	/**
+	* `damping / criticalDamping`. Below 1 the spring bounces. At 1 it
+	* settles fastest without overshooting. Above 1 it settles slower.
+	*/
+	dampingRatio;
+	/** Resting threshold in value units, `0.5 * 10^-precision`. */
+	restingMagnitude;
+	constructor(input) {
+		const raw = input;
+		const mass = raw.mass;
+		const tension = raw.tension;
+		const damping = raw.damping;
+		const bounce = raw.bounce;
+		const duration = raw.duration !== void 0 ? raw.duration / 1e3 : void 0;
+		const displacement = raw.displacement ?? 1;
+		const precision = raw.precision ?? 2;
+		const arrival = raw.arrival;
+		for (const key of Object.keys(raw)) {
+			if (key === "arrival") continue;
+			const value = raw[key];
+			if (value !== void 0) invariant(Number.isFinite(value), () => `Invalid ${key}: expected a finite number`);
+		}
+		if (mass !== void 0) invariant(mass > 0, "Mass must be greater than 0");
+		if (tension !== void 0) invariant(tension > 0, "Tension must be greater than 0");
+		if (damping !== void 0) invariant(damping >= 0, "Damping must be greater than or equal to 0");
+		if (bounce !== void 0) invariant(bounce >= -1 && bounce <= 1, "Bounce must be between -1 and 1");
+		invariant(raw.dampingRatio === void 0 || bounce === void 0, "Provide either dampingRatio or bounce, not both");
+		const dampingRatio = raw.dampingRatio ?? (bounce !== void 0 ? Math.max(1e-4, 1 - bounce) : void 0);
+		if (dampingRatio !== void 0) invariant(dampingRatio >= 0, "Damping ratio must be greater than or equal to 0");
+		if (duration !== void 0) invariant(duration > 0, "Duration must be greater than 0");
+		invariant(precision >= 0, "Precision must be greater than or equal to 0");
+		invariant(arrival === void 0 || arrival === "passthrough" || arrival === "stop" || typeof arrival === "number" && Number.isFinite(arrival) && arrival >= -1 && arrival <= 1, "Arrival must be 'passthrough', 'stop', or a number between -1 and 1");
+		this.precision = precision;
+		this.restingMagnitude = .5 / 10 ** precision;
+		if (arrival === void 0 || arrival === "passthrough") this.arrival = 1;
+		else if (arrival === "stop") this.arrival = 0;
+		else this.arrival = arrival === 0 ? 0 : arrival;
+		const hasM = mass !== void 0;
+		const hasK = tension !== void 0;
+		const hasC = damping !== void 0;
+		const hasZ = dampingRatio !== void 0;
+		const hasT = duration !== void 0;
+		if (hasK && hasC && !hasZ && !hasT) {
+			this.mass = mass ?? 1;
+			this.tension = tension;
+			this.damping = damping;
+		} else if (hasK && hasZ && !hasC && !hasT) {
+			this.mass = mass ?? 1;
+			this.tension = tension;
+			this.damping = 2 * dampingRatio * Math.sqrt(this.mass * tension);
+		} else if (hasC && hasZ && !hasK && !hasT) {
+			invariant(dampingRatio > 0, "dampingRatio must be > 0 to derive tension");
+			invariant(bounce === void 0 || bounce < 1, "bounce must be < 1 to derive tension");
+			this.mass = mass ?? 1;
+			this.tension = damping ** 2 / (4 * dampingRatio ** 2 * this.mass);
+			this.damping = damping;
+		} else if (hasK && hasC && hasZ && !hasT) {
+			invariant(!hasM, "mass is derived when tension, damping, and dampingRatio are all provided");
+			invariant(dampingRatio > 0, "dampingRatio must be > 0 to derive mass");
+			invariant(bounce === void 0 || bounce < 1, "bounce must be < 1 to derive mass");
+			this.mass = damping ** 2 / (4 * dampingRatio ** 2 * tension);
+			this.tension = tension;
+			this.damping = damping;
+		} else if (hasZ && hasT) {
+			const x0 = Math.abs(displacement);
+			invariant(x0 > this.restingMagnitude, () => `Displacement magnitude must be greater than the resting threshold (${this.restingMagnitude} at precision ${precision})`);
+			invariant(dampingRatio > 0, "dampingRatio must be > 0 for duration-based config");
+			const wn = restUnits(dampingRatio, x0 / this.restingMagnitude) / duration;
+			if (!hasK && !hasC) {
+				this.mass = mass ?? 1;
+				this.tension = wn ** 2 * this.mass;
+				this.damping = 2 * dampingRatio * this.mass * wn;
+			} else if (hasK && !hasC) {
+				invariant(!hasM, "mass is derived in duration-based configs with tension");
+				this.mass = tension / wn ** 2;
+				this.tension = tension;
+				this.damping = 2 * dampingRatio * this.mass * wn;
+			} else if (hasC && !hasK) {
+				invariant(!hasM, "mass is derived in duration-based configs with damping");
+				this.mass = damping / (2 * dampingRatio * wn);
+				this.tension = wn ** 2 * this.mass;
+				this.damping = damping;
+			} else throw new Error("Invalid spring config: provide one of the supported input shapes.");
+		} else throw new Error("Invalid spring config: provide one of the supported input shapes.");
+		this.naturalFrequency = Math.sqrt(this.tension / this.mass);
+		this.criticalDamping = 2 * this.mass * this.naturalFrequency;
+		this.dampingRatio = this.damping / this.criticalDamping;
+		Object.freeze(this);
+	}
+	/**
+	* Computes the time in ms until a spring with this config rests from
+	* `state`, solved exactly from the motion's decay bound. The spring
+	* rests at the first tick at or after it.
+	*
+	* An underdamped spring can also rest earlier, on a frame that samples
+	* a dip in its pulsing rest amplitude, so read the result as "no later
+	* than". The motion an early rest cuts off never leaves the resting
+	* threshold. See https://github.com/tkofh/coily/blob/main/PRECISION.md.
+	*
+	* Returns 0 when `state` is already inside the resting threshold.
+	* Returns Infinity when the motion never settles: a `dampingRatio` of 0
+	* whose `arrival` neither stops nor slows it. With `arrival` 0, the
+	* result is capped at the first target crossing, where the spring rests
+	* exactly. Other multipliers fold their per-crossing velocity loss into
+	* the time.
 	*/
-	addEdge(edge) {
-		this.#edges.set(edge.follower, edge);
-		edge.follower._edge = edge;
-		this.#dirty = true;
+	computeTimeRemaining(state) {
+		const { position, velocity } = state;
+		if (Math.abs(position) + Math.abs(velocity) / this.naturalFrequency <= this.restingMagnitude) return 0;
+		const crossing = this.arrival === 0 ? firstCrossing(this, position, velocity) * 1e3 : Infinity;
+		return Math.min(restTime(this, position, velocity) * 1e3, crossing);
 	}
-	/** Drops the edge whose follower is `motion`, if one is registered. */
-	removeEdge(follower) {
-		if (this.#edges.delete(follower)) {
-			follower._edge = null;
-			this.#dirty = true;
-		}
+};
+function solveEntry(f, threshold, peak) {
+	let low = 0;
+	let high = Math.max(peak, 1e-6);
+	while (f(high) > threshold) {
+		low = high;
+		high *= 2;
 	}
-	/**
-	* Recomputes ranks if an edge was added or removed since the last
-	* call; clean calls return immediately. Afterward, motions the graph
-	* touches hold ranks counting up from 0 with every leader ranked
-	* before its followers, members of a cycle rank in ascending creation
-	* id, and motions outside the graph hold -1. Ranks are canonical: a
-	* function of graph structure and creation order, never of wiring
-	* order.
-	*/
-	ensureOrder() {
-		if (!this.#dirty) return;
-		this.#dirty = false;
-		this.#recompute();
+	for (let i = 0; i < 60; i++) {
+		const mid = (low + high) / 2;
+		if (f(mid) > threshold) low = mid;
+		else high = mid;
 	}
-	#recompute() {
-		for (const motion of this.#ranked) motion._rank = -1;
-		for (const motion of this.#withFollowers) motion._followers = null;
-		const withFollowers = [];
-		for (const edge of this.#edges.values()) for (const leader of edge.leaders) {
-			if (leader._followers === null) {
-				leader._followers = [];
-				withFollowers.push(leader);
-			}
-			leader._followers.push(edge);
-		}
-		this.#withFollowers = withFollowers;
-		const nodes = /* @__PURE__ */ new Set();
-		for (const [follower, edge] of this.#edges) {
-			nodes.add(follower);
-			for (const leader of edge.leaders) nodes.add(leader);
-		}
-		const roots = [...nodes].sort((a, b) => a._id - b._id);
-		const indexOf = /* @__PURE__ */ new Map();
-		const lowOf = /* @__PURE__ */ new Map();
-		const onStack = /* @__PURE__ */ new Set();
-		const stack = [];
-		const ranked = [];
-		const sccOf = /* @__PURE__ */ new Map();
-		let index = 0;
-		let rank = 0;
-		let scc = 0;
-		for (const root of roots) {
-			if (indexOf.has(root)) continue;
-			const frames = [{
-				node: root,
-				leaders: this.#leadersOf(root),
-				next: 0
-			}];
-			indexOf.set(root, index);
-			lowOf.set(root, index);
-			index++;
-			stack.push(root);
-			onStack.add(root);
-			while (frames.length > 0) {
-				const frame = frames.at(-1);
-				if (frame.next < frame.leaders.length) {
-					const leader = frame.leaders[frame.next++];
-					const seen = indexOf.get(leader);
-					if (seen === void 0) {
-						indexOf.set(leader, index);
-						lowOf.set(leader, index);
-						index++;
-						stack.push(leader);
-						onStack.add(leader);
-						frames.push({
-							node: leader,
-							leaders: this.#leadersOf(leader),
-							next: 0
-						});
-					} else if (onStack.has(leader)) lowOf.set(frame.node, Math.min(lowOf.get(frame.node), seen));
-				} else {
-					frames.pop();
-					const low = lowOf.get(frame.node);
-					const parent = frames.at(-1);
-					if (parent !== void 0) lowOf.set(parent.node, Math.min(lowOf.get(parent.node), low));
-					if (low === indexOf.get(frame.node)) {
-						const members = [];
-						let member;
-						do {
-							member = stack.pop();
-							onStack.delete(member);
-							members.push(member);
-						} while (member !== frame.node);
-						members.sort((a, b) => a._id - b._id);
-						for (const motion of members) {
-							motion._rank = rank++;
-							sccOf.set(motion, scc);
-							ranked.push(motion);
-						}
-						scc++;
-					}
-				}
-			}
-		}
-		this.#ranked = ranked;
-		const edgeList = [...this.#edges.values()];
-		for (const edge of edgeList) {
-			const home = sccOf.get(edge.follower);
-			edge._cyclic = edge.leaders.some((leader) => sccOf.get(leader) === home);
-		}
-		this.#edgeList = edgeList;
+	return high;
+}
+function restTime(config, position, velocity) {
+	const { naturalFrequency, dampingRatio, restingMagnitude, arrival } = config;
+	if (dampingRatio < 1) {
+		const sigma = dampingRatio * naturalFrequency;
+		const wd = naturalFrequency * Math.sqrt(1 - dampingRatio ** 2);
+		const R = Math.hypot(position, (velocity + sigma * position) / wd);
+		const drop = Math.log(R * Math.sqrt(2 + 2 * dampingRatio) / restingMagnitude);
+		const plain = sigma > 0 ? drop / sigma : Infinity;
+		const strength = Math.abs(arrival);
+		if (strength === 0 || strength === 1) return plain;
+		const first = firstCrossing(config, position, velocity);
+		if (plain <= first) return plain;
+		const loss = -Math.log(strength) * wd / Math.PI;
+		return (drop + loss * first) / (sigma + loss);
 	}
-	#leadersOf(motion) {
-		return this.#edges.get(motion)?.leaders ?? NO_LEADERS;
+	if (dampingRatio === 1) {
+		const a0 = Math.abs(position) + Math.abs(velocity) / naturalFrequency;
+		const beta = 2 * Math.abs(velocity + naturalFrequency * position);
+		return solveEntry((t) => Math.exp(-naturalFrequency * t) * (a0 + beta * t), restingMagnitude, beta > 0 ? Math.max(0, 1 / naturalFrequency - a0 / beta) : 0);
 	}
-};
-//#endregion
-//#region src/motion-set.ts
-function compareMotions(a, b) {
-	return a._rank - b._rank || a._id - b._id;
+	const wd = naturalFrequency * Math.sqrt(dampingRatio ** 2 - 1);
+	const slow = dampingRatio * naturalFrequency - wd;
+	const fast = dampingRatio * naturalFrequency + wd;
+	const slowAmplitude = Math.abs(velocity + fast * position) / (2 * wd) * (1 + slow / naturalFrequency);
+	const fastAmplitude = Math.abs(velocity + slow * position) / (2 * wd) * (1 + fast / naturalFrequency);
+	return solveEntry((t) => slowAmplitude * Math.exp(-slow * t) + fastAmplitude * Math.exp(-fast * t), restingMagnitude, 0);
 }
-const MAX_SUBSTEPS = 8;
-/**
-* A binary min-heap over (rank, creation id): the ordered pass worklist.
-* Duplicate pushes are expected — the tick's pass marker deduplicates at
-* pop.
-*/
-var MotionHeap = class {
-	#items = [];
+function restUnits(dampingRatio, ratio) {
+	if (dampingRatio < 1) return Math.log(ratio * Math.sqrt(2 / (1 - dampingRatio))) / dampingRatio;
+	if (dampingRatio === 1) return solveEntry((u) => Math.exp(-u) * (1 + 2 * u), 1 / ratio, .5);
+	const wd = Math.sqrt(dampingRatio ** 2 - 1);
+	const slow = dampingRatio - wd;
+	const fast = dampingRatio + wd;
+	const slowAmplitude = fast / (2 * wd) * (1 + slow);
+	const fastAmplitude = slow / (2 * wd) * (1 + fast);
+	return solveEntry((u) => slowAmplitude * Math.exp(-slow * u) + fastAmplitude * Math.exp(-fast * u), 1 / ratio, 0);
+}
+function firstCrossing(config, position, velocity) {
+	const { naturalFrequency, dampingRatio } = config;
+	if (dampingRatio < 1) {
+		const wd = naturalFrequency * Math.sqrt(1 - dampingRatio ** 2);
+		const c2 = (velocity + dampingRatio * naturalFrequency * position) / wd;
+		let theta = Math.atan2(-position, c2) % Math.PI;
+		if (theta <= 0) theta += Math.PI;
+		return theta / wd;
+	}
+	if (dampingRatio === 1) {
+		const t = -position / (velocity + naturalFrequency * position);
+		return t > 0 ? t : Infinity;
+	}
+	const wd = naturalFrequency * Math.sqrt(dampingRatio ** 2 - 1);
+	const theta = Math.atanh(-position * wd / (velocity + dampingRatio * naturalFrequency * position));
+	return theta > 0 ? theta / wd : Infinity;
+}
+function defineSpring(input) {
+	return new SpringDefinition(input);
+}
+//#endregion
+//#region src/emitter.ts
+/** Minimal fixed-event emitter behind motions and composite springs. */
+var Emitter = class {
+	#update = [];
+	#start = [];
+	#stop = [];
+	#dispose = [];
+	on(type, handler) {
+		this.#list(type).push(handler);
+		return () => {
+			this.off(type, handler);
+		};
+	}
+	off(type, handler) {
+		const list = this.#list(type);
+		if (handler) list.splice(list.indexOf(handler) >>> 0, 1);
+		else list.length = 0;
+	}
 	clear() {
-		this.#items.length = 0;
+		this.#update.length = 0;
+		this.#start.length = 0;
+		this.#stop.length = 0;
+		this.#dispose.length = 0;
 	}
-	push(motion) {
-		const items = this.#items;
-		let hole = items.length;
-		items.push(motion);
-		while (hole > 0) {
-			const parent = hole - 1 >> 1;
-			if (compareMotions(items[parent], motion) <= 0) break;
-			items[hole] = items[parent];
-			hole = parent;
-		}
-		items[hole] = motion;
+	emit(type) {
+		const list = this.#list(type);
+		if (list.length === 1) list[0]();
+		else if (list.length > 1) for (const handler of list.slice()) handler();
 	}
-	pop() {
-		const items = this.#items;
-		if (items.length === 0) return void 0;
-		const top = items[0];
-		const last = items.pop();
-		if (items.length > 0) {
-			let hole = 0;
-			for (;;) {
-				const left = 2 * hole + 1;
-				if (left >= items.length) break;
-				const right = left + 1;
-				const child = right < items.length && compareMotions(items[right], items[left]) < 0 ? right : left;
-				if (compareMotions(last, items[child]) <= 0) break;
-				items[hole] = items[child];
-				hole = child;
-			}
-			items[hole] = last;
+	#list(type) {
+		switch (type) {
+			case "update": return this.#update;
+			case "start": return this.#start;
+			case "stop": return this.#stop;
+			case "dispose": return this.#dispose;
 		}
-		return top;
 	}
 };
+//#endregion
+//#region src/motion.ts
+let nextId = 0;
 /**
-* The set of motions currently moving. Motions leave the set as they
-* rest and re-enter on any write that disturbs them; `onWake` tells the
-* ticker the set became non-empty so it can stop sleeping.
+* Something the system advances frame by frame: a spring's `SpringMotion`
+* or a ramp's `RampMotion`. `MotionSet` ticks motions and `FollowGraph`
+* orders them through the members declared here. Owners keep their motion
+* in a private field, so none of this reaches the public api.
+*
+* A tick runs in two phases. Every moving motion first advances silently,
+* so followers recouple against frame-current values. Then each motion
+* that advanced delivers its events in `endFrame`.
 */
-var MotionSet = class {
-	reduced = false;
-	onWake = null;
+var Motion = class {
 	/**
-	* The coupling error budget, in value units: the local per-frame error
-	* the sub-step controller targets on each follow edge, floored by the
-	* follower's resting magnitude. `SpringSystem` exposes it as the
-	* `couplingTolerance` option and property; validation lives there.
+	* Creation order across every kind of motion. The lower id goes first
+	* wherever motions need a deterministic order and nothing else decides.
 	*/
-	couplingTolerance = .1;
-	flushes = new FlushQueue();
-	/** Follow edges registered by following springs, with the dependency rank over their motions. */
-	graph = new FollowGraph();
-	#motions = /* @__PURE__ */ new Set();
-	#heap = new MotionHeap();
-	#advanced = [];
-	/** The live pass worklist while an advance phase runs, so mid-phase wakes join it. */
-	#activeHeap = null;
-	/** Whether any tick is on the stack, settle sweep included — a reentrant advance must not share the pass structures. */
-	#inTick = false;
-	#debug;
-	#lastSize = 0;
-	#pass = 0;
-	/** Ordered-frame counter: sub-steps share one id, deduplicating the settle list. */
-	#frame = 0;
-	constructor(debug = false) {
-		this.#debug = debug;
+	id = nextId++;
+	/**
+	* The last ordered pass that advanced the motion, written by
+	* `MotionSet`, so a motion queued twice in one pass advances once.
+	*/
+	pass = 0;
+	/**
+	* The last ordered frame that advanced the motion, written by
+	* `MotionSet`. Sub-steps share one frame, and the first advance in it
+	* queues the motion for `endFrame`.
+	*/
+	frame = 0;
+	/**
+	* Dependency rank, written by `FollowGraph`. Motions in the follow
+	* graph count up from 0, leaders before followers. -1 marks a motion
+	* outside the graph.
+	*/
+	rank = -1;
+	/**
+	* The edge this motion follows through, or null. `FollowGraph` writes
+	* it. Only a spring follows.
+	*/
+	edge = null;
+	/**
+	* The edges that read this motion, or null when none do. `FollowGraph`
+	* rebuilds them with the ranks, so they can lag a mid-pass edge change
+	* until the next recompute. The tick tolerates stale entries.
+	*/
+	followers = null;
+};
+//#endregion
+//#region src/spring-motion.ts
+/**
+* One spring simulation in displacement space. Position is measured from
+* the target (0 means settled), so a retarget is a rebase that the
+* owning `Spring` performs. Picks the closed-form solver for the
+* config's damping regime and emits update, start, stop, and dispose
+* events.
+*/
+var SpringMotion = class extends Motion {
+	/** Whether reduced motion finishes the motion: false for a `'nonmotion'` spring. */
+	#reduces;
+	/**
+	* First-order-hold slope in value units per second, 0 when the target
+	* holds still across the step. `armSlope` sets it immediately before the
+	* `advance` that reads and clears it, with no user code between.
+	*/
+	#slope = 0;
+	#config;
+	#state;
+	#underdampedSolver = null;
+	#criticallyDampedSolver = null;
+	#overdampedSolver = null;
+	#currentSolver = null;
+	#needsUpdate = false;
+	#needsReset = false;
+	#running;
+	#emitter;
+	constructor(config, position, velocity, purpose = "motion") {
+		super();
+		this.#reduces = purpose === "motion";
+		this.#config = config;
+		this.#state = new State(config, position, velocity);
+		this.#emitter = new Emitter();
+		this.#running = !this.#state.isResting;
+		this.#updateSolver();
 	}
-	get size() {
-		return this.#motions.size;
+	get position() {
+		return this.#state.position;
 	}
-	add(motion) {
-		const wasEmpty = this.#motions.size === 0;
-		this.#motions.add(motion);
-		this.#activeHeap?.push(motion);
-		if (wasEmpty) this.onWake?.();
+	set position(value) {
+		this.#state.position = value;
+		this.#needsReset = true;
+		this.#syncStart();
 	}
-	remove(motion) {
-		this.#motions.delete(motion);
+	get velocity() {
+		return this.#state.velocity;
 	}
-	finishAll() {
-		this.flushes.batch(() => {
-			for (const motion of this.#motions) {
-				if (!motion.respectsReducedMotion) continue;
-				motion.finish();
-				this.#motions.delete(motion);
-			}
-		});
+	set velocity(value) {
+		this.#state.velocity = value;
+		this.#needsReset = true;
+		this.#syncStart();
 	}
-	tick(dt) {
-		const reentrant = this.#inTick;
-		this.#inTick = true;
-		this.flushes.enter();
-		try {
-			this.graph.ensureOrder();
-			if (this.graph.isEmpty) this.#tickUnordered(dt, reentrant);
-			else this.#tickOrdered(dt, reentrant);
-		} finally {
-			this.#inTick = reentrant;
-			this.flushes.exit();
+	get timeRemaining() {
+		return this.#config.computeTimeRemaining(this.#state);
+	}
+	get isResting() {
+		return this.#state.isResting;
+	}
+	configure(config) {
+		this.#config = config;
+		this.#state.configure(config);
+		this.#needsUpdate = true;
+		this.#syncStart();
+	}
+	tick(dt, emit = true) {
+		this.advance(dt);
+		if (emit) this.endFrame();
+		else this.#reconcileRunning();
+	}
+	/**
+	* Makes the next `advance` integrate against a target moving at `slope`
+	* value units per second instead of holding still. The owner calls it
+	* with the step's new target already assigned and the position still
+	* measured from the old one, so the step ends measured from the new
+	* target. Only the next `advance` reads it.
+	*/
+	armSlope(slope) {
+		this.#slope = slope;
+	}
+	/**
+	* Advances the simulation and emits nothing. The tick pass advances
+	* every motion through this, then delivers events with `endFrame`. The
+	* synchronous `tick` wraps the two.
+	*
+	* A pending slope from `armSlope` makes the step one affine transform
+	* around the unchanged solver. With the target at `p(t) = p0 + g*t`, the
+	* displacement u = x - p(t) obeys the homogeneous equation shifted by the
+	* constant u_ss = -(2*zeta/wn)*g = -(damping/tension)*g. The solver ticks
+	* w = u - u_ss exactly, and the results shift back. u is measured from
+	* the moving target, which the armer already assigned, so the step ends
+	* on it with no rebase arithmetic. With g = 0 the step takes the plain
+	* path, so a motion never armed steps bit-exactly like an isolated
+	* spring.
+	*/
+	advance(dt) {
+		invariant(this.#currentSolver, "Cannot tick a disposed motion");
+		const g = this.#slope;
+		if (g !== 0) {
+			this.#slope = 0;
+			const state = this.#state;
+			const shift = this.#config.damping / this.#config.tension * g;
+			state.position += shift;
+			state.velocity -= g;
+			if (this.#needsUpdate) {
+				this.#updateSolver();
+				this.#needsUpdate = false;
+			} else this.#currentSolver.configure();
+			this.#currentSolver.tick(dt);
+			state.position -= shift;
+			state.velocity += g;
+			this.#needsReset = true;
+			if (state.isResting) {
+				state.position = 0;
+				state.velocity = 0;
+			}
+			return;
 		}
-		if (this.#debug && this.#motions.size !== this.#lastSize) {
-			this.#lastSize = this.#motions.size;
-			console.log(`coily: ${this.#lastSize} active motions`);
+		if (this.#needsUpdate) {
+			this.#updateSolver();
+			this.#needsUpdate = false;
+			this.#needsReset = false;
+		} else if (this.#needsReset) {
+			this.#currentSolver.configure();
+			this.#needsReset = false;
 		}
-	}
-	/** The no-edge fast path: nothing constrains order, so insertion order serves for free. */
-	#tickUnordered(dt, reentrant) {
-		this.#pass++;
-		const advanced = reentrant ? [] : this.#advanced;
-		advanced.length = 0;
-		for (const motion of this.#motions) {
-			if (motion._pass === this.#pass) continue;
-			motion._pass = this.#pass;
-			motion._advance(dt);
-			advanced.push(motion);
-			if (motion.isResting) this.#motions.delete(motion);
+		this.#currentSolver.tick(dt);
+		if (this.#state.isResting) {
+			this.#state.position = 0;
+			this.#state.velocity = 0;
+			this.#needsReset = true;
 		}
-		this.#settle(advanced);
 	}
-	#tickOrdered(dt, reentrant) {
-		const heap = reentrant ? new MotionHeap() : this.#heap;
-		const advanced = reentrant ? [] : this.#advanced;
-		const previous = this.#activeHeap;
-		this.#activeHeap = heap;
-		advanced.length = 0;
-		const frame = ++this.#frame;
-		let demand = 1;
-		if (!this.reduced) {
-			for (const edge of this.graph.edges) if (this.#shouldPlan(edge)) {
-				const k = edge.plan(dt);
-				if (k > demand) demand = k;
+	/**
+	* Emits the frame's `update`, then reconciles `stop` and `start`. The
+	* tick pass calls this after every motion advanced, in the order the
+	* motions first advanced, so update callbacks read frame-final values
+	* everywhere.
+	*/
+	endFrame() {
+		this.#emitter.emit("update");
+		this.#reconcileRunning();
+	}
+	#reconcileRunning() {
+		if (this.#state.isResting) {
+			if (this.#running) {
+				this.#running = false;
+				this.#emitter.emit("stop");
 			}
+		} else if (!this.#running) {
+			this.#running = true;
+			this.#emitter.emit("start");
 		}
-		const K = Math.min(demand, MAX_SUBSTEPS);
-		const h = dt / K;
-		try {
-			for (let step = 0; step < K; step++) this.#advancePass(dt, h, step === 0, heap, advanced, frame);
-		} finally {
-			this.#activeHeap = previous;
-		}
-		this.#settle(advanced);
 	}
-	#advancePass(dt, h, first, heap, advanced, frame) {
-		this.#pass++;
-		heap.clear();
-		for (const motion of this.#motions) {
-			if (!first && motion._rank === -1) continue;
-			heap.push(motion);
+	/**
+	* Puts the motion at rest on the target and emits nothing. The next
+	* `endFrame` delivers `update`, plus `stop` if it was moving. A
+	* follower jumps through this mid-tick, so its listeners wait for the
+	* settle sweep.
+	*/
+	rest() {
+		this.#state.position = 0;
+		this.#state.velocity = 0;
+		this.#needsReset = true;
+	}
+	/** Ends the motion at the target at once and emits `update`, plus `stop` if it was moving. */
+	finish() {
+		this.rest();
+		this.tick(0);
+	}
+	/**
+	* Finishes the motion when reduced motion turns on, unless its purpose
+	* is `'nonmotion'`. A motion already at rest on its target stays
+	* silent. A leader's finish can jump its followers before the change
+	* reaches them, and they must not emit twice.
+	*/
+	applyReducedMotion(reduced) {
+		if (!reduced || !this.#reduces) return;
+		const state = this.#state;
+		if (!this.#running && state.position === 0 && state.velocity === 0) return;
+		this.finish();
+	}
+	/**
+	* The shock signal for the sub-step controller, read by a follower's
+	* `plan` from its leader: the deviation from the quasi-steady tracking
+	* manifold x = -(damping/tension) * v, where damping/tension is
+	* 2*zeta/wn. It is near zero while chasing a smoothly moving target at
+	* any speed, the full displacement after a target teleport, and
+	* (damping/tension) * |v| after a fling from rest.
+	*/
+	manifoldDeviation() {
+		const config = this.#config;
+		return Math.abs(this.#state.position + config.damping / config.tension * this.#state.velocity);
+	}
+	/**
+	* Newton's second law for the damped spring, `a = -(k*x + c*v) / m`,
+	* with x the displacement from the target. Like position and velocity,
+	* it is exact from the state and the config.
+	*/
+	get acceleration() {
+		const config = this.#config;
+		return -(config.tension * this.#state.position + config.damping * this.#state.velocity) / config.mass;
+	}
+	/** A spring's slope never changes at a moment known in advance. */
+	kinksWithin(_dt) {
+		return false;
+	}
+	onUpdate(callback) {
+		return this.#emitter.on("update", callback);
+	}
+	onStart(callback) {
+		return this.#emitter.on("start", callback);
+	}
+	onStop(callback) {
+		return this.#emitter.on("stop", callback);
+	}
+	onDispose(callback) {
+		return this.#emitter.on("dispose", callback);
+	}
+	dispose() {
+		this.#emitter.emit("dispose");
+		this.#emitter.clear();
+		this.#underdampedSolver = null;
+		this.#criticallyDampedSolver = null;
+		this.#overdampedSolver = null;
+		this.#currentSolver = null;
+	}
+	#syncStart() {
+		if (!this.#running && !this.#state.isResting) {
+			this.#running = true;
+			this.#emitter.emit("start");
 		}
-		for (let motion = heap.pop(); motion !== void 0; motion = heap.pop()) {
-			if (motion._pass === this.#pass) continue;
-			const edge = motion._edge;
-			if (edge !== null && this.#shouldRecouple(edge)) edge.recouple(h);
-			if (!this.#motions.has(motion)) continue;
-			motion._pass = this.#pass;
-			motion._advance(motion._rank === -1 ? dt : h);
-			if (motion._frame !== frame) {
-				motion._frame = frame;
-				advanced.push(motion);
-			}
-			if (motion.isResting) this.#motions.delete(motion);
-			const followers = motion._followers;
-			if (followers !== null) for (const out of followers) heap.push(out.follower);
+	}
+	#updateSolver() {
+		if (this.#config.dampingRatio < 1) {
+			this.#underdampedSolver ||= new UnderdampedSolver(this.#state);
+			this.#currentSolver = this.#underdampedSolver;
+		} else if (this.#config.dampingRatio === 1) {
+			this.#criticallyDampedSolver ||= new CriticallyDampedSolver(this.#state);
+			this.#currentSolver = this.#criticallyDampedSolver;
+		} else {
+			this.#overdampedSolver ||= new OverdampedSolver(this.#state);
+			this.#currentSolver = this.#overdampedSolver;
 		}
-	}
-	#settle(advanced) {
-		for (const motion of advanced) motion._settleFrame();
-	}
-	#shouldRecouple(edge) {
-		for (const leader of edge.leaders) if (leader._pass === this.#pass || this.#motions.has(leader)) return true;
-		return false;
-	}
-	#shouldPlan(edge) {
-		for (const leader of edge.leaders) if (this.#motions.has(leader)) return true;
-		return false;
+		this.#currentSolver.configure(this.#config);
 	}
 };
 //#endregion
 //#region src/spring.ts
 /**
 * One animated number, driven toward its target with damped spring
-* motion. Create springs with `SpringSystem.createSpring`; the owning
-* system advances them, so a spring only moves while its system runs.
+* motion. Create springs with `SpringSystem.createSpring`. A spring moves
+* only when its system advances it.
 *
-* Reads return the exact simulated state; nothing is rounded. Numeric
-* writes — `target`, `value`, `velocity`, `jumpTo` — require finite
-* numbers: `NaN` or an infinity throws rather than poisoning the
-* simulation. See
-* https://github.com/tkofh/coily/blob/main/PRECISION.md for the
-* numerical contract.
+* Reads return the exact, unrounded simulated state. Numeric writes
+* (`target`, `value`, `velocity`, `jumpTo`) throw on `NaN` or an
+* infinity. See https://github.com/tkofh/coily/blob/main/PRECISION.md
+* for the numerical contract.
 */
 var Spring = class {
-	/** Brands the spring as a `KinematicSource` whose api is the spring itself. */
+	/** Brands the spring as a `TargetedSource` whose api is the spring itself. */
 	get [SpringSourceSymbol]() {
 		registerBacking(this, this.#motion);
 		return this;
@@ -1273,38 +1423,40 @@ var Spring = class {
 	#disposed = false;
 	constructor(motions, value, config, purpose = "motion") {
 		invariant(Number.isFinite(value), "Spring value must be a finite number");
-		invariant(purpose === "motion" || purpose === "appearance", "Spring purpose must be 'motion' or 'appearance'");
+		invariant(purpose === "motion" || purpose === "nonmotion", "Spring purpose must be 'motion' or 'nonmotion'");
 		this.#motions = motions;
 		this.#config = config ?? SpringDefinition.default;
 		this.#target = value;
 		this.#purpose = purpose;
-		this.#motion = new Motion(this.#config, 0, 0);
-		this.#motion.respectsReducedMotion = purpose === "motion";
+		this.#motion = new SpringMotion(this.#config, 0, 0, purpose);
 	}
 	/**
 	* The value the spring is animating toward. While following a source,
 	* reads return the source's value as of its last update.
 	*
 	* Assignment accepts any `SpringTarget`:
-	* - A number retargets the spring. The current value and momentum carry
-	*   over, so mid-flight retargets stay smooth. Assigning a number while
-	*   following also stops the following.
-	* - A `SpringSource` — a `Spring`, or a value derived with `mapSpring` —
+	* - A number retargets smoothly, keeping the current value and velocity.
+	*   It also ends any following.
+	* - A `SpringSource` (a `Spring`, or a value derived with `mapSpring`)
 	*   makes this spring follow the source's live value.
 	*
-	* Under reduced motion, retargets apply instantly — unless `purpose` is
-	* `'appearance'`, in which case they animate as normal.
+	* Under reduced motion, retargets apply instantly unless `purpose` is
+	* `'nonmotion'`.
 	*/
 	get target() {
 		return this.#target;
 	}
 	set target(value) {
+		this.#assertLive();
 		if (typeof value === "number") {
+			invariant(Number.isFinite(value), "Spring target must be a finite number");
 			this.#unfollow();
 			this.#setTarget(value);
 		} else {
 			invariant(isSpringSource(value), "Spring target must be a number or a SpringSource");
-			invariant(typeof value[SpringSourceSymbol].value === "number", "A spring can only follow a scalar SpringSource; derive one from a composite with mapSpring");
+			const current = value[SpringSourceSymbol].value;
+			invariant(typeof current === "number", "A spring can only follow a scalar SpringSource; derive one from a composite with mapSpring");
+			invariant(Number.isFinite(current), "Spring target must be a finite number");
 			this.#follow(value);
 		}
 	}
@@ -1312,16 +1464,16 @@ var Spring = class {
 	* The current animated value: the target plus the remaining
 	* displacement.
 	*
-	* Writing displaces the spring: it keeps its target and springs back
-	* from the written value, notifying update listeners synchronously.
-	* Writing the current value is a no-op. Under reduced motion a write
-	* jumps the spring — target included — to the written value, unless
-	* `purpose` is `'appearance'`, in which case it displaces as normal.
+	* Writing displaces the spring. It keeps its target, springs back from
+	* the written value, and notifies update listeners synchronously.
+	* Writing the current value is a no-op. Under reduced motion, a write
+	* jumps value and target together unless `purpose` is `'nonmotion'`.
 	*/
 	get value() {
 		return this.#target + this.#motion.position;
 	}
 	set value(value) {
+		this.#assertLive();
 		invariant(Number.isFinite(value), "Spring value must be a finite number");
 		if (this.#motions.reduced && this.#purpose === "motion") {
 			if (value !== this.value) this.jumpTo(value);
@@ -1337,36 +1489,32 @@ var Spring = class {
 	/**
 	* The current velocity, in value units per second.
 	*
-	* Writing flings the spring: motion continues from the current value
-	* with the written velocity, then settles back to the target. Under
-	* reduced motion writes are ignored, unless `purpose` is `'appearance'`,
-	* in which case the fling applies as normal.
+	* Writing flings the spring from its current value, and it settles back
+	* to the target. Under reduced motion, the write is ignored unless
+	* `purpose` is `'nonmotion'`.
 	*/
 	get velocity() {
 		return this.#motion.velocity;
 	}
 	set velocity(value) {
+		this.#assertLive();
 		invariant(Number.isFinite(value), "Spring velocity must be a finite number");
 		if (this.#motions.reduced && this.#purpose === "motion") return;
 		this.#motions.add(this.#motion);
 		this.#motion.velocity = value;
 	}
 	/**
-	* The current acceleration, in value units per second squared — how
-	* fast the velocity is changing. Read-only: acceleration is the
-	* spring's stiffness and friction acting on its current displacement
-	* and velocity, so it follows from the motion rather than being set.
-	* To fling the spring, write `velocity` instead.
+	* The current acceleration, in value units per second squared.
+	* Read-only, because stiffness and friction derive it from the current
+	* displacement and velocity. To fling the spring, write `velocity`.
 	*/
 	get acceleration() {
-		const { tension, damping, mass } = this.#config;
-		return -(tension * this.#motion.position + damping * this.#motion.velocity) / mass;
+		return this.#motion.acceleration;
 	}
 	/**
-	* What the spring animates — `'motion'` or `'appearance'` — fixed when
-	* it was created. An `'appearance'` spring opts out of reduced motion:
-	* it keeps animating where a `'motion'` spring snaps to its target. See
-	* `Purpose`.
+	* What the spring animates, fixed at creation. Under reduced motion, a
+	* `'motion'` spring snaps to its target and a `'nonmotion'` spring keeps
+	* animating. See `Purpose`.
 	*/
 	get purpose() {
 		return this.#purpose;
@@ -1374,12 +1522,11 @@ var Spring = class {
 	/**
 	* The spring's `SpringDefinition`: the one it was created with or last
 	* assigned, otherwise `SpringDefinition.default`. Following a source
-	* never changes it — how a spring chases its target is the spring's
-	* own setting.
+	* never changes it.
 	*
-	* Assigning a config reconfigures the spring in place — value and
-	* velocity are preserved, so mid-flight reconfigures stay smooth.
-	* Assigning `null` reverts to the default.
+	* Assigning reconfigures the spring in place, keeping value and
+	* velocity, so mid-flight changes stay smooth. `null` reverts to the
+	* default.
 	*/
 	get config() {
 		return this.#config;
@@ -1400,15 +1547,16 @@ var Spring = class {
 	get dampingRatio() {
 		return this.#config.dampingRatio;
 	}
-	/** The config's resting precision. */
+	/** The config's precision: decimal places of the resting threshold. */
 	get precision() {
 		return this.#config.precision;
 	}
-	/** The config's arrival multiplier. */
+	/** The config's arrival multiplier, applied to the velocity at each target crossing. */
 	get arrival() {
 		return this.#config.arrival;
 	}
 	set config(value) {
+		this.#assertLive();
 		const next = value ?? SpringDefinition.default;
 		if (this.#config === next) return;
 		this.#config = next;
@@ -1416,12 +1564,12 @@ var Spring = class {
 		if (!this.#motion.isResting) this.#motions.add(this.#motion);
 	}
 	/**
-	* Milliseconds until the spring rests: 0 while resting, Infinity when
-	* the motion never settles. The time is solved from the motion, not
-	* estimated — the spring is resting at the first tick at or after it,
-	* and a bouncy spring can rest up to one oscillation earlier when a
-	* frame samples a low pulse. When the config's `arrival` is 0, it is
-	* capped at the exact ms of the first target crossing.
+	* The time until the spring rests, in ms, solved from the motion: 0
+	* while resting, `Infinity` when it never settles. The spring rests at
+	* the first tick at or after this time. A bouncy spring can rest up to
+	* one oscillation earlier, when a frame samples a low point of the
+	* bounce. With `arrival: 0`, the time is capped at the first target
+	* crossing, exact to the ms.
 	*/
 	get timeRemaining() {
 		return this.#motion.timeRemaining;
@@ -1436,9 +1584,9 @@ var Spring = class {
 		return this.#motion.isResting;
 	}
 	/**
-	* A promise that resolves when the spring next comes to rest — already
-	* resolved while resting or after dispose. Retargeting mid-flight
-	* extends the wait; disposing resolves it.
+	* A promise that resolves when the spring next rests or is disposed.
+	* It is already resolved while the spring rests and after dispose.
+	* Retargeting mid-flight extends the wait.
 	*
 	* @example
 	* ```ts
@@ -1461,21 +1609,22 @@ var Spring = class {
 		return this.#settled;
 	}
 	/**
-	* Snaps the spring to `value` with no animation: target and value both
-	* become `value` and velocity clears. Listeners are notified
-	* synchronously — `update`, plus `stop` if the spring was moving.
+	* Snaps target and value to `value` and zeroes the velocity, with no
+	* animation. Listeners fire synchronously: `update`, plus `stop` if the
+	* spring was moving.
 	*/
 	jumpTo(value) {
+		this.#assertLive();
 		invariant(Number.isFinite(value), "Spring value must be a finite number");
 		this.#target = value;
 		this.#motion.finish();
 	}
 	/**
-	* Releases the spring permanently: stops following, detaches followers
-	* (each keeps its current target), resolves `settled`, and notifies
-	* dispose listeners. Calling it again is a no-op.
+	* Releases the spring permanently. It stops following, detaches
+	* followers (each keeps its current target), resolves `settled`, and
+	* notifies dispose listeners. Calling it again is a no-op.
 	*
-	* A disposed spring keeps its final value readable; writes throw.
+	* A disposed spring keeps its final value readable. Writes throw.
 	*/
 	dispose() {
 		if (this.#disposed) return;
@@ -1503,7 +1652,7 @@ var Spring = class {
 	}
 	/**
 	* Subscribes to the spring leaving rest. `start` and `stop` always
-	* alternate; retargeting mid-flight fires neither. Returns an
+	* alternate, and retargeting mid-flight fires neither. Returns an
 	* unsubscribe function.
 	*/
 	onStart(callback) {
@@ -1521,6 +1670,9 @@ var Spring = class {
 	onDispose(callback) {
 		return this.#motion.onDispose(callback);
 	}
+	#assertLive() {
+		invariant(!this.#disposed, "Cannot write to a disposed spring");
+	}
 	#setTarget(value) {
 		invariant(Number.isFinite(value), "Spring target must be a finite number");
 		if (value !== this.#target) {
@@ -1550,38 +1702,46 @@ var Spring = class {
 			const edge = {
 				follower: this.#motion,
 				leaders,
-				_cyclic: false,
-				_prevValue: 0,
-				_d1: 0,
-				_d2: 0,
+				cyclic: false,
+				trail: new TargetTrail(0),
 				recouple: (h) => {
-					if (edge._cyclic || h === 0 || this.#config.arrival !== 1 || this.#motions.reduced && this.#purpose === "motion") {
+					if (this.#motions.reduced && this.#purpose === "motion") {
+						const value = api.value;
+						invariant(Number.isFinite(value), "Spring target must be a finite number");
+						if (value === this.#target) return;
+						this.#target = value;
+						this.#motions.add(this.#motion);
+						this.#motion.rest();
+						return;
+					}
+					if (edge.cyclic || h === 0 || this.#config.arrival !== 1) {
 						this.#setTarget(api.value);
 						return;
 					}
 					const value = api.value;
 					invariant(Number.isFinite(value), "Spring target must be a finite number");
-					if (value === this.#target) return;
+					const previous = this.#target;
+					if (value === previous) return;
 					this.#motions.add(this.#motion);
-					this.#motion._ramp = (value - this.#target) / h;
 					this.#target = value;
+					this.#motion.armSlope((value - previous) / h);
 				},
 				plan: (dt) => {
-					const target = this.#target;
-					const d = target - edge._prevValue;
-					edge._d2 = edge._d1;
-					edge._d1 = d;
-					edge._prevValue = target;
+					const trail = edge.trail;
+					const d = trail.observe(this.#target);
 					let dHat = Math.abs(d);
-					let error = Math.abs(d - edge._d2) / 8;
-					for (const leader of leaders) if (leader._manifoldDeviation() > 4 * Math.abs(d)) {
-						const accel = Math.abs(leader._acceleration());
-						const speed = Math.abs(leader.velocity);
-						dHat = Math.max(dHat, speed * dt + .5 * accel * dt * dt);
-						error = Math.max(error, accel * dt * dt / 8);
+					let error = Math.abs(trail.curvature) / 8;
+					for (const leader of leaders) {
+						if (leader.kinksWithin(dt)) return Number.POSITIVE_INFINITY;
+						if (leader.manifoldDeviation() > 4 * Math.abs(d)) {
+							const accel = Math.abs(leader.acceleration);
+							const speed = Math.abs(leader.velocity);
+							dHat = Math.max(dHat, speed * dt + .5 * accel * dt * dt);
+							error = Math.max(error, accel * dt * dt / 8);
+						}
 					}
 					const tol = Math.max(this.#config.restingMagnitude, this.#motions.couplingTolerance);
-					return edge._cyclic || this.#config.arrival !== 1 ? Math.ceil(dHat / (2 * tol)) : Math.ceil(Math.sqrt(error / tol));
+					return edge.cyclic || this.#config.arrival !== 1 ? Math.ceil(dHat / (2 * tol)) : Math.ceil(Math.sqrt(error / tol));
 				}
 			};
 			this.#motions.graph.addEdge(edge);
@@ -1591,7 +1751,7 @@ var Spring = class {
 				this.#motions.graph.removeEdge(this.#motion);
 			};
 			this.#setTarget(api.value);
-			edge._prevValue = this.#target;
+			edge.trail.anchor(this.#target);
 			return;
 		}
 		this.#unsubLeader = () => {
@@ -1613,12 +1773,6 @@ var Spring = class {
 function invalidConfig(path) {
 	return `Invalid config for ${describePath(path)}: expected a SpringDefinition, null, or a config shape matching the value`;
 }
-/**
-* Decides what a config node means: `null` and `SpringDefinition` instances are
-* configs covering the whole subtree, any other object or array is a config
-* shape to descend into (its structure is checked on the way down), and
-* anything else — a bare number, string, or options object — is invalid.
-*/
 function resolveConfigNode(node, path) {
 	if (node === null) return null;
 	if (node instanceof SpringDefinition) return node;
@@ -1626,15 +1780,10 @@ function resolveConfigNode(node, path) {
 	throw new Error(invalidConfig(path));
 }
 function invalidPurpose(path) {
-	return `Invalid purpose for ${describePath(path)}: expected 'motion', 'appearance', or a purpose shape matching the value`;
+	return `Invalid purpose for ${describePath(path)}: expected 'motion', 'nonmotion', or a purpose shape matching the value`;
 }
-/**
-* Decides what a purpose node means: a `Purpose` string covers the whole
-* subtree, any object or array is a purpose shape to descend into, and
-* anything else is invalid.
-*/
 function resolvePurposeNode(node, path) {
-	if (node === "motion" || node === "appearance") return node;
+	if (node === "motion" || node === "nonmotion") return node;
 	if (isRecordOrArray(node)) return BRANCH;
 	throw new Error(invalidPurpose(path));
 }
@@ -1642,13 +1791,8 @@ const readTarget = (spring) => spring.target;
 const readValue = (spring) => spring.value;
 const readVelocity = (spring) => spring.velocity;
 const readAcceleration = (spring) => spring.acceleration;
-/**
-* The target scatter's leaf guard: a channel animates toward a number,
-* or follows a scalar source. Checked here so the error carries the
-* channel's path.
-*/
 function acceptChannelTarget(input, path) {
-	invariant(isNumber(input) && Number.isFinite(input) || isSpringSource(input) && typeof input[SpringSourceSymbol].value === "number", () => `Invalid value at '${path}': expected a finite number or a scalar SpringSource`);
+	invariant(isNumber(input) && Number.isFinite(input) || isSpringSource(input) && Number.isFinite(input[SpringSourceSymbol].value), () => `Invalid value at '${path}': expected a finite number or a scalar SpringSource`);
 	return input;
 }
 const assignTarget = (spring, value) => {
@@ -1670,24 +1814,22 @@ const followChannel = (mine, theirs) => {
 	mine.target = theirs;
 };
 /**
-* A composite spring over a fixed numeric shape — a nested plain object
+* A composite spring over a fixed numeric shape: a nested plain object
 * or array whose leaves are all numbers. Each leaf runs an independent
-* spring, called a channel, behind one API: targets, values, velocities,
-* and configs read and write as (partial) shapes, and events are
-* coalesced across channels. Create composite springs with
+* spring, called a channel. Targets, values, velocities, and configs read
+* and write as shapes, writes can name any subset of the channels, and
+* events coalesce across channels. Create one with
 * `SpringSystem.createSpring`.
 *
-* A composite spring is a `SpringSource` of its value shape: `mapSpring`
-* derives scalar sources from it — alone or at the leaves of a shape —
-* which springs can then follow. Only scalar sources are followable
-* directly.
+* A composite spring is a `SpringSource` of its value shape. Springs
+* follow only scalar sources, so use `mapSpring` to derive one from the
+* composite, alone or at the leaves of a shape.
 *
-* The shape is fixed at construction. Writes naming unknown channels
-* throw with the channel's path (`position.z`), and so do non-finite
-* channel values.
+* A write that names an unknown channel or gives one a non-finite value
+* throws with the channel's path (`position.z`) and changes nothing.
 */
 var CompositeSpring = class CompositeSpring {
-	/** Brands the composite as a `KinematicSource` whose api is the composite itself. */
+	/** Brands the composite as a `TargetedSource` whose api is the composite itself. */
 	get [SpringSourceSymbol]() {
 		registerBacking(this, this.#tree.leaves);
 		return this;
@@ -1719,6 +1861,12 @@ var CompositeSpring = class CompositeSpring {
 			this.#running = true;
 			this.#emitter.emit("start");
 		}
+		const resolve = this.#resolveSettled;
+		if (resolve !== null && !this.#running) {
+			this.#settled = null;
+			this.#resolveSettled = null;
+			resolve();
+		}
 	};
 	constructor(motions, value, config, purpose) {
 		this.#motions = motions;
@@ -1747,20 +1895,19 @@ var CompositeSpring = class CompositeSpring {
 	}
 	/**
 	* The value each channel is animating toward, as a read-only mirror of
-	* the shape. The mirror object is reused: every read refreshes its
-	* numbers in place, so read it fresh rather than holding it across
-	* frames.
+	* the shape. The mirror is reused and refreshed in place on each read,
+	* so read it fresh instead of holding it across frames.
 	*
 	* Assignment accepts a `CompositeSpringTarget`:
-	* - A partial shape retargets the channels it names and leaves the
-	*   others alone. Each named channel takes a number, or a scalar
-	*   `SpringSource` to follow — a `Spring`, or a value derived with
-	*   `mapSpring`. While following a leader, naming a channel also
-	*   detaches that channel from it.
-	* - A `CompositeSpring` of the same shape follows the leader channel by
-	*   channel.
+	* - A partial shape retargets the channels it names, each to a number
+	*   or to a scalar `SpringSource` to follow, such as a `Spring` or a
+	*   `mapSpring` result. Naming a channel detaches it from any leader.
+	* - A `CompositeSpring` of the same shape becomes the leader, and each
+	*   channel follows the matching leader channel.
 	*
-	* Unknown channels throw with their path.
+	* Unknown channels throw with their path. Under reduced motion,
+	* retargets apply instantly, except on channels whose `purpose` is
+	* `'nonmotion'`.
 	*/
 	get target() {
 		const view = this.#targetView ??= new ShapeView(this.#tree.root, readTarget);
@@ -1769,39 +1916,34 @@ var CompositeSpring = class CompositeSpring {
 	}
 	set target(value) {
 		if (value instanceof CompositeSpring) this.#follow(value);
-		else this.#motions.flushes.batch(() => {
-			this.#tree.root.scatter(value, acceptChannelTarget, assignTarget);
-		});
+		else this.#scatter(value, acceptChannelTarget, assignTarget);
 	}
 	/**
 	* The current animated value of every channel, as a read-only mirror of
-	* the shape. The mirror object is reused: every read refreshes its
-	* numbers in place, so read it fresh rather than holding it across
-	* frames.
+	* the shape. The mirror is reused and refreshed in place on each read,
+	* so read it fresh instead of holding it across frames.
 	*
-	* Assignment takes a partial shape and displaces the channels it names:
-	* each keeps its target and springs back from the written value, with
-	* one coalesced `update` fired synchronously. Under reduced motion a
-	* write jumps the named channels — targets included — except channels
-	* whose `purpose` is `'appearance'`, which displace as normal.
+	* Assignment displaces the channels a partial shape names. Each keeps
+	* its target and springs back from the written value. The write fires
+	* one coalesced `update` synchronously. Under reduced motion, the named
+	* channels jump to the written values, targets included, except on
+	* channels whose `purpose` is `'nonmotion'`.
 	*/
 	get value() {
 		this.#valueView.refresh();
 		return this.#valueView.root;
 	}
 	set value(value) {
-		this.#motions.flushes.batch(() => {
-			this.#tree.root.scatter(value, acceptNumber, assignValue);
-		});
+		this.#scatter(value, acceptNumber, assignValue);
 	}
 	/**
 	* The current velocity of every channel in value units per second, as a
-	* read-only mirror of the shape — reused and refreshed in place on each
-	* read.
+	* read-only mirror of the shape. The mirror is reused and refreshed in
+	* place on each read.
 	*
-	* Assignment takes a partial shape and flings the channels it names;
-	* the rest are untouched. Under reduced motion writes are ignored,
-	* except on channels whose `purpose` is `'appearance'`.
+	* Assignment flings the channels a partial shape names. Under reduced
+	* motion, writes are ignored, except on channels whose `purpose` is
+	* `'nonmotion'`.
 	*/
 	get velocity() {
 		const view = this.#velocityView ??= new ShapeView(this.#tree.root, readVelocity);
@@ -1809,15 +1951,12 @@ var CompositeSpring = class CompositeSpring {
 		return view.root;
 	}
 	set velocity(value) {
-		this.#motions.flushes.batch(() => {
-			this.#tree.root.scatter(value, acceptNumber, assignVelocity);
-		});
+		this.#scatter(value, acceptNumber, assignVelocity);
 	}
 	/**
 	* The current acceleration of every channel in value units per second
-	* squared, as a read-only mirror of the shape — reused and refreshed in
-	* place on each read. Read-only, like each channel's: acceleration
-	* follows from the motion. To fling channels, write `velocity`.
+	* squared, as a read-only mirror of the shape. The mirror is reused and
+	* refreshed in place on each read. To fling channels, write `velocity`.
 	*/
 	get acceleration() {
 		const view = this.#accelerationView ??= new ShapeView(this.#tree.root, readAcceleration);
@@ -1830,8 +1969,9 @@ var CompositeSpring = class CompositeSpring {
 	*
 	* Assignment accepts a `ConfigShape`: one config for every channel,
 	* `null` to revert every channel to the default, or a shape mirroring
-	* the value with configs at any level — a config at a subtree covers
-	* every channel below it. Non-config leaves throw with their path.
+	* the value whose configs each cover their subtree. Non-config leaves
+	* throw with their path. Assigning a `null` read back reverts every
+	* channel to the default rather than restoring the mix.
 	*/
 	get config() {
 		const channels = this.#tree.leaves;
@@ -1840,14 +1980,19 @@ var CompositeSpring = class CompositeSpring {
 		return first;
 	}
 	set config(value) {
+		this.#assertLive();
+		const root = this.#tree.root;
+		const config = value ?? null;
+		root.broadcast(config, resolveConfigNode, null, "config");
 		this.#motions.flushes.batch(() => {
-			this.#tree.root.broadcast(value ?? null, resolveConfigNode, assignConfig, "config");
+			root.broadcast(config, resolveConfigNode, assignConfig, "config");
 		});
 	}
 	/**
 	* The shared purpose when every channel resolves to the same `Purpose`,
-	* and `null` when they differ. Fixed when the spring is created — an
-	* `'appearance'` channel opts out of reduced motion. See `Purpose`.
+	* and `null` when they differ. The purposes are fixed when the spring is
+	* created. A `'nonmotion'` channel opts out of reduced motion. See
+	* `Purpose`.
 	*/
 	get purpose() {
 		const channels = this.#tree.leaves;
@@ -1855,7 +2000,7 @@ var CompositeSpring = class CompositeSpring {
 		for (let i = 1; i < channels.length; i++) if (channels[i].purpose !== first) return null;
 		return first;
 	}
-	/** The largest `timeRemaining` across channels, in milliseconds. */
+	/** The largest `timeRemaining` across channels, in ms. */
 	get timeRemaining() {
 		let max = 0;
 		for (const channel of this.#tree.leaves) {
@@ -1870,39 +2015,30 @@ var CompositeSpring = class CompositeSpring {
 		return true;
 	}
 	/**
-	* A promise that resolves when every channel next rests — already
-	* resolved while resting or after dispose. Retargeting any channel
-	* mid-flight extends the wait; disposing resolves it.
+	* A promise that resolves when every channel next rests. It is already
+	* resolved while the composite rests or after dispose. Retargeting any
+	* channel mid-flight extends the wait, and disposing resolves it.
 	*/
 	get settled() {
 		if (this.#disposed || this.isResting) return RESOLVED;
 		this.#settled ??= new Promise((resolve) => {
 			this.#resolveSettled = resolve;
-			const unsubscribe = this.onStop(() => {
-				unsubscribe();
-				this.#settled = null;
-				this.#resolveSettled = null;
-				resolve();
-			});
 		});
 		return this.#settled;
 	}
 	/**
-	* Snaps the channels the partial shape names to the given values with
-	* no animation, notifying listeners synchronously. Channels it leaves
-	* out are untouched.
+	* Snaps the channels a partial shape names to the given values with no
+	* animation, setting both target and value. Fires one `update`
+	* synchronously, plus `stop` if the jump leaves every channel resting.
 	*/
 	jumpTo(value) {
-		this.#motions.flushes.batch(() => {
-			this.#tree.root.scatter(value, acceptNumber, applyJump);
-		});
+		this.#scatter(value, acceptNumber, applyJump);
 	}
 	/**
-	* Releases every channel permanently: resolves `settled` and notifies
-	* dispose listeners. Calling it again is a no-op.
-	*
-	* A disposed composite spring keeps its final values readable; writes
-	* throw.
+	* Releases every channel permanently. Each channel stops following, and
+	* its followers detach and keep their current targets. `settled`
+	* resolves and dispose listeners fire. Calling it again is a no-op.
+	* Afterward, final values stay readable and writes throw.
 	*/
 	dispose() {
 		if (this.#disposed) return;
@@ -1916,25 +2052,26 @@ var CompositeSpring = class CompositeSpring {
 		this.#emitter.clear();
 	}
 	/**
-	* Subscribes to coalesced value changes: at most one `update` per tick,
-	* fired after every channel has advanced, plus one per synchronous
-	* write. Returns an unsubscribe function.
+	* Subscribes to coalesced value changes. `update` fires at most once per
+	* tick, after every channel advances, and once per synchronous write that
+	* moves a channel, such as a `value` write or `jumpTo`. Returns an
+	* unsubscribe function.
 	*/
 	onUpdate(callback) {
 		return this.#emitter.on("update", callback);
 	}
 	/**
-	* Subscribes to the composite leaving rest: a channel starts moving
-	* while all were resting. Always alternates with `stop`. Returns an
-	* unsubscribe function.
+	* Subscribes to the composite leaving rest. `start` fires when a channel
+	* starts to move and no other channel was moving. It always alternates
+	* with `stop`. Returns an unsubscribe function.
 	*/
 	onStart(callback) {
 		return this.#emitter.on("start", callback);
 	}
 	/**
-	* Subscribes to the composite coming to rest: every channel resting,
-	* fired after that tick's final `update`. Always alternates with
-	* `start`. Returns an unsubscribe function.
+	* Subscribes to the composite coming to rest. `stop` fires when every
+	* channel rests, after that tick's final `update`. It always alternates
+	* with `start`. Returns an unsubscribe function.
 	*/
 	onStop(callback) {
 		return this.#emitter.on("stop", callback);
@@ -1943,10 +2080,509 @@ var CompositeSpring = class CompositeSpring {
 	onDispose(callback) {
 		return this.#tree.leaves[0].onDispose(callback);
 	}
+	#assertLive() {
+		invariant(!this.#disposed, "Cannot write to a disposed spring");
+	}
+	#scatter(input, accept, apply) {
+		this.#assertLive();
+		const root = this.#tree.root;
+		root.scatter(input, accept, null);
+		this.#motions.flushes.batch(() => {
+			root.scatter(input, accept, apply);
+		});
+	}
 	#follow(leader) {
+		this.#assertLive();
+		const root = this.#tree.root;
+		root.zip(leader.#tree.root, null);
 		this.#motions.flushes.batch(() => {
-			this.#tree.root.zip(leader.#tree.root, followChannel);
+			root.zip(leader.#tree.root, followChannel);
+		});
+	}
+};
+//#endregion
+//#region src/ramp-motion.ts
+/**
+* A ramp's motion, computed from an anchor on the system clock.
+*
+* At clock time `t` the value is `anchorValue + speed * (t - anchorTime)`
+* toward the target, clamped there. Every write re-anchors at the
+* current value first. The ramp joins the tick only while an update
+* listener, or a stop listener on a bounded ramp, needs it per frame.
+* Outside the tick it still moves, but emits no frame events, not even
+* `stop` on arrival.
+*
+* Within an advance phase, `advance` steps a cached value by `speed * h`
+* per sub-step, so a follower recoupling mid-frame reads the sub-step's
+* position. Between phases, reads use the formula.
+*/
+var RampMotion = class extends Motion {
+	#motions;
+	#emitter = new Emitter();
+	/** Whether reduced motion applies: false for a `'nonmotion'` ramp. */
+	#reduces;
+	#anchorValue;
+	/** Clock seconds at which `#anchorValue` holds. */
+	#anchorTime;
+	#target;
+	/** Value units per second. */
+	#rate;
+	/** Whether the ramp is endless and holds still under reduced motion. */
+	#held = false;
+	#disposed = false;
+	/** Whether the ramp is in the set's `reducible` registry. */
+	#reducible = false;
+	/** The motion state listeners last heard: true after `start`, false after `stop`. */
+	#running;
+	#updateListeners = 0;
+	#stopListeners = 0;
+	/** The advance phase `#stepped` belongs to, or 0. */
+	#phase = 0;
+	#stepped = 0;
+	constructor(motions, from, rate, target, purpose) {
+		super();
+		this.#motions = motions;
+		this.#reduces = purpose === "motion";
+		this.#anchorValue = from;
+		this.#anchorTime = motions.time;
+		this.#target = target;
+		this.#rate = rate;
+		if (this.#reduces && motions.reduced) if (Number.isFinite(target)) this.#anchorValue = target;
+		else this.#held = true;
+		this.#running = !this.isResting;
+		this.#sync();
+	}
+	get value() {
+		if (this.#phase !== 0 && this.#phase === this.#motions.advancing) return this.#stepped;
+		return this.#at(this.#motions.time);
+	}
+	get target() {
+		return this.#target;
+	}
+	get rate() {
+		return this.#rate;
+	}
+	get isResting() {
+		return this.#speed() === 0 || this.value === this.#target;
+	}
+	get velocity() {
+		const value = this.value;
+		const speed = this.#speed();
+		if (speed === 0 || value === this.#target) return 0;
+		return this.#target > value ? speed : -speed;
+	}
+	/** Time until arrival, in ms: 0 at rest, Infinity while moving toward an infinite target. */
+	get timeRemaining() {
+		const value = this.value;
+		const speed = this.#speed();
+		if (speed === 0 || value === this.#target) return 0;
+		return Math.abs(this.#target - value) / speed * 1e3;
+	}
+	set value(value) {
+		this.#beginWrite();
+		if (value === this.value) return;
+		this.#anchorValue = value;
+		this.#anchorTime = this.#motions.time;
+		if (this.#reduces && this.#motions.reduced && Number.isFinite(this.#target)) this.#target = value;
+		this.#emitter.emit("update");
+		this.#sync();
+	}
+	set target(target) {
+		this.#beginWrite();
+		this.#reanchor();
+		this.#target = target;
+		const endless = !Number.isFinite(target);
+		if (this.#reduces && this.#motions.reduced) {
+			this.#held = endless;
+			if (!endless && this.#anchorValue !== target) {
+				this.#anchorValue = target;
+				this.#emitter.emit("update");
+			}
+		} else this.#held = false;
+		this.#sync();
+	}
+	set rate(rate) {
+		this.#beginWrite();
+		this.#reanchor();
+		this.#rate = rate;
+		this.#sync();
+	}
+	jumpTo(value) {
+		this.#beginWrite();
+		this.#anchorValue = value;
+		this.#anchorTime = this.#motions.time;
+		this.#target = value;
+		this.#held = false;
+		this.#emitter.emit("update");
+		this.#sync();
+	}
+	/**
+	* Applies a change of the reduced-motion setting: a bounded ramp
+	* finishes at its target, an endless one holds where it is, and a held
+	* ramp resumes from where it holds. Applying the current setting again
+	* changes nothing.
+	*/
+	applyReducedMotion(reduced) {
+		if (!this.#reduces || this.#disposed) return;
+		if (reduced) {
+			if (Number.isFinite(this.#target)) {
+				if (this.value !== this.#target) {
+					this.#anchorValue = this.#target;
+					this.#anchorTime = this.#motions.time;
+					this.#emitter.emit("update");
+				}
+			} else if (!this.#held) {
+				this.#reanchor();
+				this.#held = true;
+			}
+		} else if (this.#held) {
+			this.#reanchor();
+			this.#held = false;
+		}
+		this.#sync();
+	}
+	advance(h) {
+		const phase = this.#motions.advancing;
+		if (this.#phase !== phase) {
+			this.#phase = phase;
+			this.#stepped = this.#at(this.#motions.time);
+		}
+		const speed = this.#speed();
+		const remaining = this.#target - this.#stepped;
+		if (speed === 0 || remaining === 0) return;
+		const step = speed * h;
+		this.#stepped = Math.abs(remaining) <= step ? this.#target : this.#stepped + Math.sign(remaining) * step;
+	}
+	endFrame() {
+		if (this.#stepped === this.#target && this.#anchorValue !== this.#target) {
+			this.#anchorValue = this.#target;
+			this.#anchorTime = this.#motions.time;
+		}
+		this.#phase = 0;
+		this.#emitter.emit("update");
+		this.#sync();
+	}
+	/** 0: nothing knocks a ramp off its straight line. */
+	manifoldDeviation() {
+		return 0;
+	}
+	/** 0: a ramp's speed changes only at arrival and on writes. */
+	get acceleration() {
+		return 0;
+	}
+	/** True when a bounded ramp arrives within the next `dt` seconds, ending its slope there. */
+	kinksWithin(dt) {
+		const speed = this.#speed();
+		if (speed === 0 || !Number.isFinite(this.#target)) return false;
+		const arrival = Math.abs(this.#target - this.value) / speed;
+		return arrival > 0 && arrival <= dt;
+	}
+	onUpdate(callback) {
+		return this.#listen("update", callback);
+	}
+	onStart(callback) {
+		return this.#emitter.on("start", callback);
+	}
+	onStop(callback) {
+		return this.#listen("stop", callback);
+	}
+	onDispose(callback) {
+		return this.#emitter.on("dispose", callback);
+	}
+	dispose() {
+		if (this.#disposed) return;
+		this.#reanchor();
+		this.#disposed = true;
+		this.#emitter.emit("dispose");
+		this.#emitter.clear();
+		this.#sync();
+	}
+	get disposed() {
+		return this.#disposed;
+	}
+	#speed() {
+		return this.#held || this.#disposed ? 0 : this.#rate;
+	}
+	#at(time) {
+		const speed = this.#speed();
+		const remaining = this.#target - this.#anchorValue;
+		if (speed === 0 || remaining === 0) return this.#anchorValue;
+		const travel = speed * Math.max(0, time - this.#anchorTime);
+		return Math.abs(remaining) <= travel ? this.#target : this.#anchorValue + Math.sign(remaining) * travel;
+	}
+	#reanchor() {
+		const time = this.#motions.time;
+		this.#anchorValue = this.#at(time);
+		this.#anchorTime = time;
+	}
+	#beginWrite() {
+		invariant(!this.#disposed, "Cannot write to a disposed ramp");
+		this.#sync();
+	}
+	#listen(type, callback) {
+		this.#sync();
+		const off = this.#emitter.on(type, callback);
+		if (type === "update") this.#updateListeners++;
+		else this.#stopListeners++;
+		this.#sync();
+		let active = true;
+		return () => {
+			if (!active) return;
+			active = false;
+			off();
+			if (type === "update") this.#updateListeners--;
+			else this.#stopListeners--;
+			this.#sync();
+		};
+	}
+	#sync() {
+		const moving = !this.#disposed && !this.isResting;
+		const watched = this.#updateListeners > 0 || this.#stopListeners > 0 && Number.isFinite(this.#target);
+		const ticking = moving && watched;
+		if (ticking !== this.#motions.has(this)) if (ticking) this.#motions.add(this);
+		else this.#motions.remove(this);
+		const reducible = this.#reduces && !this.#disposed && (moving || this.#held);
+		if (reducible !== this.#reducible) {
+			this.#reducible = reducible;
+			if (reducible) this.#motions.reducible.add(this);
+			else this.#motions.reducible.delete(this);
+		}
+		if (moving !== this.#running) {
+			this.#running = moving;
+			this.#emitter.emit(moving ? "start" : "stop");
+		}
+	}
+};
+//#endregion
+//#region src/ramp.ts
+function assertRate(rate) {
+	invariant(Number.isFinite(rate) && rate >= 0, "Ramp rate must be a finite number >= 0");
+}
+function assertTarget(target) {
+	invariant(typeof target === "number" && !Number.isNaN(target), "Ramp target must be a number; use Infinity or -Infinity for an endless ramp");
+}
+function assertValue(value) {
+	invariant(Number.isFinite(value), "Ramp value must be a finite number");
+}
+/**
+* A value that moves toward its target at a fixed speed, in a straight
+* line, and stops there. Create ramps with `SpringSystem.createRamp`.
+*
+* A ramp is a `SpringSource`, so a spring can follow it. With the
+* default `arrival`, the spring integrates against the ramp's steady
+* motion exactly, where a target assigned once per frame would reach it
+* as a staircase. With any other `arrival`, the spring holds the target
+* still within each of a frame's sub-steps, one stair per sub-step.
+* Typical uses are an endless spin, a heading that turns at a capped
+* speed, and a clock in ms mapped into a shape with `mapSpring`.
+*
+* ```ts
+* const system = createSpringSystem()
+* const sweep = system.createRamp(0, { rate: 270, target: Infinity })
+* const ring = system.createSpring(sweep, defineSpring({ duration: 300, dampingRatio: 1 }))
+*
+* system.advance(1000)
+* sweep.value // 270
+* ```
+*
+* A ramp costs nothing per frame unless something watches it: an
+* `onUpdate` listener, a following spring, or, on a bounded ramp, an
+* `onStop` listener or a pending `settled`. An unwatched ramp still
+* moves, and a read reports where it is.
+*
+* Ramps move on the system clock. It counts frame time, `advance` calls,
+* and the time a started system spends asleep, and stops while the
+* system is stopped. A sleeping system skips the time the page is
+* hidden. An awake system gets no frames in a hidden tab, so the hidden
+* spell counts as one frame on return: `adjustedLag` ms if it lasted
+* longer than `lagThreshold`, in full otherwise or with lag clamping off.
+*
+* The clock holds still through synchronous code, so every read in one
+* event handler or render sees the same moment. A ramp created and read
+* with no `await` in between reads its starting value.
+*
+* Under reduced motion, a `'motion'` ramp jumps to a bounded target, and
+* an endless one holds still until reduced motion turns off, then
+* resumes. A `'nonmotion'` ramp keeps moving.
+*/
+var Ramp = class {
+	/** Brands the ramp as a `TargetedSource` whose api is the ramp itself. */
+	get [SpringSourceSymbol]() {
+		registerBacking(this, this.#motion);
+		return this;
+	}
+	#motion;
+	#purpose;
+	#settled = null;
+	#resolveSettled = null;
+	constructor(motions, from, options) {
+		invariant(typeof options === "object" && options !== null, "createRamp needs options with a rate");
+		const { rate, target = from, purpose = "motion" } = options;
+		assertValue(from);
+		assertRate(rate);
+		assertTarget(target);
+		invariant(purpose === "motion" || purpose === "nonmotion", "Ramp purpose must be 'motion' or 'nonmotion'");
+		this.#purpose = purpose;
+		this.#motion = new RampMotion(motions, from, rate, target, purpose);
+	}
+	/**
+	* The current value.
+	*
+	* Assignment accepts a finite number. It moves the ramp there at once,
+	* keeping its target and rate, and notifies update listeners
+	* synchronously. Writing the
+	* current value does nothing. Under reduced motion, a `'motion'` ramp
+	* with a bounded target rests at the written value, which becomes its
+	* target too.
+	*/
+	get value() {
+		return this.#motion.value;
+	}
+	set value(value) {
+		assertValue(value);
+		this.#motion.value = value;
+	}
+	/**
+	* Where the ramp is heading, or `Infinity` or `-Infinity` for an
+	* endless ramp.
+	*
+	* Assignment accepts any number but `NaN`, and sends the ramp toward the
+	* new target at its current rate.
+	* It emits `start` if the ramp was resting, and no `update`, since the
+	* value has not moved. Under reduced motion, a `'motion'` ramp jumps to
+	* a bounded target, notifying update listeners, and holds still toward
+	* an endless one.
+	*/
+	get target() {
+		return this.#motion.target;
+	}
+	set target(target) {
+		assertTarget(target);
+		this.#motion.target = target;
+	}
+	/**
+	* The ramp's speed, in value units per second.
+	*
+	* Assignment accepts any finite number >= 0 and applies from the
+	* current value on. A rate of 0 rests the ramp where it is.
+	*/
+	get rate() {
+		return this.#motion.rate;
+	}
+	set rate(rate) {
+		assertRate(rate);
+		this.#motion.rate = rate;
+	}
+	/**
+	* The current velocity, in value units per second. It is `rate`
+	* signed toward the target while the ramp moves, and 0 at rest.
+	*/
+	get velocity() {
+		return this.#motion.velocity;
+	}
+	/** Always 0, since a ramp moves at a constant speed. */
+	get acceleration() {
+		return 0;
+	}
+	/**
+	* What the ramp drives, `'motion'` or `'nonmotion'`, fixed when the
+	* ramp was created. A `'nonmotion'` ramp ignores reduced motion. See
+	* `Purpose`.
+	*/
+	get purpose() {
+		return this.#purpose;
+	}
+	/**
+	* Whether the ramp is still: at its target, at a rate of 0, held under
+	* reduced motion, or disposed.
+	*/
+	get isResting() {
+		return this.#motion.isResting;
+	}
+	/**
+	* The time until the ramp reaches its target, in ms. It is 0 at rest,
+	* and `Infinity` while the ramp moves toward an endless target.
+	*/
+	get timeRemaining() {
+		return this.#motion.timeRemaining;
+	}
+	/**
+	* A promise that resolves when the ramp next comes to rest. Already
+	* resolved while the ramp rests and after dispose. A pending
+	* `settled` keeps a bounded ramp in the frame loop, so the promise
+	* resolves on the frame the ramp arrives.
+	*
+	* ```ts
+	* ramp.target = 100
+	* await ramp.settled
+	* // the ramp is at 100
+	* ```
+	*/
+	get settled() {
+		if (this.#motion.disposed || this.#motion.isResting) return RESOLVED;
+		this.#settled ??= new Promise((resolve) => {
+			this.#resolveSettled = resolve;
+			const unsubscribe = this.onStop(() => {
+				unsubscribe();
+				this.#settled = null;
+				this.#resolveSettled = null;
+				resolve();
+			});
 		});
+		return this.#settled;
+	}
+	/**
+	* Rests the ramp at `value`, which becomes both its value and target.
+	* Notifies update listeners synchronously, and emits `stop` if the ramp
+	* was moving.
+	*/
+	jumpTo(value) {
+		assertValue(value);
+		this.#motion.jumpTo(value);
+	}
+	/**
+	* Releases the ramp permanently. It stops where it is, `settled`
+	* resolves, and dispose listeners run. Followers detach and keep their
+	* current target. Calling it again does nothing.
+	*
+	* The final value stays readable, and writes throw.
+	*/
+	dispose() {
+		if (this.#motion.disposed) return;
+		const resolve = this.#resolveSettled;
+		this.#settled = null;
+		this.#resolveSettled = null;
+		this.#motion.dispose();
+		resolve?.();
+	}
+	/**
+	* Subscribes to value changes: every frame the ramp moves, plus
+	* synchronous `value` writes, `jumpTo` calls, and reduced-motion jumps.
+	* A subscribed listener keeps the ramp in the frame loop. Returns an
+	* unsubscribe function.
+	*/
+	onUpdate(callback) {
+		return this.#motion.onUpdate(callback);
+	}
+	/**
+	* Subscribes to the ramp leaving rest. `start` and `stop` alternate.
+	* Returns an unsubscribe function.
+	*/
+	onStart(callback) {
+		return this.#motion.onStart(callback);
+	}
+	/**
+	* Subscribes to the ramp coming to rest: arriving at its target,
+	* `jumpTo`, a rate of 0, or holding under reduced motion. A subscribed
+	* listener keeps a bounded ramp in the frame loop, so the event fires
+	* on the frame it arrives. Returns an unsubscribe function.
+	*/
+	onStop(callback) {
+		return this.#motion.onStop(callback);
+	}
+	/** Subscribes to `dispose`, which fires once. Returns an unsubscribe function. */
+	onDispose(callback) {
+		return this.#motion.onDispose(callback);
 	}
 };
 //#endregion
@@ -1956,11 +2592,18 @@ const cancel = (id) => {
 	if (typeof window !== "undefined") window.cancelAnimationFrame(id);
 	else clearTimeout(id);
 };
+const now = () => performance.now();
 /**
-* Drives a `MotionSet` from animation frames. Schedules frames only
-* while motions exist — otherwise it sleeps and the set's `onWake`
-* rearms it — paces fps caps to whole display frames, and clamps lag
-* gaps.
+* Drives a `MotionSet` from animation frames, pacing fps caps to whole
+* display frames and clamping lag. It requests frames only while the set
+* has motions, and otherwise sleeps until the set's `onWake` rearms it.
+*
+* While started and asleep, it credits idle wall time to the set's clock,
+* less any time the document is hidden. An awake set gets no frames in a
+* hidden tab, so the gap arrives as one frame, clamped like any lag.
+*
+* Idle time reads the wall clock once per microtask checkpoint, so the
+* clock holds still through synchronous code, as it does between frames.
 */
 var Ticker = class {
 	#fps;
@@ -1968,7 +2611,12 @@ var Ticker = class {
 	#capGap;
 	#lagThreshold;
 	#adjustedLag;
-	#motion;
+	/** Frame gaps longer than this count as lag: `#lagThreshold`, or Infinity when 0 disables clamping. */
+	#lagLimit = 0;
+	/** The ms a lagging frame steps: `#adjustedLag` clamped to `#lagThreshold`. */
+	#lagStep = 0;
+	#motions;
+	#onVisibility = () => this.#onVisibilityChange();
 	#frame = 0;
 	#time = 0;
 	#delta = 0;
@@ -1978,8 +2626,20 @@ var Ticker = class {
 	#id = 0;
 	#stopped = true;
 	#sleeping = false;
+	/** Whether a frame callback is running. Its `finally` schedules the next frame. */
+	#inFrame = false;
+	/** Wall ms when the current idle spell began, or null outside one. */
+	#idleSince = null;
+	/** Hidden ms already closed out within the current idle spell. */
+	#hiddenIdle = 0;
+	/** Wall ms when the document was last hidden, or null while visible. */
+	#hiddenSince = null;
+	/** The wall ms synchronous code reads until the next microtask checkpoint, or null until it first reads. */
+	#taskTime = null;
+	/** The latest task time, so a frame never credits the clock back past a read. */
+	#lastTaskTime = 0;
 	constructor(motions, options) {
-		this.#motion = motions;
+		this.#motions = motions;
 		const fps = options?.fps ?? 0;
 		const lagThreshold = options?.lagThreshold ?? 500;
 		const adjustedLag = options?.adjustedLag ?? 33;
@@ -1989,9 +2649,15 @@ var Ticker = class {
 		this.#fps = fps;
 		this.#gap = fps === 0 ? 1e3 / 60 : 1e3 / fps;
 		this.#capGap = fps === 0 ? 0 : 1e3 / fps;
-		this.#lagThreshold = lagThreshold === 0 ? 1e8 : lagThreshold;
-		this.#adjustedLag = Math.min(adjustedLag, this.#lagThreshold);
+		this.#lagThreshold = lagThreshold;
+		this.#adjustedLag = adjustedLag;
+		this.#updateLag();
 		motions.onWake = () => this.#wake();
+		motions.idleTime = () => this.#idleSince === null ? 0 : this.#idleMs(this.#taskNow()) / 1e3;
+		if (typeof document !== "undefined") {
+			if (document.visibilityState === "hidden") this.#hiddenSince = this.#taskNow();
+			document.addEventListener("visibilitychange", this.#onVisibility);
+		}
 	}
 	get fps() {
 		return this.#fps;
@@ -2007,15 +2673,16 @@ var Ticker = class {
 	}
 	set lagThreshold(value) {
 		invariant(value >= 0, "Lag threshold must be greater than or equal to 0");
-		this.#lagThreshold = value === 0 ? 1e8 : value;
-		this.#adjustedLag = Math.min(this.#adjustedLag, this.#lagThreshold);
+		this.#lagThreshold = value;
+		this.#updateLag();
 	}
 	get adjustedLag() {
 		return this.#adjustedLag;
 	}
 	set adjustedLag(value) {
 		invariant(value >= 0, "Adjusted lag must be greater than or equal to 0");
-		this.#adjustedLag = Math.min(value, this.#lagThreshold);
+		this.#adjustedLag = value;
+		this.#updateLag();
 	}
 	get time() {
 		return this.#time;
@@ -2037,7 +2704,7 @@ var Ticker = class {
 			this.#stopped = false;
 			this.#primed = false;
 			this.#acc = 0;
-			this.#schedule();
+			if (!this.#inFrame) this.#schedule(this.#taskNow());
 		}
 	}
 	stop() {
@@ -2045,15 +2712,25 @@ var Ticker = class {
 			if (!this.#sleeping) cancel(this.#id);
 			this.#stopped = true;
 			this.#sleeping = false;
+			this.#creditIdle(this.#taskNow());
 		}
 	}
 	tick() {
 		this.#step(this.#gap);
 	}
-	#schedule() {
-		if (this.#motion.size === 0) {
+	/** Stops the ticker and removes its document listener. */
+	dispose() {
+		this.stop();
+		if (typeof document !== "undefined") document.removeEventListener("visibilitychange", this.#onVisibility);
+	}
+	#schedule(timestamp) {
+		if (this.#motions.size === 0) {
 			this.#sleeping = true;
 			this.#acc = 0;
+			if (this.#idleSince === null) {
+				this.#idleSince = timestamp;
+				this.#hiddenIdle = 0;
+			}
 		} else {
 			this.#sleeping = false;
 			this.#id = request((t) => this.#onFrame(t));
@@ -2062,83 +2739,131 @@ var Ticker = class {
 	#wake() {
 		if (!this.#stopped && this.#sleeping) {
 			this.#primed = false;
-			this.#schedule();
+			this.#schedule(this.#taskNow());
 		}
 	}
 	#onFrame(timestamp) {
 		if (this.#stopped) return;
+		this.#inFrame = true;
 		try {
 			if (this.#primed) {
 				const wallElapsed = timestamp - this.#lastWallTime;
-				const elapsed = wallElapsed > this.#lagThreshold ? this.#adjustedLag : wallElapsed;
+				const elapsed = wallElapsed > this.#lagLimit ? this.#lagStep : wallElapsed;
 				this.#acc += elapsed;
 				if (this.#acc + elapsed / 2 >= this.#capGap) {
 					const delta = this.#acc;
 					this.#acc = 0;
 					this.#step(delta);
 				}
-			} else this.#primed = true;
+			} else {
+				this.#primed = true;
+				this.#creditIdle(Math.max(timestamp, this.#lastTaskTime));
+			}
 		} finally {
 			this.#lastWallTime = timestamp;
-			if (!this.#stopped) this.#schedule();
+			this.#inFrame = false;
+			if (!this.#stopped) this.#schedule(timestamp);
+		}
+	}
+	#updateLag() {
+		this.#lagLimit = this.#lagThreshold === 0 ? Number.POSITIVE_INFINITY : this.#lagThreshold;
+		this.#lagStep = Math.min(this.#adjustedLag, this.#lagThreshold);
+	}
+	#idleMs(timestamp) {
+		const since = this.#idleSince;
+		if (since === null) return 0;
+		let hidden = this.#hiddenIdle;
+		if (this.#hiddenSince !== null) hidden += timestamp - Math.max(this.#hiddenSince, since);
+		return Math.max(0, timestamp - since - hidden);
+	}
+	#taskNow() {
+		if (this.#taskTime === null) {
+			const time = now();
+			this.#taskTime = time;
+			this.#lastTaskTime = time;
+			queueMicrotask(() => {
+				this.#taskTime = null;
+			});
+		}
+		return this.#taskTime;
+	}
+	#creditIdle(timestamp) {
+		if (this.#idleSince === null) return;
+		this.#motions.credit(this.#idleMs(timestamp) / 1e3);
+		this.#idleSince = null;
+	}
+	#onVisibilityChange() {
+		const timestamp = this.#taskNow();
+		if (document.visibilityState === "hidden") this.#hiddenSince ??= timestamp;
+		else if (this.#hiddenSince !== null) {
+			if (this.#idleSince !== null) this.#hiddenIdle += Math.max(0, timestamp - Math.max(this.#hiddenSince, this.#idleSince));
+			this.#hiddenSince = null;
 		}
 	}
 	#step(dt) {
 		this.#time += dt;
 		this.#frame++;
 		this.#delta = dt;
-		this.#motion.tick(dt / 1e3);
+		this.#motions.tick(dt / 1e3);
 	}
 };
 //#endregion
 //#region src/system.ts
 var SpringSystemImpl = class {
-	#motion;
+	#motions;
 	#ticker;
+	/** Removes the reduced-motion media query listener, or null without one. */
+	#unwatchReducedMotion = null;
+	#disposed = false;
 	constructor(options) {
-		this.#motion = new MotionSet(options?.debug);
-		this.#ticker = new Ticker(this.#motion, options);
+		this.#motions = new MotionSet(options?.debug);
+		this.#ticker = new Ticker(this.#motions, options);
 		if (options?.couplingTolerance !== void 0) this.couplingTolerance = options.couplingTolerance;
 		const mode = options?.reducedMotion ?? "user";
-		if (mode === "always") this.#motion.reduced = true;
+		if (mode === "always") this.#motions.reduced = true;
 		else if (mode === "user" && typeof window !== "undefined" && typeof window.matchMedia === "function") {
 			const query = window.matchMedia("(prefers-reduced-motion: reduce)");
 			this.#applyReducedMotion(query.matches);
-			query.addEventListener("change", (event) => {
+			const onChange = (event) => {
 				this.#applyReducedMotion(event.matches);
-			});
+			};
+			query.addEventListener("change", onChange);
+			this.#unwatchReducedMotion = () => query.removeEventListener("change", onChange);
 		}
 	}
 	#applyReducedMotion(reduced) {
-		this.#motion.reduced = reduced;
-		if (reduced) this.#motion.finishAll();
+		this.#motions.setReduced(reduced);
 	}
 	get reducedMotion() {
-		return this.#motion.reduced;
+		return this.#motions.reduced;
 	}
 	get couplingTolerance() {
-		return this.#motion.couplingTolerance;
+		return this.#motions.couplingTolerance;
 	}
 	set couplingTolerance(value) {
 		invariant(Number.isFinite(value) && value >= 0, "couplingTolerance must be a finite, non-negative number");
-		this.#motion.couplingTolerance = value;
+		this.#motions.couplingTolerance = value;
 	}
 	createSpring(value, config, options) {
-		if (typeof value === "number") return new Spring(this.#motion, value, config, options?.purpose);
+		if (typeof value === "number") return new Spring(this.#motions, value, config, options?.purpose);
 		if (isSpringSource(value)) {
 			const api = value[SpringSourceSymbol];
 			invariant(typeof api.value === "number", "A spring can only follow a scalar SpringSource; derive one from a composite with mapSpring");
-			const spring = new Spring(this.#motion, api.value, config, options?.purpose);
+			const spring = new Spring(this.#motions, api.value, config, options?.purpose);
 			spring.target = value;
 			return spring;
 		}
-		return new CompositeSpring(this.#motion, value, config, options?.purpose);
+		return new CompositeSpring(this.#motions, value, config, options?.purpose);
+	}
+	createRamp(from, options) {
+		return new Ramp(this.#motions, from, options);
 	}
 	advance(dt) {
-		invariant(Number.isFinite(dt), "dt must be a finite number of milliseconds");
-		this.#motion.tick(dt / 1e3);
+		invariant(Number.isFinite(dt) && dt >= 0, "dt must be a finite, non-negative number of milliseconds");
+		this.#motions.tick(dt / 1e3);
 	}
 	start() {
+		invariant(!this.#disposed, "Cannot start a disposed spring system");
 		this.#ticker.start();
 	}
 	stop() {
@@ -2147,6 +2872,13 @@ var SpringSystemImpl = class {
 	get running() {
 		return !this.#ticker.stopped;
 	}
+	dispose() {
+		if (this.#disposed) return;
+		this.#disposed = true;
+		this.#ticker.dispose();
+		this.#unwatchReducedMotion?.();
+		this.#unwatchReducedMotion = null;
+	}
 	get fps() {
 		return this.#ticker.fps;
 	}
@@ -2185,4 +2917,4 @@ function createSpringSystem(options) {
 	return new SpringSystemImpl(options);
 }
 //#endregion
-export { registerRecipe as a, mapSpring as i, SpringSourceSymbol as n, SpringDefinition as o, isSpringSource as r, defineSpring as s, createSpringSystem as t };
+export { SpringSourceSymbol as a, registerRecipe as c, defineSpring as i, CompositeSpring as n, isSpringSource as o, SpringDefinition as r, mapSpring as s, createSpringSystem as t };