coily 0.12.2 → 0.13.1

package/dist/system-Csho09XW.js

@@ -0,0 +1,1384 @@
+//#region src/flush-queue.ts
+var FlushQueue = class {
+	#callbacks = /* @__PURE__ */ new Set();
+	#depth = 0;
+	request(callback) {
+		if (this.#depth > 0) this.#callbacks.add(callback);
+		else callback();
+	}
+	batch(fn) {
+		this.enter();
+		try {
+			fn();
+		} finally {
+			this.exit();
+		}
+	}
+	enter() {
+		this.#depth++;
+	}
+	exit() {
+		this.#depth--;
+		if (this.#depth === 0) for (const callback of this.#callbacks) {
+			this.#callbacks.delete(callback);
+			callback();
+		}
+	}
+};
+//#endregion
+//#region src/motion-set.ts
+var MotionSet = class {
+	reduced = false;
+	onWake = null;
+	flushes = new FlushQueue();
+	#motions = /* @__PURE__ */ new Set();
+	#debug;
+	#lastSize = 0;
+	#pass = 0;
+	constructor(debug = false) {
+		this.#debug = debug;
+	}
+	get size() {
+		return this.#motions.size;
+	}
+	add(motion) {
+		const wasEmpty = this.#motions.size === 0;
+		this.#motions.add(motion);
+		if (wasEmpty) this.onWake?.();
+	}
+	remove(motion) {
+		this.#motions.delete(motion);
+	}
+	finishAll() {
+		this.flushes.batch(() => {
+			for (const motion of this.#motions) {
+				motion.finish();
+				this.#motions.delete(motion);
+			}
+		});
+	}
+	tick(dt) {
+		this.#pass++;
+		this.flushes.enter();
+		try {
+			for (const motion of this.#motions) {
+				if (motion._pass === this.#pass) continue;
+				motion._pass = this.#pass;
+				motion.tick(dt);
+				if (motion.isResting) this.#motions.delete(motion);
+			}
+		} finally {
+			this.flushes.exit();
+		}
+		if (this.#debug && this.#motions.size !== this.#lastSize) {
+			this.#lastSize = this.#motions.size;
+			console.log(`coily: ${this.#lastSize} active motions`);
+		}
+	}
+};
+//#endregion
+//#region src/util.ts
+function invariant(condition, message) {
+	if (condition) return;
+	const resolved = typeof message === "function" ? message() : message;
+	throw new Error(resolved ?? "Invariant Failed");
+}
+function isRecord(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+function isRecordOrArray(value) {
+	return isRecord(value) || Array.isArray(value);
+}
+function isArray(value) {
+	return Array.isArray(value);
+}
+function isNumber(value) {
+	return typeof value === "number";
+}
+//#endregion
+//#region src/config.ts
+/**
+* Immutable spring configuration. Instances are frozen — to change a spring's
+* behavior, assign a new config via `spring.config`.
+*/
+var SpringConfig = class SpringConfig {
+	static default = new SpringConfig({
+		dampingRatio: 1,
+		duration: 500
+	});
+	mass;
+	tension;
+	damping;
+	precision;
+	naturalFrequency;
+	criticalDamping;
+	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;
+		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");
+		this.precision = precision;
+		this.restingMagnitude = .5 / 10 ** precision;
+		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");
+			let sigmaCoeff;
+			if (dampingRatio < 1) sigmaCoeff = dampingRatio;
+			else if (dampingRatio === 1) sigmaCoeff = 1;
+			else sigmaCoeff = dampingRatio - Math.sqrt(dampingRatio ** 2 - 1);
+			invariant(sigmaCoeff > 0, "dampingRatio must be > 0 for duration-based config");
+			const wn = 2 * Math.log(x0 / threshold) / (sigmaCoeff * 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);
+	}
+	/**
+	* Analytically estimates the time remaining for a spring to come to rest,
+	* given the current displacement and velocity.
+	*
+	* Uses the exponential decay envelope common to all three damping regimes.
+	* The decay rate depends on the regime:
+	* - Underdamped (ζ < 1): σ = ζωₙ
+	* - Critically damped (ζ = 1): σ = ωₙ
+	* - Overdamped (ζ > 1): σ = (ζ - √(ζ²-1))ωₙ  (the slower eigenvalue)
+	*
+	* The effective initial amplitude accounts for both displacement and velocity,
+	* since kinetic energy can convert to additional displacement:
+	*   A₀ = |x₀| + |v₀| / ωₙ
+	*
+	* Settling time: t = ln(A₀ / threshold) / σ, with a 2× safety factor
+	* to account for polynomial terms in the critically damped solution.
+	*
+	* Returns the estimated time in milliseconds.
+	*/
+	computeTimeRemaining(state) {
+		const { position, velocity } = state;
+		const a0 = Math.abs(position) + Math.abs(velocity) / this.naturalFrequency;
+		if (a0 <= this.restingMagnitude) return 0;
+		let sigma;
+		if (this.dampingRatio < 1) sigma = this.dampingRatio * this.naturalFrequency;
+		else if (this.dampingRatio === 1) sigma = this.naturalFrequency;
+		else sigma = (this.dampingRatio - Math.sqrt(this.dampingRatio * this.dampingRatio - 1)) * this.naturalFrequency;
+		if (sigma <= 0) return Infinity;
+		return 2 * Math.log(a0 / this.restingMagnitude) / sigma * 1e3;
+	}
+};
+function defineSpring(input) {
+	return new SpringConfig(input);
+}
+//#endregion
+//#region src/emitter.ts
+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;
+		}
+	}
+};
+//#endregion
+//#region src/state.ts
+var State = class {
+	#config;
+	#position;
+	#velocity;
+	constructor(config, position, velocity) {
+		this.#config = config;
+		this.#position = position;
+		this.#velocity = velocity;
+	}
+	configure(config) {
+		this.#config = config;
+	}
+	get position() {
+		return this.#position;
+	}
+	set position(value) {
+		this.#position = value;
+	}
+	get velocity() {
+		return this.#velocity;
+	}
+	set velocity(value) {
+		this.#velocity = value;
+	}
+	get isResting() {
+		return Math.abs(this.#position) + Math.abs(this.#velocity) / this.#config.naturalFrequency <= this.#config.restingMagnitude;
+	}
+};
+//#endregion
+//#region src/solver.ts
+var UnderdampedSolver = class {
+	#state;
+	#dampedFrequency = 0;
+	#decayRate = 0;
+	#t = 0;
+	#c1 = 0;
+	#c2 = 0;
+	constructor(state) {
+		this.#state = state;
+	}
+	configure(config) {
+		if (config) {
+			this.#decayRate = config.dampingRatio * config.naturalFrequency;
+			this.#dampedFrequency = config.naturalFrequency * Math.sqrt(1 - config.dampingRatio ** 2);
+		}
+		this.#t = 0;
+		this.#c1 = this.#state.position;
+		this.#c2 = (this.#state.velocity + this.#decayRate * this.#state.position) / this.#dampedFrequency;
+	}
+	tick(dt) {
+		this.#t += dt;
+		const sin = Math.sin(this.#dampedFrequency * this.#t);
+		const cos = Math.cos(this.#dampedFrequency * this.#t);
+		const decay = Math.exp(-this.#decayRate * this.#t);
+		const decayVelocity = -this.#decayRate * decay;
+		const oscillation = this.#c1 * cos + this.#c2 * sin;
+		const oscillationVelocity = -this.#c1 * this.#dampedFrequency * sin + this.#c2 * this.#dampedFrequency * cos;
+		this.#state.position = decay * oscillation;
+		this.#state.velocity = decay * oscillationVelocity + decayVelocity * oscillation;
+	}
+};
+var CriticallyDampedSolver = class {
+	#state;
+	#naturalFrequency = 0;
+	#t = 0;
+	#c1 = 0;
+	#c2 = 0;
+	constructor(state) {
+		this.#state = state;
+	}
+	configure(config) {
+		if (config) this.#naturalFrequency = config.naturalFrequency;
+		this.#t = 0;
+		this.#c1 = this.#state.position;
+		this.#c2 = this.#state.velocity + this.#naturalFrequency * this.#state.position;
+	}
+	tick(dt) {
+		this.#t += dt;
+		const decay = Math.exp(-this.#naturalFrequency * this.#t);
+		const decayVelocity = -this.#naturalFrequency * decay;
+		const scale = this.#c1 + this.#c2 * this.#t;
+		const scaleVelocity = this.#c2;
+		this.#state.position = scale * decay;
+		this.#state.velocity = scaleVelocity * decay + decayVelocity * scale;
+	}
+};
+var OverdampedSolver = class {
+	#state;
+	#dampedFrequency = 0;
+	#decayRate = 0;
+	#t = 0;
+	#c1 = 0;
+	#c2 = 0;
+	constructor(state) {
+		this.#state = state;
+	}
+	configure(config) {
+		if (config) {
+			this.#decayRate = config.dampingRatio * config.naturalFrequency;
+			this.#dampedFrequency = config.naturalFrequency * Math.sqrt(config.dampingRatio ** 2 - 1);
+		}
+		this.#t = 0;
+		this.#c1 = this.#state.velocity + this.#decayRate * this.#state.position;
+		this.#c2 = this.#state.position * this.#dampedFrequency;
+	}
+	tick(dt) {
+		this.#t += dt;
+		const decay = Math.exp(-this.#decayRate * this.#t);
+		const decayVelocity = -this.#decayRate * decay;
+		const clamped = Math.min(this.#dampedFrequency * this.#t, 300);
+		const sinh = Math.sinh(clamped);
+		const cosh = Math.cosh(clamped);
+		const scale = this.#c1 * sinh + this.#c2 * cosh;
+		const scaleVelocity = this.#c1 * this.#dampedFrequency * cosh + this.#c2 * this.#dampedFrequency * sinh;
+		this.#state.position = scale * decay / this.#dampedFrequency;
+		this.#state.velocity = (scale * decayVelocity + scaleVelocity * decay) / this.#dampedFrequency;
+	}
+};
+//#endregion
+//#region src/motion.ts
+var Motion = class {
+	_pass = 0;
+	#config;
+	#state;
+	#underdampedSolver = null;
+	#criticallyDampedSolver = null;
+	#overdampedSolver = null;
+	#currentSolver = null;
+	#needsUpdate = false;
+	#needsReset = false;
+	#timeRemaining = 0;
+	#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();
+		this.#timeRemaining = this.#config.computeTimeRemaining(this.#state);
+	}
+	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.#timeRemaining;
+	}
+	get isResting() {
+		return this.#state.isResting;
+	}
+	configure(config) {
+		this.#config = config;
+		this.#state.configure(config);
+		this.#needsUpdate = true;
+		this.#syncStart();
+	}
+	tick(dt, emit = true) {
+		invariant(this.#currentSolver, "Cannot tick a disposed motion");
+		const needsTimeRemaining = this.#needsUpdate || this.#needsReset;
+		if (this.#needsUpdate) {
+			this.#updateSolver();
+			this.#needsUpdate = false;
+			this.#needsReset = false;
+		} else if (this.#needsReset) {
+			this.#currentSolver.configure();
+			this.#needsReset = false;
+		}
+		if (needsTimeRemaining) this.#timeRemaining = this.#config.computeTimeRemaining(this.#state);
+		this.#currentSolver.tick(dt);
+		this.#timeRemaining = Math.max(0, this.#timeRemaining - dt * 1e3);
+		if (this.#state.isResting) {
+			this.#state.position = 0;
+			this.#state.velocity = 0;
+			this.#needsReset = true;
+		}
+		if (emit) this.#emitter.emit("update");
+		if (this.#state.isResting) {
+			if (this.#running) {
+				this.#running = false;
+				this.#timeRemaining = 0;
+				this.#emitter.emit("stop");
+			}
+		} else if (!this.#running) {
+			this.#running = true;
+			this.#emitter.emit("start");
+		}
+	}
+	finish() {
+		this.position = 0;
+		this.velocity = 0;
+		this.tick(0);
+	}
+	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");
+		}
+	}
+	#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/spring.ts
+function normalizeTarget(target) {
+	if (target instanceof Spring) return {
+		spring: target,
+		offset: 0
+	};
+	if (typeof target === "object" && target !== null && "spring" in target && target.spring instanceof Spring) return {
+		spring: target.spring,
+		offset: target.offset ?? 0
+	};
+	return null;
+}
+const RESOLVED$1 = Promise.resolve();
+var Spring = class {
+	#target;
+	#override;
+	#resolved;
+	#motion;
+	#motions;
+	#followers = /* @__PURE__ */ new Set();
+	#leader = null;
+	#offset = 0;
+	#unsubLeader = null;
+	#settled = null;
+	#resolveSettled = null;
+	#disposed = false;
+	constructor(motions, position, config) {
+		this.#motions = motions;
+		let numericTarget;
+		let value;
+		let normalized = null;
+		if (typeof position === "number") {
+			numericTarget = position;
+			value = position;
+		} else {
+			normalized = normalizeTarget(position.target);
+			if (normalized) {
+				numericTarget = normalized.spring.value + normalized.offset;
+				value = position.value ?? numericTarget;
+			} else {
+				numericTarget = position.target ?? position.value ?? 0;
+				value = position.value ?? numericTarget;
+			}
+		}
+		if (motions.reduced) value = numericTarget;
+		this.#override = config ?? null;
+		this.#resolved = config ?? (normalized ? normalized.spring.#resolved : SpringConfig.default);
+		this.#target = numericTarget;
+		this.#motion = new Motion(this.#resolved, value - numericTarget, 0);
+		if (!this.#motion.isResting) this.#motions.add(this.#motion);
+		if (normalized) {
+			this.#leader = normalized.spring;
+			this.#offset = normalized.offset;
+			normalized.spring.#followers.add(this);
+			this.#unsubLeader = normalized.spring.onUpdate(() => {
+				this.#setTarget(this.#leader.value + this.#offset);
+			});
+		}
+	}
+	get target() {
+		return this.#target;
+	}
+	set target(value) {
+		if (typeof value === "number") {
+			this.#unfollow();
+			this.#setTarget(value);
+		} else {
+			const normalized = normalizeTarget(value);
+			this.#follow(normalized.spring, normalized.offset);
+		}
+	}
+	get value() {
+		return this.#target + this.#motion.position;
+	}
+	set value(value) {
+		if (this.#motions.reduced) {
+			if (value !== this.value) this.jumpTo(value);
+			return;
+		}
+		const position = value - this.#target;
+		if (position !== this.#motion.position) {
+			this.#motions.add(this.#motion);
+			this.#motion.position = position;
+			this.#motion.tick(0);
+		}
+	}
+	get velocity() {
+		return this.#motion.velocity;
+	}
+	set velocity(value) {
+		if (this.#motions.reduced) return;
+		this.#motions.add(this.#motion);
+		this.#motion.velocity = value;
+	}
+	get config() {
+		return this.#resolved;
+	}
+	get mass() {
+		return this.#resolved.mass;
+	}
+	get tension() {
+		return this.#resolved.tension;
+	}
+	get damping() {
+		return this.#resolved.damping;
+	}
+	get dampingRatio() {
+		return this.#resolved.dampingRatio;
+	}
+	get precision() {
+		return this.#resolved.precision;
+	}
+	set config(value) {
+		this.#override = value;
+		this.#applyConfig(value ?? (this.#leader ? this.#leader.#resolved : SpringConfig.default));
+	}
+	get timeRemaining() {
+		return this.#motion.timeRemaining;
+	}
+	get isResting() {
+		return this.#motion.isResting;
+	}
+	get settled() {
+		if (this.#disposed || this.#motion.isResting) return RESOLVED$1;
+		this.#settled ??= new Promise((resolve) => {
+			this.#resolveSettled = resolve;
+			const unsubscribe = this.onStop(() => {
+				unsubscribe();
+				this.#settled = null;
+				this.#resolveSettled = null;
+				resolve();
+			});
+		});
+		return this.#settled;
+	}
+	jumpTo(value) {
+		this.#target = value;
+		this.#motion.finish();
+	}
+	dispose() {
+		if (this.#disposed) return;
+		this.#disposed = true;
+		if (this.#resolveSettled) {
+			this.#resolveSettled();
+			this.#settled = null;
+			this.#resolveSettled = null;
+		}
+		if (this.#unsubLeader) {
+			this.#unsubLeader();
+			this.#unsubLeader = null;
+		}
+		if (this.#leader) {
+			this.#leader.#followers.delete(this);
+			this.#leader = null;
+		}
+		for (const follower of this.#followers) follower.#unfollow();
+		this.#motions.remove(this.#motion);
+		this.#motion.dispose();
+	}
+	onUpdate(callback) {
+		return this.#motion.onUpdate(callback);
+	}
+	onStart(callback) {
+		return this.#motion.onStart(callback);
+	}
+	onStop(callback) {
+		return this.#motion.onStop(callback);
+	}
+	onDispose(callback) {
+		return this.#motion.onDispose(callback);
+	}
+	#setTarget(value) {
+		if (value !== this.#target) {
+			if (this.#motions.reduced) {
+				this.jumpTo(value);
+				return;
+			}
+			this.#motions.add(this.#motion);
+			const current = this.value;
+			this.#target = value;
+			this.#motion.position = current - this.#target;
+			this.#motion.tick(0, false);
+		}
+	}
+	#follow(leader, offset) {
+		if (this.#unsubLeader) {
+			this.#unsubLeader();
+			this.#leader.#followers.delete(this);
+		}
+		this.#leader = leader;
+		this.#offset = offset;
+		leader.#followers.add(this);
+		if (this.#override === null) this.#applyConfig(leader.#resolved);
+		this.#unsubLeader = leader.onUpdate(() => {
+			this.#setTarget(this.#leader.value + this.#offset);
+		});
+		this.#setTarget(leader.value + offset);
+	}
+	#unfollow() {
+		if (!this.#leader) return;
+		this.#unsubLeader();
+		this.#unsubLeader = null;
+		this.#leader.#followers.delete(this);
+		this.#leader = null;
+		this.#offset = 0;
+		if (this.#override === null) this.#override = this.#resolved;
+	}
+	#applyConfig(next) {
+		if (this.#resolved === next) return;
+		this.#resolved = next;
+		this.#motion.configure(next);
+		if (!this.#motion.isResting) this.#motions.add(this.#motion);
+		for (const follower of this.#followers) if (follower.#override === null) follower.#applyConfig(next);
+	}
+};
+//#endregion
+//#region src/channel-tree-node.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");
+/**
+* One node of a shape's tree: a `LeafNode` wraps a single channel's leaf
+* object, `ListNode` and `RecordNode` carry the nesting. Every traversal is
+* an ordinary method each kind implements for itself, so call sites dispatch
+* without inspecting nodes; errors keep their dot paths because each node
+* stores the `path` it was built at.
+*/
+var ChannelTreeNode = class ChannelTreeNode {
+	/** This node's dot path from the root (`position.x`), fixed at construction. */
+	path;
+	constructor(path) {
+		this.path = path;
+	}
+	/** Parses a numeric shape into a node tree, appending each created leaf to `leaves`. */
+	static build(shape, path, factory, leaves) {
+		if (isArray(shape)) {
+			invariant(shape.length > 0, () => emptyShape(path));
+			return new ListNode(shape.map((child, i) => ChannelTreeNode.#child(child, joinPath(path, i), factory, leaves)), path);
+		}
+		const keys = Object.keys(shape);
+		invariant(keys.length > 0, () => emptyShape(path));
+		const children = /* @__PURE__ */ new Map();
+		for (const key of keys) children.set(key, ChannelTreeNode.#child(shape[key], joinPath(path, key), factory, leaves));
+		return new RecordNode(children, path);
+	}
+	static #child(value, path, factory, leaves) {
+		if (isNumber(value)) {
+			const leaf = factory(value, path);
+			leaves.push(leaf);
+			return new LeafNode(leaf, path);
+		}
+		invariant(isRecordOrArray(value), `Invalid value at '${path}': expected a number or a nested shape of numbers`);
+		return ChannelTreeNode.build(value, path, factory, leaves);
+	}
+};
+function emptyShape(path) {
+	return `Invalid value at ${describePath(path)}: a shape must contain at least one channel`;
+}
+var LeafNode = class LeafNode extends ChannelTreeNode {
+	leaf;
+	constructor(leaf, path) {
+		super(path);
+		this.leaf = leaf;
+	}
+	mirror(read, slots, carrier, key) {
+		carrier[key] = read(this.leaf);
+		slots.push({
+			leaf: this.leaf,
+			key,
+			carrier
+		});
+	}
+	scatter(input, apply) {
+		invariant(isNumber(input), `Expected a number for channel '${this.path}'`);
+		apply(this.leaf, input);
+	}
+	zip(theirs, values, label, fn) {
+		invariant(theirs instanceof LeafNode, () => `Shape mismatch at ${describePath(this.path)}`);
+		let value;
+		if (values !== void 0) {
+			invariant(isNumber(values), `Expected a number at '${this.path}' in ${label}`);
+			value = values;
+		}
+		fn(this.leaf, theirs.leaf, value, this.path);
+	}
+	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 extends ChannelTreeNode {
+	children;
+	constructor(children, path) {
+		super(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, 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], apply);
+		}
+	}
+	zip(theirs, values, label, fn) {
+		invariant(theirs instanceof ListNode && theirs.children.length === this.children.length, () => `Shape mismatch at ${describePath(this.path)}`);
+		let list;
+		if (values !== void 0) {
+			invariant(isArray(values), `Expected an array at ${describePath(this.path)} in ${label}`);
+			invariant(values.length <= this.children.length, `Unknown channel '${joinPath(this.path, this.children.length)}' in ${label}`);
+			list = values;
+		}
+		for (let i = 0; i < this.children.length; i++) this.children[i].zip(theirs.children[i], list?.[i], label, 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 extends ChannelTreeNode {
+	children;
+	constructor(children, path) {
+		super(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, 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, apply);
+		}
+	}
+	zip(theirs, values, label, fn) {
+		invariant(theirs instanceof RecordNode && theirs.children.size === this.children.size, () => `Shape mismatch at ${describePath(this.path)}`);
+		let record;
+		if (values !== void 0) {
+			invariant(isRecord(values), () => `Expected an object at ${describePath(this.path)} in ${label}`);
+			for (const key of Object.keys(values)) invariant(this.children.has(key), () => `Unknown channel '${joinPath(this.path, key)}' in ${label}`);
+			record = values;
+		}
+		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, record?.[key], label, 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 live view of a shape: `read(leaf)` at every leaf, mirrored into a stable
+* object — `refresh` rewrites the numbers in place through slots recorded at
+* construction, so per-frame reads do no traversal or allocation.
+*/
+var ChannelView = 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);
+	}
+};
+//#endregion
+//#region src/channel-tree.ts
+/**
+* A numeric shape — a plain object or array whose leaves are all numbers —
+* flattened into one leaf object per number, with the nesting preserved as a
+* tree of `ChannelTreeNode`s. The shape is fixed at construction. Knows nothing
+* about what the leaves are: construction, views, scatter, zip, and
+* broadcast are all structural; leaf semantics
+* live with the caller. Paths appear as dot-joined strings (`position.x`,
+* `color.2`) in every error.
+*/
+var ChannelTree = class {
+	#root;
+	#leaves = [];
+	constructor(shape, factory) {
+		invariant(isRecordOrArray(shape), "A shape must be a plain object or an array of numeric channels");
+		this.#root = ChannelTreeNode.build(shape, "", factory, this.#leaves);
+	}
+	/** Every leaf in depth-first shape order. */
+	get leaves() {
+		return this.#leaves;
+	}
+	/**
+	* Builds a live view of the shape with `read(leaf)` at every leaf —
+	* see `ChannelView`.
+	*/
+	createView(read) {
+		return new ChannelView(this.#root, read);
+	}
+	/**
+	* Scatters a partial numeric shape: `apply` runs for each channel the input
+	* mentions, the rest are untouched. Unknown channels and structure
+	* mismatches throw; `undefined` entries (and array holes) are skipped.
+	*/
+	scatter(input, apply) {
+		this.#root.scatter(input, apply);
+	}
+	/**
+	* Pairs this map's leaves with another map's, requiring the shapes to
+	* match exactly. `values` is an optional partial numeric shape (labelled
+	* `valuesLabel` in errors) delivered alongside each pair — absent entries
+	* arrive as `undefined`.
+	*/
+	zip(other, values, valuesLabel, fn) {
+		this.#root.zip(other.#root, values, valuesLabel, fn);
+	}
+	/**
+	* Broadcasts a covering shape — an input mirroring the shape where a value
+	* at any node covers every leaf below it. At each node, `resolve` decides
+	* whether the input is a value for the whole subtree or a branch to
+	* descend into; `apply` runs per covered leaf. `undefined` entries are
+	* skipped, unknown channels (labelled `label` in errors) throw.
+	*/
+	broadcast(input, resolve, apply, label) {
+		if (input === void 0) return;
+		this.#root.broadcast(input, resolve, apply, label);
+	}
+};
+//#endregion
+//#region src/spring-object.ts
+function invalidConfig(path) {
+	return `Invalid config for ${describePath(path)}: expected a SpringConfig, null, or a config shape matching the value`;
+}
+/**
+* Decides what a config node means: `null` and `SpringConfig` 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 SpringConfig) return node;
+	if (isRecordOrArray(node)) return BRANCH;
+	throw new Error(invalidConfig(path));
+}
+const readTarget = (spring) => spring.target;
+const readValue = (spring) => spring.value;
+const readVelocity = (spring) => spring.velocity;
+const assignTarget = (spring, value) => {
+	spring.target = value;
+};
+const assignValue = (spring, value) => {
+	spring.value = value;
+};
+const assignVelocity = (spring, value) => {
+	spring.velocity = value;
+};
+const applyJump = (spring, value) => {
+	spring.jumpTo(value);
+};
+const assignConfig = (spring, config) => {
+	spring.config = config;
+};
+const followChannel = (mine, theirs, offset) => {
+	mine.target = offset ? {
+		spring: theirs,
+		offset
+	} : theirs;
+};
+const RESOLVED = Promise.resolve();
+var SpringObject = class SpringObject {
+	#motions;
+	#map;
+	#targetView;
+	#valueView;
+	#velocityView;
+	#emitter = new Emitter();
+	#running = false;
+	#dirty = false;
+	#settled = null;
+	#resolveSettled = null;
+	#disposed = false;
+	#flush = () => {
+		if (this.#disposed) return;
+		if (this.#dirty) {
+			this.#dirty = false;
+			this.#emitter.emit("update");
+		}
+		if (this.#running) {
+			if (this.isResting) {
+				this.#running = false;
+				this.#emitter.emit("stop");
+			}
+		} else if (!this.isResting) {
+			this.#running = true;
+			this.#emitter.emit("start");
+		}
+	};
+	constructor(motions, value, config) {
+		this.#motions = motions;
+		invariant(isRecordOrArray(value), "Spring object value must be a plain object or an array of numeric channels");
+		this.#map = new ChannelTree(value, (leafValue) => new Spring(motions, leafValue));
+		if (config !== void 0) this.#map.broadcast(config, resolveConfigNode, assignConfig, "config");
+		this.#targetView = this.#map.createView(readTarget);
+		this.#valueView = this.#map.createView(readValue);
+		this.#velocityView = this.#map.createView(readVelocity);
+		const markDirty = () => {
+			this.#dirty = true;
+			this.#motions.flushes.request(this.#flush);
+		};
+		const schedule = () => {
+			this.#motions.flushes.request(this.#flush);
+		};
+		for (const channel of this.#map.leaves) {
+			channel.onUpdate(markDirty);
+			channel.onStart(schedule);
+			channel.onStop(schedule);
+		}
+	}
+	get target() {
+		this.#targetView.refresh();
+		return this.#targetView.root;
+	}
+	set target(value) {
+		if (value instanceof SpringObject) this.#follow(value, void 0);
+		else if (isRecord(value) && "spring" in value && value.spring instanceof SpringObject) {
+			const { spring, offset } = value;
+			this.#follow(spring, offset);
+		} else this.#motions.flushes.batch(() => {
+			this.#map.scatter(value, assignTarget);
+		});
+	}
+	get value() {
+		this.#valueView.refresh();
+		return this.#valueView.root;
+	}
+	set value(value) {
+		this.#motions.flushes.batch(() => {
+			this.#map.scatter(value, assignValue);
+		});
+	}
+	get velocity() {
+		this.#velocityView.refresh();
+		return this.#velocityView.root;
+	}
+	set velocity(value) {
+		this.#motions.flushes.batch(() => {
+			this.#map.scatter(value, assignVelocity);
+		});
+	}
+	get config() {
+		const channels = this.#map.leaves;
+		const first = channels[0].config;
+		for (let i = 1; i < channels.length; i++) if (channels[i].config !== first) return null;
+		return first;
+	}
+	set config(value) {
+		this.#motions.flushes.batch(() => {
+			this.#map.broadcast(value ?? null, resolveConfigNode, assignConfig, "config");
+		});
+	}
+	get timeRemaining() {
+		let max = 0;
+		for (const channel of this.#map.leaves) {
+			const remaining = channel.timeRemaining;
+			if (remaining > max) max = remaining;
+		}
+		return max;
+	}
+	get isResting() {
+		for (const channel of this.#map.leaves) if (!channel.isResting) return false;
+		return true;
+	}
+	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;
+	}
+	jumpTo(value) {
+		this.#motions.flushes.batch(() => {
+			this.#map.scatter(value, applyJump);
+		});
+	}
+	dispose() {
+		if (this.#disposed) return;
+		this.#disposed = true;
+		if (this.#resolveSettled) {
+			this.#resolveSettled();
+			this.#settled = null;
+			this.#resolveSettled = null;
+		}
+		for (const channel of this.#map.leaves) channel.dispose();
+		this.#emitter.clear();
+	}
+	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.#map.leaves[0].onDispose(callback);
+	}
+	#follow(leader, offset) {
+		this.#motions.flushes.batch(() => {
+			this.#map.zip(leader.#map, offset, "offset", followChannel);
+		});
+	}
+};
+//#endregion
+//#region src/ticker.ts
+const request = (callback) => typeof window !== "undefined" ? window.requestAnimationFrame(callback) : setTimeout(() => callback(performance.now()), 16);
+const cancel = (id) => {
+	if (typeof window !== "undefined") window.cancelAnimationFrame(id);
+	else clearTimeout(id);
+};
+var Ticker = class {
+	#fps;
+	#gap;
+	#capGap;
+	#lagThreshold;
+	#adjustedLag;
+	#motion;
+	#frame = 0;
+	#time = 0;
+	#delta = 0;
+	#acc = 0;
+	#lastWallTime = 0;
+	#primed = false;
+	#id = 0;
+	#stopped = true;
+	#sleeping = false;
+	constructor(motions, options) {
+		this.#motion = motions;
+		const fps = options?.fps ?? 0;
+		const lagThreshold = options?.lagThreshold ?? 500;
+		const adjustedLag = options?.adjustedLag ?? 33;
+		invariant(fps >= 0, "FPS must be greater than or equal to 0");
+		invariant(lagThreshold >= 0, "Lag threshold must be greater than or equal to 0");
+		invariant(adjustedLag >= 0, "Adjusted lag must be greater than or equal to 0");
+		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);
+		motions.onWake = () => this.#wake();
+	}
+	get fps() {
+		return this.#fps;
+	}
+	set fps(value) {
+		invariant(value >= 0, "FPS must be greater than or equal to 0");
+		this.#fps = value;
+		this.#gap = value === 0 ? 1e3 / 60 : 1e3 / value;
+		this.#capGap = value === 0 ? 0 : 1e3 / value;
+	}
+	get lagThreshold() {
+		return this.#lagThreshold;
+	}
+	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);
+	}
+	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);
+	}
+	get time() {
+		return this.#time;
+	}
+	get frame() {
+		return this.#frame;
+	}
+	get delta() {
+		return this.#delta;
+	}
+	get deltaRatio() {
+		return this.#delta / this.#gap;
+	}
+	get stopped() {
+		return this.#stopped;
+	}
+	start() {
+		if (this.#stopped) {
+			this.#stopped = false;
+			this.#primed = false;
+			this.#acc = 0;
+			this.#schedule();
+		}
+	}
+	stop() {
+		if (!this.#stopped) {
+			if (!this.#sleeping) cancel(this.#id);
+			this.#stopped = true;
+			this.#sleeping = false;
+		}
+	}
+	tick() {
+		this.#step(this.#gap);
+	}
+	#schedule() {
+		if (this.#motion.size === 0) {
+			this.#sleeping = true;
+			this.#acc = 0;
+		} else {
+			this.#sleeping = false;
+			this.#id = request((t) => this.#onFrame(t));
+		}
+	}
+	#wake() {
+		if (!this.#stopped && this.#sleeping) {
+			this.#primed = false;
+			this.#schedule();
+		}
+	}
+	#onFrame(timestamp) {
+		if (this.#stopped) return;
+		if (this.#primed) {
+			const wallElapsed = timestamp - this.#lastWallTime;
+			const elapsed = wallElapsed > this.#lagThreshold ? this.#adjustedLag : 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;
+		this.#lastWallTime = timestamp;
+		this.#schedule();
+	}
+	#step(dt) {
+		this.#time += dt;
+		this.#frame++;
+		this.#delta = dt;
+		this.#motion.tick(dt / 1e3);
+	}
+};
+//#endregion
+//#region src/system.ts
+var SpringSystemImpl = class {
+	#motion;
+	#ticker;
+	constructor(options) {
+		this.#motion = new MotionSet(options?.debug);
+		this.#ticker = new Ticker(this.#motion, options);
+		const mode = options?.reducedMotion ?? "user";
+		if (mode === "always") this.#motion.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) => {
+				this.#applyReducedMotion(event.matches);
+			});
+		}
+	}
+	#applyReducedMotion(reduced) {
+		this.#motion.reduced = reduced;
+		if (reduced) this.#motion.finishAll();
+	}
+	get reducedMotion() {
+		return this.#motion.reduced;
+	}
+	createSpring(position, config) {
+		return new Spring(this.#motion, position, config);
+	}
+	createSpringObject(value, config) {
+		return new SpringObject(this.#motion, value, config);
+	}
+	advance(dt) {
+		this.#motion.tick(dt / 1e3);
+	}
+	start() {
+		this.#ticker.start();
+	}
+	stop() {
+		this.#ticker.stop();
+	}
+	get running() {
+		return !this.#ticker.stopped;
+	}
+	get fps() {
+		return this.#ticker.fps;
+	}
+	set fps(value) {
+		this.#ticker.fps = value;
+	}
+	get lagThreshold() {
+		return this.#ticker.lagThreshold;
+	}
+	set lagThreshold(value) {
+		this.#ticker.lagThreshold = value;
+	}
+	get adjustedLag() {
+		return this.#ticker.adjustedLag;
+	}
+	set adjustedLag(value) {
+		this.#ticker.adjustedLag = value;
+	}
+};
+function createSpringSystem(options) {
+	return new SpringSystemImpl(options);
+}
+//#endregion
+export { SpringConfig as n, defineSpring as r, createSpringSystem as t };