anim-engine 0.1.1

package/dist/easing/easing.js

@@ -0,0 +1,154 @@
+//#region src/easing/easing.ts
+var pow = Math.pow;
+var sqrt = Math.sqrt;
+var sin = Math.sin;
+var cos = Math.cos;
+var PI = Math.PI;
+var c1 = 1.70158;
+var c2 = c1 * 1.525;
+var c3 = 2.70158;
+var c4 = 2 * PI / 3;
+var c5 = 2 * PI / 4.5;
+var bounceOut = (x) => {
+	const n1 = 7.5625;
+	const d1 = 2.75;
+	if (x < 1 / d1) return n1 * x * x;
+	else if (x < 2 / d1) return n1 * (x -= 1.5 / d1) * x + .75;
+	else if (x < 2.5 / d1) return n1 * (x -= 2.25 / d1) * x + .9375;
+	else return n1 * (x -= 2.625 / d1) * x + .984375;
+};
+/** All 31 named easing identifiers, ordered by type. */
+var EASE_NAMES = [
+	"linear",
+	"inQuad",
+	"outQuad",
+	"inOutQuad",
+	"inCubic",
+	"outCubic",
+	"inOutCubic",
+	"inQuart",
+	"outQuart",
+	"inOutQuart",
+	"inQuint",
+	"outQuint",
+	"inOutQuint",
+	"inSine",
+	"outSine",
+	"inOutSine",
+	"inExpo",
+	"outExpo",
+	"inOutExpo",
+	"inCirc",
+	"outCirc",
+	"inOutCirc",
+	"inBack",
+	"outBack",
+	"inOutBack",
+	"inElastic",
+	"outElastic",
+	"inOutElastic",
+	"inBounce",
+	"outBounce",
+	"inOutBounce"
+];
+var easingFunctions = {
+	linear: (x) => x,
+	inQuad: (x) => x * x,
+	outQuad: (x) => 1 - (1 - x) * (1 - x),
+	inOutQuad: (x) => x < .5 ? 2 * x * x : 1 - pow(-2 * x + 2, 2) / 2,
+	inCubic: (x) => x * x * x,
+	outCubic: (x) => {
+		const t = 1 - x;
+		return 1 - t * t * t;
+	},
+	inOutCubic: (x) => {
+		if (x < .5) return 4 * x * x * x;
+		const t = -2 * x + 2;
+		return 1 - t * t * t / 2;
+	},
+	inQuart: (x) => x * x * x * x,
+	outQuart: (x) => {
+		const t = 1 - x;
+		const t2 = t * t;
+		return 1 - t2 * t2;
+	},
+	inOutQuart: (x) => {
+		if (x < .5) return 8 * x * x * x * x;
+		const t = -2 * x + 2;
+		return 1 - t * t * t * t / 2;
+	},
+	inQuint: (x) => x * x * x * x * x,
+	outQuint: (x) => {
+		const t = 1 - x;
+		const t2 = t * t;
+		return 1 - t2 * t2 * t;
+	},
+	inOutQuint: (x) => {
+		if (x < .5) return 16 * x * x * x * x * x;
+		const t = -2 * x + 2;
+		return 1 - t * t * t * t * t / 2;
+	},
+	inSine: (x) => 1 - cos(x * PI / 2),
+	outSine: (x) => sin(x * PI / 2),
+	inOutSine: (x) => -(cos(PI * x) - 1) / 2,
+	inExpo: (x) => x === 0 ? 0 : pow(2, 10 * x - 10),
+	outExpo: (x) => x === 1 ? 1 : 1 - pow(2, -10 * x),
+	inOutExpo: (x) => x === 0 ? 0 : x === 1 ? 1 : x < .5 ? pow(2, 20 * x - 10) / 2 : (2 - pow(2, -20 * x + 10)) / 2,
+	inCirc: (x) => 1 - sqrt(1 - x * x),
+	outCirc: (x) => sqrt(1 - (x - 1) * (x - 1)),
+	inOutCirc: (x) => x < .5 ? (1 - sqrt(1 - 4 * x * x)) / 2 : (sqrt(1 - 4 * (x - 1) * (x - 1)) + 1) / 2,
+	inBack: (x) => c3 * x * x * x - c1 * x * x,
+	outBack: (x) => {
+		const t = x - 1;
+		return 1 + c3 * t * t * t + c1 * t * t;
+	},
+	inOutBack: (x) => x < .5 ? 4 * x * x * (3.5949095 * 2 * x - c2) / 2 : (4 * (x - 1) * (x - 1) * (3.5949095 * (x * 2 - 2) + c2) + 2) / 2,
+	inElastic: (x) => x === 0 ? 0 : x === 1 ? 1 : -pow(2, 10 * x - 10) * sin((x * 10 - 10.75) * c4),
+	outElastic: (x) => x === 0 ? 0 : x === 1 ? 1 : pow(2, -10 * x) * sin((x * 10 - .75) * c4) + 1,
+	inOutElastic: (x) => x === 0 ? 0 : x === 1 ? 1 : x < .5 ? -(pow(2, 20 * x - 10) * sin((20 * x - 11.125) * c5)) / 2 : pow(2, -20 * x + 10) * sin((20 * x - 11.125) * c5) / 2 + 1,
+	inBounce: (x) => 1 - bounceOut(1 - x),
+	outBounce: bounceOut,
+	inOutBounce: (x) => x < .5 ? (1 - bounceOut(1 - 2 * x)) / 2 : (1 + bounceOut(2 * x - 1)) / 2
+};
+/**
+* Cubic bezier easing. Builds a pre-computed lookup table at construction time
+* for O(log n) binary search at runtime — no Newton iteration, no allocation
+* per frame.
+*
+* @param p1x - First control point x coordinate.
+* @param p1y - First control point y coordinate.
+* @param p2x - Second control point x coordinate.
+* @param p2y - Second control point y coordinate.
+* @returns An EaseFunction suitable for use with animate() or createTimeline().
+*/
+var cubicBezier = (p1x, p1y, p2x, p2y) => {
+	const sampleSize = 64;
+	const samplesX = new Float64Array(sampleSize);
+	const samplesY = new Float64Array(sampleSize);
+	for (let index = 0; index < sampleSize; index++) {
+		const t = index / (sampleSize - 1);
+		const tInv = 1 - t;
+		const tInvSq = tInv * tInv;
+		const tSq = t * t;
+		samplesX[index] = 3 * tInvSq * t * p1x + 3 * tInv * tSq * p2x + tSq * t;
+		samplesY[index] = 3 * tInvSq * t * p1y + 3 * tInv * tSq * p2y + tSq * t;
+	}
+	return (x) => {
+		if (x <= 0) return 0;
+		if (x >= 1) return 1;
+		let low = 0;
+		let high = sampleSize - 1;
+		while (high - low > 1) {
+			const mid = low + high >>> 1;
+			if (samplesX[mid] <= x) low = mid;
+			else high = mid;
+		}
+		const xLow = samplesX[low];
+		const xHigh = samplesX[high];
+		const fraction = (x - xLow) / (xHigh - xLow);
+		const yLow = samplesY[low];
+		return yLow + fraction * (samplesY[high] - yLow);
+	};
+};
+//#endregion
+export { EASE_NAMES, cubicBezier, easingFunctions };

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+export { createAnimation } from './animation/create-animation';
+export { createTimeline } from './timeline/create-timeline';
+export { createSpring } from './spring/create-spring';
+export { createSmoothDamp } from './smooth-damp/create-smooth-damp';
+export { createLerp } from './lerp/create-lerp';
+export { createSmoothClamp } from './smooth-clamp/smooth-clamp';
+export { lerpOklab, hexToRgba } from './color/lerp-oklab';
+export { getTicker } from './ticker/get-ticker';
+export { EASE_NAMES, cubicBezier } from './easing/easing';
+export type { Keyframe, AnimationOptions } from './animation/create-animation';
+export type { Animation, Interpolation, EaseName, AnimationStatus, InterpolationStatus, DynamicValue, } from './shared/types';
+export type { SpringOptions } from './spring/create-spring';
+export type { SmoothDampOptions } from './smooth-damp/create-smooth-damp';
+export type { LerpOptions } from './lerp/create-lerp';
+export type { TimelineLayer, Timeline } from './timeline/create-timeline';
+export type { RgbaTuple } from './color/lerp-oklab';
+export type { TickerControls } from './ticker/ticker';

package/dist/index.js

@@ -0,0 +1,10 @@
+import { EASE_NAMES, cubicBezier } from "./easing/easing.js";
+import { getTicker } from "./ticker/get-ticker.js";
+import { createAnimation } from "./animation/create-animation.js";
+import { createTimeline } from "./timeline/create-timeline.js";
+import { createSpring } from "./spring/create-spring.js";
+import { createSmoothDamp } from "./smooth-damp/create-smooth-damp.js";
+import { createLerp } from "./lerp/create-lerp.js";
+import { createSmoothClamp } from "./smooth-clamp/smooth-clamp.js";
+import { hexToRgba, lerpOklab } from "./color/lerp-oklab.js";
+export { EASE_NAMES, createAnimation, createLerp, createSmoothClamp, createSmoothDamp, createSpring, createTimeline, cubicBezier, getTicker, hexToRgba, lerpOklab };

package/dist/lerp/create-lerp.d.ts

@@ -0,0 +1,9 @@
+import { Interpolation, DynamicValue } from '../shared/types';
+export type LerpOptions = {
+    to: () => number;
+    smoothTimeMs: DynamicValue;
+    precision?: number;
+    onUpdate?: (value: number, velocity: number) => void;
+    onEnded?: () => void;
+};
+export declare const createLerp: (options: LerpOptions) => Interpolation;

package/dist/lerp/create-lerp.js

@@ -0,0 +1,65 @@
+import { getTicker } from "../ticker/get-ticker.js";
+import { lerpStep } from "./step.js";
+//#region src/lerp/create-lerp.ts
+var createLerp = (options) => {
+	const precision = options.precision ?? .01;
+	const onUpdate = options.onUpdate;
+	const onEnded = options.onEnded;
+	const state = { current: 0 };
+	let previousValue = 0;
+	let currentVelocity = 0;
+	let active = true;
+	const ticker = getTicker();
+	const resolveValue = (v) => typeof v === "function" ? v() : v;
+	state.current = options.to();
+	previousValue = state.current;
+	ticker.add(update);
+	const start = () => {
+		if (active) return;
+		active = true;
+		ticker.add(update);
+	};
+	const stop = () => {
+		active = false;
+		ticker.remove(update);
+	};
+	const kill = () => {
+		active = false;
+		ticker.remove(update);
+	};
+	function update(deltaMs) {
+		if (!active) return;
+		const target = options.to();
+		const smoothTimeMs = resolveValue(options.smoothTimeMs);
+		lerpStep(state, target, smoothTimeMs, deltaMs);
+		currentVelocity = (state.current - previousValue) / (deltaMs / 1e3);
+		previousValue = state.current;
+		onUpdate?.(state.current, currentVelocity);
+		if (onEnded && Math.abs(state.current - target) < precision && Math.abs(currentVelocity) < precision) {
+			state.current = target;
+			currentVelocity = 0;
+			onEnded();
+		}
+	}
+	return {
+		start,
+		stop,
+		kill,
+		setCurrentValue: (value) => {
+			state.current = value;
+			previousValue = value;
+			currentVelocity = 0;
+		},
+		get currentValue() {
+			return state.current;
+		},
+		get velocity() {
+			return currentVelocity;
+		},
+		get status() {
+			return active ? "active" : "inactive";
+		}
+	};
+};
+//#endregion
+export { createLerp };

package/dist/lerp/step.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Lerp step function — first-order exponential approach.
+ * Mutates `state` in place — zero allocation.
+ */
+export type LerpState = {
+    current: number;
+};
+/**
+ * One frame of lerp approach.
+ * Frame-rate independent. Approaches target asymptotically:
+ *   current += (target - current) * rate * deltaTime
+ * where rate = 3 / (smoothTimeMs / 1000) ≈ reaches 95% in smoothTimeMs
+ */
+export declare const lerpStep: (state: LerpState, target: number, smoothTimeMs: number, deltaMs: number) => void;

package/dist/lerp/step.js

@@ -0,0 +1,14 @@
+//#region src/lerp/step.ts
+/**
+* One frame of lerp approach.
+* Frame-rate independent. Approaches target asymptotically:
+*   current += (target - current) * rate * deltaTime
+* where rate = 3 / (smoothTimeMs / 1000) ≈ reaches 95% in smoothTimeMs
+*/
+var lerpStep = (state, target, smoothTimeMs, deltaMs) => {
+	const deltaTime = deltaMs / 1e3;
+	const rate = 3 / Math.max(1e-4, smoothTimeMs / 1e3);
+	state.current += (target - state.current) * rate * deltaTime;
+};
+//#endregion
+export { lerpStep };

package/dist/shared/internal.d.ts

@@ -0,0 +1,4 @@
+/** An object that can be driven by the ticker. */
+export type Updateable = {
+    update(deltaMs: number): void;
+};

package/dist/shared/types.d.ts

@@ -0,0 +1,29 @@
+export type EaseName = "linear" | "inQuad" | "outQuad" | "inOutQuad" | "inCubic" | "outCubic" | "inOutCubic" | "inQuart" | "outQuart" | "inOutQuart" | "inQuint" | "outQuint" | "inOutQuint" | "inSine" | "outSine" | "inOutSine" | "inExpo" | "outExpo" | "inOutExpo" | "inCirc" | "outCirc" | "inOutCirc" | "inBack" | "outBack" | "inOutBack" | "inElastic" | "outElastic" | "inOutElastic" | "inBounce" | "outBounce" | "inOutBounce";
+export type EaseFunction = (t: number) => number;
+export type AnimationStatus = "playing" | "paused" | "stopped" | "dead";
+export type InterpolationStatus = "active" | "inactive" | "dead";
+export type DynamicValue = number | (() => number);
+export type Animation = {
+    play: () => Promise<Animation>;
+    pause: () => void;
+    resume: () => void;
+    stop: () => void;
+    skipToEnd: () => void;
+    kill: () => void;
+    setCurrentValue: (value: number) => void;
+    currentValue: number;
+    velocity: number;
+    progress: number;
+    setProgress: (value: number) => void;
+    status: AnimationStatus;
+    durationMs: number;
+};
+export type Interpolation = {
+    start: () => void;
+    stop: () => void;
+    kill: () => void;
+    setCurrentValue: (value: number) => void;
+    currentValue: number;
+    velocity: number;
+    status: InterpolationStatus;
+};

package/dist/smooth-clamp/smooth-clamp.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Creates a smooth clamp function that maps input toward a threshold
+ * without ever exceeding it. Uses `x / (1 + |x|)` for a natural-feeling
+ * curve — near-linear at low inputs, asymptotically approaches the
+ * threshold at high inputs.
+ *
+ * Compared to a hard clamp, this gives a gradual rolloff that feels
+ * more organic. Useful for capping velocity, torque, or force.
+ *
+ * @param threshold - The asymptotic maximum output (never exceeded).
+ * @returns A function that applies smooth clamping to an input value.
+ */
+export declare const createSmoothClamp: (threshold: number) => ((input: number) => number);

package/dist/smooth-clamp/smooth-clamp.js

@@ -0,0 +1,22 @@
+//#region src/smooth-clamp/smooth-clamp.ts
+/**
+* Creates a smooth clamp function that maps input toward a threshold
+* without ever exceeding it. Uses `x / (1 + |x|)` for a natural-feeling
+* curve — near-linear at low inputs, asymptotically approaches the
+* threshold at high inputs.
+*
+* Compared to a hard clamp, this gives a gradual rolloff that feels
+* more organic. Useful for capping velocity, torque, or force.
+*
+* @param threshold - The asymptotic maximum output (never exceeded).
+* @returns A function that applies smooth clamping to an input value.
+*/
+var createSmoothClamp = (threshold) => {
+	return (input) => {
+		if (!isFinite(input)) return input >= 0 ? threshold : -threshold;
+		const normalized = input / threshold;
+		return threshold * (normalized / (1 + Math.abs(normalized)));
+	};
+};
+//#endregion
+export { createSmoothClamp };

package/dist/smooth-damp/create-smooth-damp.d.ts

@@ -0,0 +1,10 @@
+import { Interpolation, DynamicValue } from '../shared/types';
+export type SmoothDampOptions = {
+    to: () => number;
+    smoothTimeMs: DynamicValue;
+    maxSpeed?: DynamicValue;
+    precision?: number;
+    onUpdate?: (value: number, velocity: number) => void;
+    onEnded?: () => void;
+};
+export declare const createSmoothDamp: (options: SmoothDampOptions) => Interpolation;

package/dist/smooth-damp/create-smooth-damp.js

@@ -0,0 +1,63 @@
+import { getTicker } from "../ticker/get-ticker.js";
+import { smoothDampStep } from "./step.js";
+//#region src/smooth-damp/create-smooth-damp.ts
+var createSmoothDamp = (options) => {
+	const precision = options.precision ?? .01;
+	const onUpdate = options.onUpdate;
+	const onEnded = options.onEnded;
+	const state = {
+		current: 0,
+		velocity: 0
+	};
+	let active = true;
+	const ticker = getTicker();
+	const resolveValue = (v) => typeof v === "function" ? v() : v;
+	state.current = options.to();
+	ticker.add(update);
+	const start = () => {
+		if (active) return;
+		active = true;
+		ticker.add(update);
+	};
+	const stop = () => {
+		active = false;
+		ticker.remove(update);
+	};
+	const kill = () => {
+		active = false;
+		ticker.remove(update);
+	};
+	function update(deltaMs) {
+		if (!active) return;
+		const target = options.to();
+		const smoothTimeMs = resolveValue(options.smoothTimeMs);
+		const maxSpeed = options.maxSpeed !== void 0 ? resolveValue(options.maxSpeed) : Infinity;
+		smoothDampStep(state, target, smoothTimeMs, maxSpeed, deltaMs);
+		onUpdate?.(state.current, state.velocity);
+		if (onEnded && Math.abs(state.current - target) < precision && Math.abs(state.velocity) < precision) {
+			state.current = target;
+			state.velocity = 0;
+			onEnded();
+		}
+	}
+	return {
+		start,
+		stop,
+		kill,
+		setCurrentValue: (value) => {
+			state.current = value;
+			state.velocity = 0;
+		},
+		get currentValue() {
+			return state.current;
+		},
+		get velocity() {
+			return state.velocity;
+		},
+		get status() {
+			return active ? "active" : "inactive";
+		}
+	};
+};
+//#endregion
+export { createSmoothDamp };

package/dist/smooth-damp/step.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Unity-style Smooth Damp step function.
+ * Mutates `state` in place — zero allocation.
+ */
+export type SmoothDampState = {
+    current: number;
+    velocity: number;
+};
+/**
+ * One frame of Smooth Damp using Unity's formula.
+ * Frame-rate independent, critically damped approach toward target.
+ */
+export declare const smoothDampStep: (state: SmoothDampState, target: number, smoothTimeMs: number, maxSpeed: number, deltaMs: number) => void;

package/dist/smooth-damp/step.js

@@ -0,0 +1,26 @@
+//#region src/smooth-damp/step.ts
+/**
+* One frame of Smooth Damp using Unity's formula.
+* Frame-rate independent, critically damped approach toward target.
+*/
+var smoothDampStep = (state, target, smoothTimeMs, maxSpeed, deltaMs) => {
+	const deltaTime = deltaMs / 1e3;
+	const st = Math.max(1e-4, smoothTimeMs / 1e3);
+	const omega = 2 / st;
+	const x = omega * deltaTime;
+	const exp = 1 / (1 + x + .48 * x * x + .235 * x * x * x);
+	const change = state.current - target;
+	const originalTo = target;
+	const maxChange = maxSpeed * st;
+	const clampedChange = Math.max(-maxChange, Math.min(change, maxChange));
+	target = state.current - clampedChange;
+	const temp = (state.velocity + omega * clampedChange) * deltaTime;
+	state.velocity = (state.velocity - omega * temp) * exp;
+	state.current = target + (clampedChange + temp) * exp;
+	if (originalTo - state.current > 0 === state.current > originalTo) {
+		state.current = originalTo;
+		state.velocity = (originalTo - state.current) / deltaTime;
+	}
+};
+//#endregion
+export { smoothDampStep };

package/dist/spring/create-spring.d.ts

@@ -0,0 +1,11 @@
+import { Interpolation, DynamicValue } from '../shared/types';
+export type SpringOptions = {
+    to: () => number;
+    stiffness?: DynamicValue;
+    damping?: DynamicValue;
+    mass?: DynamicValue;
+    precision?: number;
+    onUpdate?: (value: number, velocity: number) => void;
+    onEnded?: () => void;
+};
+export declare const createSpring: (options: SpringOptions) => Interpolation;

package/dist/spring/create-spring.js

@@ -0,0 +1,67 @@
+import { getTicker } from "../ticker/get-ticker.js";
+import { verletStep } from "./verlet.js";
+//#region src/spring/create-spring.ts
+var createSpring = (options) => {
+	const precision = options.precision ?? .01;
+	const onUpdate = options.onUpdate;
+	const onEnded = options.onEnded;
+	const resolveValue = (v) => typeof v === "function" ? v() : v;
+	const rawTo = options.to;
+	const rawStiffness = options.stiffness ?? 180;
+	const rawDamping = options.damping ?? 12;
+	const rawMass = options.mass ?? 1;
+	const state = {
+		current: rawTo(),
+		velocity: 0
+	};
+	let active = true;
+	const ticker = getTicker();
+	ticker.add(update);
+	const start = () => {
+		if (active) return;
+		active = true;
+		ticker.add(update);
+	};
+	const stop = () => {
+		active = false;
+		ticker.remove(update);
+	};
+	const kill = () => {
+		active = false;
+		ticker.remove(update);
+	};
+	function update(deltaMs) {
+		if (!active) return;
+		const target = rawTo();
+		const stiffness = resolveValue(rawStiffness);
+		const damping = resolveValue(rawDamping);
+		const mass = resolveValue(rawMass);
+		verletStep(state, target, stiffness, damping, mass, deltaMs);
+		onUpdate?.(state.current, state.velocity);
+		if (onEnded && Math.abs(state.current - target) < precision && Math.abs(state.velocity) < precision) {
+			state.current = target;
+			state.velocity = 0;
+			onEnded();
+		}
+	}
+	return {
+		start,
+		stop,
+		kill,
+		setCurrentValue: (value) => {
+			state.current = value;
+			state.velocity = 0;
+		},
+		get currentValue() {
+			return state.current;
+		},
+		get velocity() {
+			return state.velocity;
+		},
+		get status() {
+			return active ? "active" : "inactive";
+		}
+	};
+};
+//#endregion
+export { createSpring };

package/dist/spring/verlet.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Verlet integration step for spring physics.
+ * Mutates `state` in place — zero allocation.
+ */
+export type SpringState = {
+    current: number;
+    velocity: number;
+};
+export declare const verletStep: (state: SpringState, target: number, stiffness: number, damping: number, mass: number, deltaMs: number) => void;
+/**
+ * Check if the spring is near rest (within precision of target, velocity near 0).
+ */
+export declare const isNearRest: (current: number, velocity: number, target: number, precision: number) => boolean;

package/dist/spring/verlet.js

@@ -0,0 +1,9 @@
+//#region src/spring/verlet.ts
+var verletStep = (state, target, stiffness, damping, mass, deltaMs) => {
+	const dt = deltaMs / 1e3;
+	const acceleration = (-stiffness * (state.current - target) + -damping * state.velocity) / mass;
+	state.velocity += acceleration * dt;
+	state.current += state.velocity * dt;
+};
+//#endregion
+export { verletStep };

package/dist/ticker/get-ticker.d.ts

@@ -0,0 +1,5 @@
+import { TickerControls } from './ticker';
+/** Returns the default ticker singleton. Created lazily on first access. */
+export declare const getTicker: () => TickerControls;
+/** Creates a new independent ticker instance (for testing or multi-loop setups). */
+export { createTicker } from './ticker';

package/dist/ticker/get-ticker.js

@@ -0,0 +1,10 @@
+import { createTicker } from "./ticker.js";
+//#region src/ticker/get-ticker.ts
+var singleton;
+/** Returns the default ticker singleton. Created lazily on first access. */
+var getTicker = () => {
+	if (!singleton) singleton = createTicker();
+	return singleton;
+};
+//#endregion
+export { getTicker };

package/dist/ticker/ticker.d.ts

@@ -0,0 +1,22 @@
+export type TickHandler = (deltaMs: number) => void;
+export type TickerControls = {
+    start: () => void;
+    stop: () => void;
+    update: (deltaMs: number) => void;
+    add: (handler: TickHandler) => void;
+    remove: (handler: TickHandler) => void;
+};
+/**
+ * Create a ticker that drives active animations.
+ *
+ * Does NOT auto-start. The user must explicitly call either:
+ * - `start()` — begins a `requestAnimationFrame` loop
+ * - `update(deltaMs)` — drive manually from a game loop
+ *
+ * `add()` and `remove()` register/unregister animations without
+ * side effects on the rAF loop.
+ *
+ * Uses a flat array with undefined-tombstone removal for safe concurrent
+ * modification during iteration. Compacted after each frame.
+ */
+export declare const createTicker: () => TickerControls;