@weasel-js/core 1.7.3 → 1.8.0

package/CHANGELOG.md

@@ -1,5 +1,52 @@
 # Changelog
 
+## 1.8.0
+
+### Minor Changes
+
+- c1aa1f6: A pref's label shortens to fit the room it is given. **Breaking:** `short` on a pref leaf and on an enum option is now a list of shorter forms, longest first (`short: ['Track', 'VA']`), where it was one string; wrap an existing value in an array. A toggle segment, a flag bar, and a `ToolOptionsBar` label show the longest form that fits, stepping every label in the bar down together, and `name` stays the accessible name. A leaf's `icon` is still drawn in place of any text form where it resolves; a flag with neither no longer falls back to its name's first letter.
+  
+  The mechanism is public: `useFitScope(ref)` measures an element and its parent for overflow, `<FitScope>` hands the step to the `<FitLabel forms>` beneath it, and `ToggleBar` is a scope on its own. `PropertyOption` and `PropertyBooleanFieldProps` take `short` beside `glyph`, which now means only a drawn glyph.
+  
+  <!-- bump-approved: minor: maintainer — minor release requested 2026-10-05 -->
+
+### Patch Changes
+
+- d24f51f: The animator computes tweens, springs, physics and decay in blits. Every signature is unchanged.
+  
+  - Springs, physics and decay follow closed forms, so a spring lands in the same place at any frame rate. Their values differ slightly from the previous integrator's, and they settle on a different frame. A value that isn't a number, a number array or an object of numeric fields, or constants the closed forms can't solve, still uses the previous integrator.
+  - A tween of a number array or an object of numbers no longer needs an `interpolate`.
+  - A tween of anything else with no `interpolate` or `interpolator` now throws when `tween` is called, instead of on its first frame. `setTarget` and `setVelocity` throw when the value's shape differs from `from`'s.
+  
+  At 10,000 tweens a frame costs about 3× what it did; at 1,000, 0.06 ms against 0.02. Springs cost slightly less than before.
+- 4db0f2e: `PoseOverrides` has a new method, `read(id)`. It returns what a node is drawn and picked with: every source of overrides for that node folded into one, as of the last write or `commit()`. `get(id)` still returns the entry a writer stored, by reference. Painting, picking and `effectivePose` now call `read`. Today the only source is the entries table, so `read` and `get` agree. Once animations write overrides too, `read` will fold them in with the table.
+  
+  Anyone who implements `PoseOverrides`, or the `overrides` of a `PoseSource` stand-in or of diagram's `ParticipantScene`, has to add `read`. For a stand-in, `read: (id) => entries.get(id)` reproduces the old behavior.
+  
+  Core now depends on `@msb235/blits`, which does the folding.
+- 2432ce3: Quantities can be infinite. Every display shows ±Infinity as `∞`, spoken "infinity", and reads `∞`, `inf` and `infinity` back; `endless(display, 'never')` gives a display its own word, shown without a unit beside it and read back when typed. A zoom display used to print `Infinity` here.
+  
+  A slider can make an end stand for infinity. `Slider` and `PropertyField` take `endless: 'max' | 'min' | 'both'`: the end stop reports ±Infinity, a value of ±Infinity sits there, and the readout shows the display's word. A number pref leaf takes `endless` and `infinity` (its word), and labkit's number builder takes `.endless('never')`, so `f.number(Infinity).range(0, 5000).suffix('ms').endless('never')` reads "never" at the top of its track instead of "5000 ms".
+- 9b1ff50: A clip that is an axis-aligned rect no longer breaks the batch. The renderer
+  cuts staged geometry to it on the CPU instead of writing it to the stencil, so
+  a clipped group's content shares a draw with what surrounds it. The clip falls
+  back to the stencil only where it must: for content that draws for itself, and
+  for content with a slanted edge across the clip's edge. Rotated or non-rect
+  clips are unchanged.
+- Updated dependencies [2432ce3]
+  - @weasel-js/quantity@1.8.0
+  - @weasel-js/cursor@1.8.0
+  - @weasel-js/font@1.8.0
+  - @weasel-js/geom@1.8.0
+  - @weasel-js/gestures@1.8.0
+  - @weasel-js/history@1.8.0
+  - @weasel-js/modes@1.8.0
+  - @weasel-js/paint@1.8.0
+  - @weasel-js/react@1.8.0
+  - @weasel-js/registry@1.8.0
+  - @weasel-js/routing@1.8.0
+  - @weasel-js/text@1.8.0
+
 ## 1.7.3
 
 ### Patch Changes

package/dist/animation/colorHelpers.js

@@ -1,38 +1,38 @@
 import { hslToRgb as e } from "../renderer/math/color.js";
 import { lerpColorArray as t } from "@weasel-js/paint";
-import { resolveEasing as n } from "@weasel-js/geom";
+import { linear as n, resolveEasing as r } from "@weasel-js/geom";
 //#region src/animation/colorHelpers.ts
-function r(e, t) {
+function i(e, t) {
 	if (e.length !== t.length) throw Error(`vertex colors: length mismatch (from=${e.length}, to=${t.length})`);
 	if (e.length === 0 || e.length % 4 != 0) throw Error(`vertex colors: length ${e.length} must be a positive multiple of 4`);
 }
-function i(e) {
+function a(e) {
 	if (e.interpolate) return e.interpolate;
 	let n = e.interpolation ?? "rgb";
 	return (e, r, i) => t(e, r, i, n);
 }
-var a = (e, t) => `colors:${e}:${t}`;
-function o(e, t) {
-	r(t.from, t.to);
-	let n = i(t), { id: o, channel: s } = t;
+var o = (e, t) => `colors:${e}:${t}`;
+function s(e, t) {
+	i(t.from, t.to);
+	let n = a(t), { id: r, channel: s } = t;
 	return e.tween({
 		from: 0,
 		to: 1,
 		ms: t.ms,
 		easing: t.easing,
-		cancelKey: a(o, s),
+		cancelKey: o(r, s),
 		interpolate: (e, t, n) => e + (t - e) * n,
-		onTick: (r) => {
-			e.colorOverrides.set(o, s, n(t.from, t.to, r));
+		onTick: (i) => {
+			e.colorOverrides.set(r, s, n(t.from, t.to, i));
 		},
 		onDone: () => {
-			e.colorOverrides.clear(o, s), t.onDone?.();
+			e.colorOverrides.clear(r, s), t.onDone?.();
 		}
 	});
 }
-function s(e, t) {
-	r(t.from, t.to);
-	let n = i(t), { id: o, channel: s } = t;
+function c(e, t) {
+	i(t.from, t.to);
+	let n = a(t), { id: r, channel: s } = t;
 	return e.spring({
 		from: 0,
 		to: 1,
@@ -40,96 +40,96 @@ function s(e, t) {
 		stiffness: t.stiffness,
 		damping: t.damping,
 		mass: t.mass,
-		cancelKey: a(o, s),
+		cancelKey: o(r, s),
 		interpolate: (e, t, n) => e + (t - e) * n,
-		onTick: (r) => {
-			let i = Math.max(0, Math.min(1, r));
-			e.colorOverrides.set(o, s, n(t.from, t.to, i));
+		onTick: (i) => {
+			let a = Math.max(0, Math.min(1, i));
+			e.colorOverrides.set(r, s, n(t.from, t.to, a));
 		},
 		onDone: () => {
-			e.colorOverrides.clear(o, s), t.onDone?.();
+			e.colorOverrides.clear(r, s), t.onDone?.();
 		}
 	});
 }
-function c(e, t) {
-	let r = i(t), { id: a, channel: o } = t, s = t.direction ?? 1, c = n(t.easing);
-	e.colorOverrides.set(a, o, (e, n) => {
+function l(e, t) {
+	let n = a(t), { id: i, channel: o } = t, s = t.direction ?? 1, c = r(t.easing);
+	e.colorOverrides.set(i, o, (e, r) => {
 		let i = e.length / 4;
 		if (i === 0) return e.slice();
-		let a = n / t.msPerCycle * i * s / i, o = a - Math.floor(a), l = c(o), u = ((Math.floor(a) + l) * i % i + i) % i, d = Math.floor(u), f = u - d, p = Array(e.length);
+		let a = r / t.msPerCycle * i * s / i, o = a - Math.floor(a), l = c(o), u = ((Math.floor(a) + l) * i % i + i) % i, d = Math.floor(u), f = u - d, p = Array(e.length);
 		for (let t = 0; t < i; t++) {
-			let n = (t + d) % i * 4, a = (t + d + 1) % i * 4, o = [
-				e[n],
-				e[n + 1],
-				e[n + 2],
-				e[n + 3]
+			let r = (t + d) % i * 4, a = (t + d + 1) % i * 4, o = [
+				e[r],
+				e[r + 1],
+				e[r + 2],
+				e[r + 3]
 			], s = [
 				e[a],
 				e[a + 1],
 				e[a + 2],
 				e[a + 3]
-			], c = r(o, s, f), l = t * 4;
+			], c = n(o, s, f), l = t * 4;
 			p[l] = c[0], p[l + 1] = c[1], p[l + 2] = c[2], p[l + 3] = c[3];
 		}
 		return p;
 	});
 	let l = e.keepAlive();
 	return { cancel() {
-		e.colorOverrides.clear(a, o), l();
+		e.colorOverrides.clear(i, o), l();
 	} };
 }
-function l(e, t) {
-	r(t.from, t.to);
-	let o = i(t), { id: s, channel: c, from: l, to: u, anchorMs: d, perAnchorDelay: f } = t, p = l.length / 4, m = n(t.easing), h = t.origin === "last" ? p - 1 : typeof t.origin == "number" ? Math.max(0, Math.min(p - 1, t.origin)) : 0, g = Math.max(h, p - 1 - h) * f + d, _ = (e) => {
-		let t = Array(l.length);
-		for (let n = 0; n < p; n++) {
-			let r = Math.abs(n - h) * f, i = Math.max(0, Math.min(1, (e - r) / d)), a = m(i), s = n * 4, c = [
-				l[s],
-				l[s + 1],
-				l[s + 2],
-				l[s + 3]
-			], p = [
-				u[s],
-				u[s + 1],
-				u[s + 2],
-				u[s + 3]
-			], g = o(c, p, a);
-			t[s] = g[0], t[s + 1] = g[1], t[s + 2] = g[2], t[s + 3] = g[3];
+function u(e, t) {
+	i(t.from, t.to);
+	let s = a(t), { id: c, channel: l, from: u, to: d, anchorMs: f, perAnchorDelay: p } = t, m = u.length / 4, h = r(t.easing), g = t.origin === "last" ? m - 1 : typeof t.origin == "number" ? Math.max(0, Math.min(m - 1, t.origin)) : 0, _ = Math.max(g, m - 1 - g) * p + f, v = (e) => {
+		let t = Array(u.length);
+		for (let n = 0; n < m; n++) {
+			let r = Math.abs(n - g) * p, i = Math.max(0, Math.min(1, (e - r) / f)), a = h(i), o = n * 4, c = [
+				u[o],
+				u[o + 1],
+				u[o + 2],
+				u[o + 3]
+			], l = [
+				d[o],
+				d[o + 1],
+				d[o + 2],
+				d[o + 3]
+			], m = s(c, l, a);
+			t[o] = m[0], t[o + 1] = m[1], t[o + 2] = m[2], t[o + 3] = m[3];
 		}
 		return t;
 	};
-	return e.colorOverrides.set(s, c, _(0)), e.tween({
+	return e.colorOverrides.set(c, l, v(0)), e.tween({
 		from: 0,
 		to: 1,
-		ms: g,
-		easing: (e) => e,
-		cancelKey: a(s, c),
+		ms: _,
+		easing: n,
+		cancelKey: o(c, l),
 		interpolate: (e, t, n) => e + (t - e) * n,
 		onTick: (t) => {
-			e.colorOverrides.set(s, c, _(t * g));
+			e.colorOverrides.set(c, l, v(t * _));
 		},
 		onDone: () => {
-			e.colorOverrides.clear(s, c), t.onDone?.();
+			e.colorOverrides.clear(c, l), t.onDone?.();
 		}
 	});
 }
-function u(e, t = {}) {
+function d(e, t = {}) {
 	let n = t.saturation ?? .8, r = t.lightness ?? .6, i = t.alpha ?? 1, a = [];
 	for (let t = 0; t < e; t++) {
-		let [o, s, c] = f(t * 360 / Math.max(1, e), n, r);
+		let [o, s, c] = p(t * 360 / Math.max(1, e), n, r);
 		a.push(o, s, c, i);
 	}
 	return a;
 }
-function d(e, t, n, r, i = 1) {
+function f(e, t, n, r, i = 1) {
 	let a = [];
 	for (let o = 0; o < e; o++) a.push(t, n, r, i);
 	return a;
 }
-function f(t, n, r) {
+function p(t, n, r) {
 	return e(t, n, r);
 }
 //#endregion
-export { c as cycleVertexColors, u as rainbowVertexColors, d as solidVertexColors, s as springVertexColors, l as staggerVertexColors, o as tweenVertexColors };
+export { l as cycleVertexColors, d as rainbowVertexColors, f as solidVertexColors, c as springVertexColors, u as staggerVertexColors, s as tweenVertexColors };
 
 //# sourceMappingURL=colorHelpers.js.map

package/dist/animation/colorHelpers.js.map

@@ -1 +1 @@
-{"version":3,"file":"colorHelpers.js","names":["validateLengths","from","to","resolveInterpolator","opts","space","lerpColorArray","a","b","t","cancelKeyFor","id","channel","tweenVertexColors","interp","animator","springVertexColors","clamped","cycleVertexColors","direction","easing","resolveEasing","n","base","cycles","tMs","cycleFrac","easedFrac","phase","phaseInt","phaseFrac","out","i","aIdx","bIdx","blended","k","releaseKeepAlive","staggerVertexColors","originIndex","totalMs","perAnchorDelay","anchorMs","colorsAt","startMs","localT","elapsedMs","eased","fSlice","tSlice","rainbowVertexColors","saturation","lightness","alpha","r","g","hslToRgbUnit","solidVertexColors","hslToRgb","h","s","l"],"sources":["../../src/animation/colorHelpers.ts"],"sourcesContent":["import { resolveEasing } from '@weasel-js/geom';\nimport type {\n  AnimationHandle,\n  Animator,\n  EasingSpec,\n  SpringPresetName,\n} from './types';\nimport type { VertexColorChannel } from './colorRegistry';\nimport { lerpColorArray, type ColorSpace } from '@weasel-js/paint';\nimport { hslToRgb } from '../renderer/math/color';\n\n/**\n * Color interpolator: receives two flat RGBA float arrays (values in\n * 0..1, the renderer's color space — same shape as\n * `stroke.vertexColors`) and a normalized progress `t` in 0..1.\n * Returns the same-length blended array, also in 0..1 floats. Override\n * the default per-channel lerp via `TweenVertexColorsOptions.interpolate`\n * when a custom color-space or shaping is needed.\n */\nexport type ColorInterpolate = (\n  from: readonly number[],\n  to: readonly number[],\n  t: number,\n) => number[];\n\n/** Options for `tweenVertexColors`. */\nexport interface TweenVertexColorsOptions {\n  id: string;\n  channel: VertexColorChannel;\n  /** Per-anchor RGBA, flat, in 0..1 floats (matches the renderer's\n   *  `stroke.vertexColors` / `PathDrawCommand.vertexColors` color space).\n   *  Length must equal `from.length`. */\n  to: readonly number[];\n  /** Per-anchor RGBA, flat, in 0..1 floats. Length must equal `to.length`\n   *  and be a positive multiple of 4. */\n  from: readonly number[];\n  ms: number;\n  easing?: EasingSpec;\n  interpolation?: ColorSpace;\n  interpolate?: ColorInterpolate;\n  onDone?: () => void;\n}\n\nfunction validateLengths(from: readonly number[], to: readonly number[]): void {\n  if (from.length !== to.length) {\n    throw new Error(\n      `vertex colors: length mismatch (from=${from.length}, to=${to.length})`,\n    );\n  }\n  if (from.length === 0 || from.length % 4 !== 0) {\n    throw new Error(\n      `vertex colors: length ${from.length} must be a positive multiple of 4`,\n    );\n  }\n}\n\nfunction resolveInterpolator(\n  opts: { interpolation?: ColorSpace; interpolate?: ColorInterpolate },\n): ColorInterpolate {\n  if (opts.interpolate) return opts.interpolate;\n  const space: ColorSpace = opts.interpolation ?? 'rgb';\n  return (a, b, t) => lerpColorArray(a, b, t, space);\n}\n\nconst cancelKeyFor = (id: string, channel: VertexColorChannel): string =>\n  `colors:${id}:${channel}`;\n\n/**\n * Animate one node's per-anchor colors from `from` to `to` over `ms`.\n *\n * The colors are published to the animator's `colorOverrides` registry rather\n * than written into the scene, so nothing is recorded in history and the\n * node's own data is untouched; the override is dropped when the animation\n * finishes. Starting another color animation on the same node and channel\n * cancels this one.\n */\nexport function tweenVertexColors(\n  animator: Animator,\n  opts: TweenVertexColorsOptions,\n): AnimationHandle {\n  validateLengths(opts.from, opts.to);\n  const interp = resolveInterpolator(opts);\n  const { id, channel } = opts;\n  return animator.tween<number>({\n    from: 0,\n    to: 1,\n    ms: opts.ms,\n    easing: opts.easing,\n    cancelKey: cancelKeyFor(id, channel),\n    interpolate: (a, b, t) => a + (b - a) * t,\n    onTick: (t) => {\n      animator.colorOverrides.set(id, channel, interp(opts.from, opts.to, t));\n    },\n    onDone: () => {\n      animator.colorOverrides.clear(id, channel);\n      opts.onDone?.();\n    },\n  });\n}\n\n/** Options for `springVertexColors`. */\nexport interface SpringVertexColorsOptions {\n  id: string;\n  channel: VertexColorChannel;\n  /** Per-anchor RGBA in 0..1 floats. See `TweenVertexColorsOptions.to`. */\n  to: readonly number[];\n  /** Per-anchor RGBA in 0..1 floats. See `TweenVertexColorsOptions.from`. */\n  from: readonly number[];\n  preset?: SpringPresetName;\n  stiffness?: number;\n  damping?: number;\n  mass?: number;\n  interpolation?: ColorSpace;\n  interpolate?: ColorInterpolate;\n  onDone?: () => void;\n}\n\n/** `tweenVertexColors` driven by a spring instead of a duration. Same override\n *  semantics. */\nexport function springVertexColors(\n  animator: Animator,\n  opts: SpringVertexColorsOptions,\n): AnimationHandle {\n  validateLengths(opts.from, opts.to);\n  const interp = resolveInterpolator(opts);\n  const { id, channel } = opts;\n  return animator.spring<number>({\n    from: 0,\n    to: 1,\n    preset: opts.preset,\n    stiffness: opts.stiffness,\n    damping: opts.damping,\n    mass: opts.mass,\n    cancelKey: cancelKeyFor(id, channel),\n    interpolate: (a, b, t) => a + (b - a) * t,\n    onTick: (t) => {\n      const clamped = Math.max(0, Math.min(1, t));\n      animator.colorOverrides.set(id, channel, interp(opts.from, opts.to, clamped));\n    },\n    onDone: () => {\n      animator.colorOverrides.clear(id, channel);\n      opts.onDone?.();\n    },\n  });\n}\n\n/** Options for `cycleVertexColors`. */\nexport interface CycleVertexColorsOptions {\n  id: string;\n  channel: VertexColorChannel;\n  msPerCycle: number;\n  direction?: 1 | -1;\n  easing?: EasingSpec;\n  interpolation?: ColorSpace;\n  /** Custom interpolator. Receives two RGBA arrays in 0..1 floats and a\n   *  progress `t` in 0..1; returns the blended array in 0..1 floats. */\n  interpolate?: ColorInterpolate;\n}\n\n/** Removes an installed color cycle. Unlike the other color helpers this is\n *  not an `AnimationHandle`, because a cycle has no progress to pause or\n *  scale — it only ends. */\nexport interface CycleHandle {\n  cancel(): void;\n}\n\n/** Register a function override that phase-rotates the base color array\n *  along the path index. Returns a handle whose `cancel()` removes the\n *  override.\n *\n *  The override computes its value purely from `performance.now()`, so\n *  there's no per-frame progress to register with the animator's tick\n *  loop. To keep the loop alive (so `<SceneCanvas animator>`'s onTick\n *  subscription continues firing redraws while the cycle is installed),\n *  cycleVertexColors holds an `animator.keepAlive()` entry for the\n *  lifetime of the cycle; `cancel()` releases it. */\nexport function cycleVertexColors(\n  animator: Animator,\n  opts: CycleVertexColorsOptions,\n): CycleHandle {\n  const interp = resolveInterpolator(opts);\n  const { id, channel } = opts;\n  const direction = opts.direction ?? 1;\n  const easing = resolveEasing(opts.easing);\n\n  const override = (base: readonly number[], tMs: number): number[] => {\n    const n = base.length / 4;\n    if (n === 0) return base.slice();\n    const raw = (tMs / opts.msPerCycle) * n * direction;\n    const cycles = raw / n;\n    const cycleFrac = cycles - Math.floor(cycles);\n    const easedFrac = easing(cycleFrac);\n    const easedRaw = (Math.floor(cycles) + easedFrac) * n;\n    const phase = ((easedRaw % n) + n) % n;\n    const phaseInt = Math.floor(phase);\n    const phaseFrac = phase - phaseInt;\n\n    const out = new Array<number>(base.length);\n    for (let i = 0; i < n; i++) {\n      const aIdx = ((i + phaseInt) % n) * 4;\n      const bIdx = ((i + phaseInt + 1) % n) * 4;\n      const a = [base[aIdx], base[aIdx + 1], base[aIdx + 2], base[aIdx + 3]];\n      const b = [base[bIdx], base[bIdx + 1], base[bIdx + 2], base[bIdx + 3]];\n      const blended = interp(a, b, phaseFrac);\n      const k = i * 4;\n      out[k] = blended[0];\n      out[k + 1] = blended[1];\n      out[k + 2] = blended[2];\n      out[k + 3] = blended[3];\n    }\n    return out;\n  };\n\n  animator.colorOverrides.set(id, channel, override);\n  // Cycle's \"value\" is a function of wall-clock time, not a tween-style\n  // progress. We don't register a per-frame ticking animation, so without\n  // an explicit keep-alive entry the animator's RAF loop would idle and\n  // SceneCanvas's onTick redraw subscription would never fire. Keep the\n  // loop running until cancel().\n  const releaseKeepAlive = animator.keepAlive();\n\n  return {\n    cancel(): void {\n      animator.colorOverrides.clear(id, channel);\n      releaseKeepAlive();\n    },\n  };\n}\n\n/** Options for `staggerVertexColors`. `origin` picks which anchor the wave\n *  starts from and `perAnchorDelay` how far behind each successive anchor\n *  runs. */\nexport interface StaggerVertexColorsOptions {\n  id: string;\n  channel: VertexColorChannel;\n  /** Per-anchor RGBA in 0..1 floats. See `TweenVertexColorsOptions.to`. */\n  to: readonly number[];\n  /** Per-anchor RGBA in 0..1 floats. See `TweenVertexColorsOptions.from`. */\n  from: readonly number[];\n  anchorMs: number;\n  perAnchorDelay: number;\n  origin?: 'first' | 'last' | number;\n  easing?: EasingSpec;\n  interpolation?: ColorSpace;\n  interpolate?: ColorInterpolate;\n  onDone?: () => void;\n}\n\n/** Run the same color change across a node's anchors as a wave, each anchor\n *  starting later than the one before it. Same override semantics as\n *  `tweenVertexColors`. */\nexport function staggerVertexColors(\n  animator: Animator,\n  opts: StaggerVertexColorsOptions,\n): AnimationHandle {\n  validateLengths(opts.from, opts.to);\n  const interp = resolveInterpolator(opts);\n  const { id, channel, from, to, anchorMs, perAnchorDelay } = opts;\n  const n = from.length / 4;\n  const easing = resolveEasing(opts.easing);\n\n  const originIndex =\n    opts.origin === 'last' ? n - 1 :\n    typeof opts.origin === 'number' ? Math.max(0, Math.min(n - 1, opts.origin)) :\n    0;\n\n  const maxDistance = Math.max(originIndex, n - 1 - originIndex);\n  const totalMs = maxDistance * perAnchorDelay + anchorMs;\n\n  const colorsAt = (elapsedMs: number): number[] => {\n    const out = new Array<number>(from.length);\n    for (let i = 0; i < n; i++) {\n      const distance = Math.abs(i - originIndex);\n      const startMs = distance * perAnchorDelay;\n      const localT = Math.max(0, Math.min(1, (elapsedMs - startMs) / anchorMs));\n      const eased = easing(localT);\n      const k = i * 4;\n      const fSlice = [from[k], from[k + 1], from[k + 2], from[k + 3]];\n      const tSlice = [to[k], to[k + 1], to[k + 2], to[k + 3]];\n      const blended = interp(fSlice, tSlice, eased);\n      out[k] = blended[0];\n      out[k + 1] = blended[1];\n      out[k + 2] = blended[2];\n      out[k + 3] = blended[3];\n    }\n    return out;\n  };\n\n  // A plain array, not a function override: painters call those with their\n  // own clock (`performance.now()`), not time since this stagger began.\n  animator.colorOverrides.set(id, channel, colorsAt(0));\n\n  return animator.tween<number>({\n    from: 0,\n    to: 1,\n    ms: totalMs,\n    easing: (t) => t,\n    cancelKey: cancelKeyFor(id, channel),\n    interpolate: (a, b, t) => a + (b - a) * t,\n    onTick: (t) => {\n      animator.colorOverrides.set(id, channel, colorsAt(t * totalMs));\n    },\n    onDone: () => {\n      animator.colorOverrides.clear(id, channel);\n      opts.onDone?.();\n    },\n  });\n}\n\n// ─── Color-array constructors ───────────────────────────────────────\n//\n// Helpers that build the per-anchor RGBA arrays the tween/cycle/stagger\n// helpers above (and `stroke.vertexColors` on draw commands) consume.\n// Values are in the 0..1 range the renderer expects — emitting bytes\n// (0..255) clamps every channel to 1.0 on the GPU and renders white.\n\n/** Build an n-anchor rainbow RGBA array sweeping the hue wheel. The\n *  output is suitable to pass directly into `stroke.vertexColors`,\n *  `tweenVertexColors({ from: rainbowVertexColors(n) })`, or any\n *  other API that wants per-anchor color floats. */\nexport function rainbowVertexColors(\n  n: number,\n  opts: { saturation?: number; lightness?: number; alpha?: number } = {},\n): number[] {\n  const saturation = opts.saturation ?? 0.8;\n  const lightness = opts.lightness ?? 0.6;\n  const alpha = opts.alpha ?? 1;\n  const out: number[] = [];\n  for (let i = 0; i < n; i++) {\n    const h = (i * 360) / Math.max(1, n);\n    const [r, g, b] = hslToRgbUnit(h, saturation, lightness);\n    out.push(r, g, b, alpha);\n  }\n  return out;\n}\n\n/** Build an n-anchor solid RGBA array. Shorthand for\n *  `[r, g, b, a, r, g, b, a, …]` — the array a `tweenVertexColors`\n *  `to`-target typically needs. */\nexport function solidVertexColors(\n  n: number,\n  r: number,\n  g: number,\n  b: number,\n  a = 1,\n): number[] {\n  const out: number[] = [];\n  for (let i = 0; i < n; i++) out.push(r, g, b, a);\n  return out;\n}\n\n/** HSL → RGB in 0..1 (hue in degrees). Delegates to the single internal\n *  implementation in `renderer/math/color.ts` so there's only one HSL→RGB\n *  formula in the package. Kept local so consumers building hue-cycled\n *  color arrays via `huesweepVertexColors` don't have to roll their own. */\nfunction hslToRgbUnit(h: number, s: number, l: number): [number, number, number] {\n  return hslToRgb(h, s, l);\n}\n"],"mappings":"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"}
+{"version":3,"file":"colorHelpers.js","names":["validateLengths","from","to","resolveInterpolator","opts","space","lerpColorArray","a","b","t","cancelKeyFor","id","channel","tweenVertexColors","interp","animator","springVertexColors","clamped","cycleVertexColors","direction","easing","resolveEasing","n","base","cycles","tMs","cycleFrac","easedFrac","phase","phaseInt","phaseFrac","out","i","aIdx","bIdx","blended","k","releaseKeepAlive","staggerVertexColors","originIndex","totalMs","perAnchorDelay","anchorMs","colorsAt","startMs","localT","elapsedMs","eased","fSlice","tSlice","linear","rainbowVertexColors","saturation","lightness","alpha","r","g","hslToRgbUnit","solidVertexColors","hslToRgb","h","s","l"],"sources":["../../src/animation/colorHelpers.ts"],"sourcesContent":["import { linear, resolveEasing } from '@weasel-js/geom';\nimport type {\n  AnimationHandle,\n  Animator,\n  EasingSpec,\n  SpringPresetName,\n} from './types';\nimport type { VertexColorChannel } from './colorRegistry';\nimport { lerpColorArray, type ColorSpace } from '@weasel-js/paint';\nimport { hslToRgb } from '../renderer/math/color';\n\n/**\n * Color interpolator: receives two flat RGBA float arrays (values in\n * 0..1, the renderer's color space — same shape as\n * `stroke.vertexColors`) and a normalized progress `t` in 0..1.\n * Returns the same-length blended array, also in 0..1 floats. Override\n * the default per-channel lerp via `TweenVertexColorsOptions.interpolate`\n * when a custom color-space or shaping is needed.\n */\nexport type ColorInterpolate = (\n  from: readonly number[],\n  to: readonly number[],\n  t: number,\n) => number[];\n\n/** Options for `tweenVertexColors`. */\nexport interface TweenVertexColorsOptions {\n  id: string;\n  channel: VertexColorChannel;\n  /** Per-anchor RGBA, flat, in 0..1 floats (matches the renderer's\n   *  `stroke.vertexColors` / `PathDrawCommand.vertexColors` color space).\n   *  Length must equal `from.length`. */\n  to: readonly number[];\n  /** Per-anchor RGBA, flat, in 0..1 floats. Length must equal `to.length`\n   *  and be a positive multiple of 4. */\n  from: readonly number[];\n  ms: number;\n  easing?: EasingSpec;\n  interpolation?: ColorSpace;\n  interpolate?: ColorInterpolate;\n  onDone?: () => void;\n}\n\nfunction validateLengths(from: readonly number[], to: readonly number[]): void {\n  if (from.length !== to.length) {\n    throw new Error(\n      `vertex colors: length mismatch (from=${from.length}, to=${to.length})`,\n    );\n  }\n  if (from.length === 0 || from.length % 4 !== 0) {\n    throw new Error(\n      `vertex colors: length ${from.length} must be a positive multiple of 4`,\n    );\n  }\n}\n\nfunction resolveInterpolator(\n  opts: { interpolation?: ColorSpace; interpolate?: ColorInterpolate },\n): ColorInterpolate {\n  if (opts.interpolate) return opts.interpolate;\n  const space: ColorSpace = opts.interpolation ?? 'rgb';\n  return (a, b, t) => lerpColorArray(a, b, t, space);\n}\n\nconst cancelKeyFor = (id: string, channel: VertexColorChannel): string =>\n  `colors:${id}:${channel}`;\n\n/**\n * Animate one node's per-anchor colors from `from` to `to` over `ms`.\n *\n * The colors are published to the animator's `colorOverrides` registry rather\n * than written into the scene, so nothing is recorded in history and the\n * node's own data is untouched; the override is dropped when the animation\n * finishes. Starting another color animation on the same node and channel\n * cancels this one.\n */\nexport function tweenVertexColors(\n  animator: Animator,\n  opts: TweenVertexColorsOptions,\n): AnimationHandle {\n  validateLengths(opts.from, opts.to);\n  const interp = resolveInterpolator(opts);\n  const { id, channel } = opts;\n  return animator.tween<number>({\n    from: 0,\n    to: 1,\n    ms: opts.ms,\n    easing: opts.easing,\n    cancelKey: cancelKeyFor(id, channel),\n    interpolate: (a, b, t) => a + (b - a) * t,\n    onTick: (t) => {\n      animator.colorOverrides.set(id, channel, interp(opts.from, opts.to, t));\n    },\n    onDone: () => {\n      animator.colorOverrides.clear(id, channel);\n      opts.onDone?.();\n    },\n  });\n}\n\n/** Options for `springVertexColors`. */\nexport interface SpringVertexColorsOptions {\n  id: string;\n  channel: VertexColorChannel;\n  /** Per-anchor RGBA in 0..1 floats. See `TweenVertexColorsOptions.to`. */\n  to: readonly number[];\n  /** Per-anchor RGBA in 0..1 floats. See `TweenVertexColorsOptions.from`. */\n  from: readonly number[];\n  preset?: SpringPresetName;\n  stiffness?: number;\n  damping?: number;\n  mass?: number;\n  interpolation?: ColorSpace;\n  interpolate?: ColorInterpolate;\n  onDone?: () => void;\n}\n\n/** `tweenVertexColors` driven by a spring instead of a duration. Same override\n *  semantics. */\nexport function springVertexColors(\n  animator: Animator,\n  opts: SpringVertexColorsOptions,\n): AnimationHandle {\n  validateLengths(opts.from, opts.to);\n  const interp = resolveInterpolator(opts);\n  const { id, channel } = opts;\n  return animator.spring<number>({\n    from: 0,\n    to: 1,\n    preset: opts.preset,\n    stiffness: opts.stiffness,\n    damping: opts.damping,\n    mass: opts.mass,\n    cancelKey: cancelKeyFor(id, channel),\n    interpolate: (a, b, t) => a + (b - a) * t,\n    onTick: (t) => {\n      const clamped = Math.max(0, Math.min(1, t));\n      animator.colorOverrides.set(id, channel, interp(opts.from, opts.to, clamped));\n    },\n    onDone: () => {\n      animator.colorOverrides.clear(id, channel);\n      opts.onDone?.();\n    },\n  });\n}\n\n/** Options for `cycleVertexColors`. */\nexport interface CycleVertexColorsOptions {\n  id: string;\n  channel: VertexColorChannel;\n  msPerCycle: number;\n  direction?: 1 | -1;\n  easing?: EasingSpec;\n  interpolation?: ColorSpace;\n  /** Custom interpolator. Receives two RGBA arrays in 0..1 floats and a\n   *  progress `t` in 0..1; returns the blended array in 0..1 floats. */\n  interpolate?: ColorInterpolate;\n}\n\n/** Removes an installed color cycle. Unlike the other color helpers this is\n *  not an `AnimationHandle`, because a cycle has no progress to pause or\n *  scale — it only ends. */\nexport interface CycleHandle {\n  cancel(): void;\n}\n\n/** Register a function override that phase-rotates the base color array\n *  along the path index. Returns a handle whose `cancel()` removes the\n *  override.\n *\n *  The override computes its value purely from `performance.now()`, so\n *  there's no per-frame progress to register with the animator's tick\n *  loop. To keep the loop alive (so `<SceneCanvas animator>`'s onTick\n *  subscription continues firing redraws while the cycle is installed),\n *  cycleVertexColors holds an `animator.keepAlive()` entry for the\n *  lifetime of the cycle; `cancel()` releases it. */\nexport function cycleVertexColors(\n  animator: Animator,\n  opts: CycleVertexColorsOptions,\n): CycleHandle {\n  const interp = resolveInterpolator(opts);\n  const { id, channel } = opts;\n  const direction = opts.direction ?? 1;\n  const easing = resolveEasing(opts.easing);\n\n  const override = (base: readonly number[], tMs: number): number[] => {\n    const n = base.length / 4;\n    if (n === 0) return base.slice();\n    const raw = (tMs / opts.msPerCycle) * n * direction;\n    const cycles = raw / n;\n    const cycleFrac = cycles - Math.floor(cycles);\n    const easedFrac = easing(cycleFrac);\n    const easedRaw = (Math.floor(cycles) + easedFrac) * n;\n    const phase = ((easedRaw % n) + n) % n;\n    const phaseInt = Math.floor(phase);\n    const phaseFrac = phase - phaseInt;\n\n    const out = new Array<number>(base.length);\n    for (let i = 0; i < n; i++) {\n      const aIdx = ((i + phaseInt) % n) * 4;\n      const bIdx = ((i + phaseInt + 1) % n) * 4;\n      const a = [base[aIdx], base[aIdx + 1], base[aIdx + 2], base[aIdx + 3]];\n      const b = [base[bIdx], base[bIdx + 1], base[bIdx + 2], base[bIdx + 3]];\n      const blended = interp(a, b, phaseFrac);\n      const k = i * 4;\n      out[k] = blended[0];\n      out[k + 1] = blended[1];\n      out[k + 2] = blended[2];\n      out[k + 3] = blended[3];\n    }\n    return out;\n  };\n\n  animator.colorOverrides.set(id, channel, override);\n  // Cycle's \"value\" is a function of wall-clock time, not a tween-style\n  // progress. We don't register a per-frame ticking animation, so without\n  // an explicit keep-alive entry the animator's RAF loop would idle and\n  // SceneCanvas's onTick redraw subscription would never fire. Keep the\n  // loop running until cancel().\n  const releaseKeepAlive = animator.keepAlive();\n\n  return {\n    cancel(): void {\n      animator.colorOverrides.clear(id, channel);\n      releaseKeepAlive();\n    },\n  };\n}\n\n/** Options for `staggerVertexColors`. `origin` picks which anchor the wave\n *  starts from and `perAnchorDelay` how far behind each successive anchor\n *  runs. */\nexport interface StaggerVertexColorsOptions {\n  id: string;\n  channel: VertexColorChannel;\n  /** Per-anchor RGBA in 0..1 floats. See `TweenVertexColorsOptions.to`. */\n  to: readonly number[];\n  /** Per-anchor RGBA in 0..1 floats. See `TweenVertexColorsOptions.from`. */\n  from: readonly number[];\n  anchorMs: number;\n  perAnchorDelay: number;\n  origin?: 'first' | 'last' | number;\n  easing?: EasingSpec;\n  interpolation?: ColorSpace;\n  interpolate?: ColorInterpolate;\n  onDone?: () => void;\n}\n\n/** Run the same color change across a node's anchors as a wave, each anchor\n *  starting later than the one before it. Same override semantics as\n *  `tweenVertexColors`. */\nexport function staggerVertexColors(\n  animator: Animator,\n  opts: StaggerVertexColorsOptions,\n): AnimationHandle {\n  validateLengths(opts.from, opts.to);\n  const interp = resolveInterpolator(opts);\n  const { id, channel, from, to, anchorMs, perAnchorDelay } = opts;\n  const n = from.length / 4;\n  const easing = resolveEasing(opts.easing);\n\n  const originIndex =\n    opts.origin === 'last' ? n - 1 :\n    typeof opts.origin === 'number' ? Math.max(0, Math.min(n - 1, opts.origin)) :\n    0;\n\n  const maxDistance = Math.max(originIndex, n - 1 - originIndex);\n  const totalMs = maxDistance * perAnchorDelay + anchorMs;\n\n  const colorsAt = (elapsedMs: number): number[] => {\n    const out = new Array<number>(from.length);\n    for (let i = 0; i < n; i++) {\n      const distance = Math.abs(i - originIndex);\n      const startMs = distance * perAnchorDelay;\n      const localT = Math.max(0, Math.min(1, (elapsedMs - startMs) / anchorMs));\n      const eased = easing(localT);\n      const k = i * 4;\n      const fSlice = [from[k], from[k + 1], from[k + 2], from[k + 3]];\n      const tSlice = [to[k], to[k + 1], to[k + 2], to[k + 3]];\n      const blended = interp(fSlice, tSlice, eased);\n      out[k] = blended[0];\n      out[k + 1] = blended[1];\n      out[k + 2] = blended[2];\n      out[k + 3] = blended[3];\n    }\n    return out;\n  };\n\n  // A plain array, not a function override: painters call those with their\n  // own clock (`performance.now()`), not time since this stagger began.\n  animator.colorOverrides.set(id, channel, colorsAt(0));\n\n  return animator.tween<number>({\n    from: 0,\n    to: 1,\n    ms: totalMs,\n    easing: linear,\n    cancelKey: cancelKeyFor(id, channel),\n    interpolate: (a, b, t) => a + (b - a) * t,\n    onTick: (t) => {\n      animator.colorOverrides.set(id, channel, colorsAt(t * totalMs));\n    },\n    onDone: () => {\n      animator.colorOverrides.clear(id, channel);\n      opts.onDone?.();\n    },\n  });\n}\n\n// ─── Color-array constructors ───────────────────────────────────────\n//\n// Helpers that build the per-anchor RGBA arrays the tween/cycle/stagger\n// helpers above (and `stroke.vertexColors` on draw commands) consume.\n// Values are in the 0..1 range the renderer expects — emitting bytes\n// (0..255) clamps every channel to 1.0 on the GPU and renders white.\n\n/** Build an n-anchor rainbow RGBA array sweeping the hue wheel. The\n *  output is suitable to pass directly into `stroke.vertexColors`,\n *  `tweenVertexColors({ from: rainbowVertexColors(n) })`, or any\n *  other API that wants per-anchor color floats. */\nexport function rainbowVertexColors(\n  n: number,\n  opts: { saturation?: number; lightness?: number; alpha?: number } = {},\n): number[] {\n  const saturation = opts.saturation ?? 0.8;\n  const lightness = opts.lightness ?? 0.6;\n  const alpha = opts.alpha ?? 1;\n  const out: number[] = [];\n  for (let i = 0; i < n; i++) {\n    const h = (i * 360) / Math.max(1, n);\n    const [r, g, b] = hslToRgbUnit(h, saturation, lightness);\n    out.push(r, g, b, alpha);\n  }\n  return out;\n}\n\n/** Build an n-anchor solid RGBA array. Shorthand for\n *  `[r, g, b, a, r, g, b, a, …]` — the array a `tweenVertexColors`\n *  `to`-target typically needs. */\nexport function solidVertexColors(\n  n: number,\n  r: number,\n  g: number,\n  b: number,\n  a = 1,\n): number[] {\n  const out: number[] = [];\n  for (let i = 0; i < n; i++) out.push(r, g, b, a);\n  return out;\n}\n\n/** HSL → RGB in 0..1 (hue in degrees). Delegates to the single internal\n *  implementation in `renderer/math/color.ts` so there's only one HSL→RGB\n *  formula in the package. Kept local so consumers building hue-cycled\n *  color arrays via `huesweepVertexColors` don't have to roll their own. */\nfunction hslToRgbUnit(h: number, s: number, l: number): [number, number, number] {\n  return hslToRgb(h, s, l);\n}\n"],"mappings":"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"}

package/dist/animation/engine/axes.js

@@ -0,0 +1,36 @@
+import { isPlainObject as e } from "../../core/isPlainObject.js";
+//#region src/animation/engine/axes.ts
+function t(t) {
+	if (typeof t == "number") return {
+		count: 1,
+		shape: "number",
+		to: (e) => [e],
+		from: (e, t = 0) => e[t]
+	};
+	if (Array.isArray(t)) return t.every((e) => typeof e == "number") ? {
+		count: t.length,
+		shape: `array:${t.length}`,
+		to: (e) => e.slice(),
+		from: (e, n = 0) => {
+			let r = Array(t.length);
+			for (let t = 0; t < r.length; t++) r[t] = e[n + t];
+			return r;
+		}
+	} : null;
+	if (!e(t)) return null;
+	let n = Object.keys(t).sort();
+	return n.length === 0 || !n.every((e) => typeof t[e] == "number") ? null : {
+		count: n.length,
+		shape: `object:${JSON.stringify(n)}`,
+		to: (e) => n.map((t) => e[t]),
+		from: (e, t = 0) => {
+			let r = {};
+			for (let i = 0; i < n.length; i++) r[n[i]] = e[t + i];
+			return r;
+		}
+	};
+}
+//#endregion
+export { t as axesOf };
+
+//# sourceMappingURL=axes.js.map

package/dist/animation/engine/axes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"axes.js","names":["axesOf","sample","v","a","at","x","out","i","isPlainObject","keys","k"],"sources":["../../../src/animation/engine/axes.ts"],"sourcesContent":["import { isPlainObject } from '../../core/isPlainObject';\n\n/** How a value maps to the flat numbers blits moves, and back. */\nexport interface Axes<T> {\n  count: number;\n  /** Equal for two values exactly when their axes line up one for one. */\n  shape: string;\n  to(v: T): number[];\n  /** The value whose `count` axes start at `at` in `a`. */\n  from(a: ArrayLike<number>, at?: number): T;\n}\n\n/** The axes of `sample`'s shape: a number, a plain array of numbers, or a plain object whose\n *  fields are all numbers. Null for any other shape, which blits cannot move. */\nexport function axesOf<T>(sample: T): Axes<T> | null {\n  if (typeof sample === 'number') {\n    return { count: 1, shape: 'number', to: (v) => [v as number], from: (a, at = 0) => a[at] as T };\n  }\n  if (Array.isArray(sample)) {\n    if (!sample.every((x) => typeof x === 'number')) return null;\n    return {\n      count: sample.length,\n      shape: `array:${sample.length}`,\n      to: (v) => (v as number[]).slice(),\n      from: (a, at = 0) => {\n        const out = new Array<number>(sample.length);\n        for (let i = 0; i < out.length; i++) out[i] = a[at + i]!;\n        return out as T;\n      },\n    };\n  }\n  if (!isPlainObject(sample)) return null;\n  const keys = Object.keys(sample).sort();\n  if (keys.length === 0 || !keys.every((k) => typeof sample[k] === 'number')) return null;\n  return {\n    count: keys.length,\n    shape: `object:${JSON.stringify(keys)}`,\n    to: (v) => keys.map((k) => (v as Record<string, number>)[k]!),\n    from: (a, at = 0) => {\n      const out: Record<string, number> = {};\n      for (let i = 0; i < keys.length; i++) out[keys[i]!] = a[at + i]!;\n      return out as T;\n    },\n  };\n}\n"],"mappings":";;AAcA,SAAgBA,EAAU,GAA2B;CACnD,IAAI,OAAOC,KAAW,UACpB,OAAO;EAAE,OAAO;EAAG,OAAO;EAAU,KAAK,MAAM,CAACC,CAAW;EAAG,OAAO,GAAG,IAAK,MAAMC,EAAEC;CAAS;CAEhG,IAAI,MAAM,QAAQH,CAAM,GAEtB,OADKA,EAAO,OAAO,MAAM,OAAOI,KAAM,QAAQ,IACvC;EACL,OAAOJ,EAAO;EACd,OAAO,SAASA,EAAO;EACvB,KAAK,MAAOC,EAAe,MAAM;EACjC,OAAO,GAAG,IAAK,MAAM;GACnB,IAAMI,IAAU,MAAcL,EAAO,MAAM;GAC3C,KAAK,IAAIM,IAAI,GAAGA,IAAID,EAAI,QAAQ,KAAK,EAAIC,KAAKJ,EAAEC,IAAKG;GACrD,OAAOD;EACT;CACF,IAVwD;CAY1D,IAAI,CAACE,EAAcP,CAAM,GAAG,OAAO;CACnC,IAAMQ,IAAO,OAAO,KAAKR,CAAM,CAAC,CAAC,KAAK;CAEtC,OADIQ,EAAK,WAAW,KAAK,CAACA,EAAK,OAAO,MAAM,OAAOR,EAAOS,MAAO,QAAQ,IAAU,OAC5E;EACL,OAAOD,EAAK;EACZ,OAAO,UAAU,KAAK,UAAUA,CAAI;EACpC,KAAK,MAAMA,EAAK,KAAK,MAAOP,EAA6BQ,EAAG;EAC5D,OAAO,GAAG,IAAK,MAAM;GACnB,IAAMJ,IAA8B,CAAC;GACrC,KAAK,IAAI,IAAI,GAAG,IAAIG,EAAK,QAAQ,KAAK,EAAIA,EAAK,MAAON,EAAEC,IAAK;GAC7D,OAAOE;EACT;CACF;AACF"}

package/dist/animation/engine/codec.js

@@ -0,0 +1,170 @@
+import { glide as e, kit as t, mix as n, spring as r, sum as i, tween as a, vec as o } from "@msb235/blits";
+//#region src/animation/engine/codec.ts
+function s() {
+	let s = /* @__PURE__ */ new Map(), c = /* @__PURE__ */ new Map(), l = [], u = 0, d = (e) => {
+		let r = s.get(e);
+		if (!r) {
+			let a = n(t({ v: o(e, i()) }));
+			a.sync(u), r = {
+				axes: e,
+				mix: a,
+				ids: [],
+				subs: [],
+				pending: /* @__PURE__ */ new Set(),
+				dirty: !1,
+				idle: 0,
+				cols: { v: /* @__PURE__ */ new Float64Array() }
+			}, s.set(e, r);
+		}
+		return r;
+	}, f = (e, t) => {
+		e.slot = -1, e.cols = e.held, e.at = 0, e.lane.pending.add(t), e.lane.dirty = !0;
+	}, p = (e, t) => {
+		let n = e.lane;
+		if (n.dirty = !0, e.slot < 0) {
+			n.pending.delete(t);
+			return;
+		}
+		let r = n.ids.pop(), i = n.subs.pop();
+		if (r === t) return;
+		let a = n.axes, o = n.ids.length * a;
+		n.cols.v.copyWithin(e.slot * a, o, o + a), n.ids[e.slot] = r, n.subs[e.slot] = i, i.slot = e.slot, i.at = e.slot * a;
+	}, m = (e) => {
+		let t = e.ids.slice(), n = e.subs;
+		for (let r of e.pending) {
+			let i = c.get(r);
+			i.slot = t.length, i.at = i.slot * e.axes, i.cols = e.cols.v, t.push(r), n.push(i);
+		}
+		if (e.pending.clear(), e.ids = t, e.cols.v.length !== t.length * e.axes) {
+			e.cols = { v: new Float64Array(t.length * e.axes) };
+			for (let t of n) t.cols = e.cols.v;
+		}
+		e.dirty = !1;
+	}, h = (t, n, i) => {
+		let a = i.to == null ? e("v", {
+			from: i.from,
+			ms: 1e3 * i.mass / i.damping
+		}) : r("v", {
+			from: i.from,
+			to: i.from,
+			stiffness: i.stiffness,
+			damping: i.damping,
+			mass: i.mass
+		}), o = t.mix.cue({
+			patch: a,
+			subjects: [n]
+		});
+		return i.to && a.to(n, i.to, 0), a.push(n, i.velocity, 0), {
+			handle: o,
+			patch: a
+		};
+	}, g = (e) => {
+		let t = c.get(e);
+		if (!t) throw Error(`codec: no subject ${e}`);
+		return t;
+	}, _ = (e, t) => e.patch.read(t) ?? {
+		value: e.spring.from.slice(),
+		velocity: e.spring.velocity.slice()
+	};
+	function v(e) {
+		let t = c.get(e);
+		t && (t.queued ? t.queued = void 0 : (t.handle.fade({ over: 0 }), t.lane.mix.drop(e)), p(t, e), c.delete(e));
+	}
+	return {
+		frame(e) {
+			for (let e of l) {
+				let t = e.queued;
+				if (!t) continue;
+				e.queued = void 0;
+				let n = a("v", {
+					from: t.from.slice(),
+					to: t.from.slice(),
+					ms: t.ms,
+					ease: t.ease
+				});
+				e.handle = e.lane.mix.cue({
+					patch: n,
+					subjects: [t.id]
+				}), e.patch = n, n.to(t.id, t.to.slice(), 0), e.queuedRate !== void 0 && (e.handle.rate = e.queuedRate);
+			}
+			l.length = 0, u += e;
+			for (let e of s.values()) {
+				if (e.dirty && m(e), e.ids.length === 0 && ++e.idle >= 2) {
+					s.delete(e.axes);
+					continue;
+				}
+				e.mix.sync(u), e.ids.length !== 0 && (e.idle = 0, e.mix.pull(e.ids, e.cols));
+			}
+		},
+		tween(e) {
+			if (e.to.length !== e.from.length) throw Error(`codec: tween ${e.id} goes from ${e.from.length} axes to ${e.to.length}`);
+			let t = d(e.from.length), n = Float64Array.from(e.from), r = {
+				kind: "tween",
+				lane: t,
+				slot: -1,
+				held: n,
+				cols: n,
+				at: 0,
+				queued: e
+			};
+			return c.set(e.id, r), f(r, e.id), l.push(r), r;
+		},
+		spring(e) {
+			let t = {
+				...e,
+				from: e.from.slice(),
+				to: e.to && e.to.slice(),
+				velocity: e.velocity.slice()
+			}, n = d(t.axes), { handle: r, patch: i } = h(n, e.id, t), a = Float64Array.from(t.from), o = {
+				kind: "spring",
+				lane: n,
+				handle: r,
+				patch: i,
+				spring: t,
+				slot: -1,
+				held: a,
+				cols: a,
+				at: 0
+			};
+			c.set(e.id, o), f(o, e.id);
+			let s = e.id;
+			return o.motion = () => _(o, s), o;
+		},
+		retarget(e, t) {
+			let n = g(e);
+			if (n.kind === "tween") throw Error(`codec: subject ${e} is a tween; tweens are not retargeted`);
+			let r = n.spring;
+			if (t == null == (r.to == null)) {
+				if (!t) return;
+				r.to = t.slice(), n.patch.to(e, r.to);
+				return;
+			}
+			let i = _(n, e), a = n.handle.rate, o = {
+				...r,
+				to: t && t.slice(),
+				from: i.value,
+				velocity: i.velocity
+			};
+			n.handle.fade({ over: 0 });
+			let { handle: s, patch: c } = h(n.lane, e, o);
+			s.rate = a, n.handle = s, n.patch = c, n.spring = o;
+		},
+		push(e, t) {
+			let n = g(e);
+			n.spring && !n.patch.read(e) && (n.spring.velocity = t.slice()), n.patch.push?.(e, t);
+		},
+		rate(e, t) {
+			let n = g(e);
+			n.queued ? n.queuedRate = t : n.handle.rate = t;
+		},
+		stop: v,
+		has: (e) => c.has(e),
+		voiceCount() {
+			return c.size;
+		}
+	};
+}
+//#endregion
+export { s as createCodec };
+
+//# sourceMappingURL=codec.js.map

package/dist/animation/engine/codec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec.js","names":["springPatch","tweenPatch","createCodec","lanes","subjects","queue","time","laneOf","l","axes","m","mix","kit","vec","sum","join","s","id","depart","last","moved","n","from","rebuild","ids","subs","springVoice","patch","sp","glide","spring","handle","get","current","stop","sub","q","tween","dtMs","held","to","now","rate","next","velocity"],"sources":["../../../src/animation/engine/codec.ts"],"sourcesContent":["import {\n  glide, kit, mix, spring as springPatch, sum, tween as tweenPatch, vec,\n  type Handle, type Mix, type Motion, type Patch,\n} from '@msb235/blits';\n\nexport interface TweenStart {\n  id: number; ms: number; ease: (u: number) => number;\n  /** Endpoints as axes. A tween whose caller blends its own values passes [0] and [1]. */\n  from: number[]; to: number[];\n}\nexport interface SpringStart {\n  id: number; axes: number;\n  from: number[]; to: number[] | null; velocity: number[];\n  stiffness: number; damping: number; mass: number;\n}\n/** One subject's value, kept current in place by the codec. Valid until the subject stops. */\nexport interface Reader {\n  /** The array holding the subject's axes as the last `frame` read them, from `at` on. It is the\n   *  codec's own, shared with other subjects and valid until the next `frame`. */\n  readonly cols: Float64Array;\n  /** Where the subject's axes start in `cols`. */\n  readonly at: number;\n}\nexport interface SpringReader extends Reader {\n  /** Position and velocity at the last `frame`. */\n  motion(): { value: number[]; velocity: number[] };\n}\nexport interface Codec {\n  /** Advances the codec's clock by `dtMs` of animator time, then reads every subject. */\n  frame(dtMs: number): void;\n  tween(s: TweenStart): Reader;\n  spring(s: SpringStart): SpringReader;\n  retarget(id: number, to: number[] | null): void;\n  push(id: number, velocity: number[]): void;\n  /** Plays `id` at rate `rate` from where it is, without a jump. */\n  rate(id: number, rate: number): void;\n  stop(id: number): void;\n  /** Whether `id` is one of the codec's subjects. */\n  has(id: number): boolean;\n  /** How many voices the codec is running, one per subject; for tests and diagnostics. */\n  voiceCount(): number;\n}\n\ntype Out = { v: number[] };\n\n/** What the codec calls on a motion patch: a tween has no `push`, a glide no `to`. */\ninterface Moves {\n  to?(id: number, target: number[], at?: number): void;\n  read(id: number, at?: number): Motion<number[]> | undefined;\n  push?(id: number, velocity: number[], at?: number): void;\n}\n\n/** One mix per axis count, since a kit's channel width is fixed. */\ninterface Lane {\n  axes: number;\n  mix: Mix<number, Out>;\n  /** The subjects `pull` reads, by slot. Joins wait in `pending` until the next `frame`. */\n  ids: number[];\n  /** Each slot's subject, beside `ids`. */\n  subs: Subject[];\n  pending: Set<number>;\n  dirty: boolean;\n  /** Frames in a row it has had no subjects at; it retires at the second. */\n  idle: number;\n  cols: { v: Float64Array };\n}\n\ninterface Subject extends Reader {\n  cols: Float64Array;\n  at: number;\n  kind: 'tween' | 'spring';\n  lane: Lane;\n  handle: Handle<number>;\n  patch: Moves;\n  /** The codec's own copy, kept at the subject's motion as of its last re-cue. */\n  spring?: SpringStart;\n  /** Index into the lane's `ids`; -1 while no frame has read it. */\n  slot: number;\n  /** What `cols` points at while `slot` is -1. */\n  held: Float64Array;\n  /** A tween's start, until the next `frame` cues its voice; `handle` and `patch` exist only after. */\n  queued?: TweenStart;\n  /** A rate asked for while queued. */\n  queuedRate?: number;\n  motion?(): { value: number[]; velocity: number[] };\n}\n\nexport function createCodec(): Codec {\n  const lanes = new Map<number, Lane>();\n  const subjects = new Map<number, Subject>();\n  // Tweens are cued together at the next frame, not one by one as they start: a burst of starts then\n  // keeps the caller's objects together rather than each a voice apart, which the frame loop reads.\n  const queue: Subject[] = [];\n  let time = 0;\n\n  const laneOf = (axes: number): Lane => {\n    let l = lanes.get(axes);\n    if (!l) {\n      const m = mix<number, Out>(kit<Out>({ v: vec(axes, sum()) }));\n      m.sync(time);\n      l = { axes, mix: m, ids: [], subs: [], pending: new Set(), dirty: false, idle: 0, cols: { v: new Float64Array(0) } };\n      lanes.set(axes, l);\n    }\n    return l;\n  };\n  const join = (s: Subject, id: number): void => {\n    s.slot = -1;\n    s.cols = s.held;\n    s.at = 0;\n    s.lane.pending.add(id);\n    s.lane.dirty = true;\n  };\n  const depart = (s: Subject, id: number): void => {\n    const l = s.lane;\n    l.dirty = true;\n    if (s.slot < 0) { l.pending.delete(id); return; }\n    const last = l.ids.pop()!;\n    const moved = l.subs.pop()!;\n    if (last === id) return;\n    const n = l.axes;\n    const from = l.ids.length * n;\n    l.cols.v.copyWithin(s.slot * n, from, from + n);\n    l.ids[s.slot] = last;\n    l.subs[s.slot] = moved;\n    moved.slot = s.slot;\n    moved.at = s.slot * n;\n  };\n  const rebuild = (l: Lane): void => {\n    const ids = l.ids.slice();\n    const subs = l.subs;\n    for (const id of l.pending) {\n      const s = subjects.get(id)!;\n      s.slot = ids.length;\n      s.at = s.slot * l.axes;\n      s.cols = l.cols.v;\n      ids.push(id);\n      subs.push(s);\n    }\n    l.pending.clear();\n    l.ids = ids;\n    if (l.cols.v.length !== ids.length * l.axes) {\n      l.cols = { v: new Float64Array(ids.length * l.axes) };\n      for (const s of subs) s.cols = l.cols.v;\n    }\n    l.dirty = false;\n  };\n\n  // A voice cued now reads voice time 0 at codec time `time`. Each patch holds its subject at rest\n  // at `from`, and the codec releases it with a `to` or `push` timed at 0.\n  const springVoice = (l: Lane, id: number, sp: SpringStart): { handle: Handle<number>; patch: Moves } => {\n    // With no target the spring force is zero whatever the stiffness, leaving damping alone:\n    // velocity falls as exp(-t * damping / mass), a glide whose time constant is mass / damping.\n    const patch: Moves & Patch<number, Out, void> = sp.to == null\n      ? glide<number, Out, number[]>('v', { from: sp.from, ms: (1000 * sp.mass) / sp.damping })\n      : springPatch<number, Out, number[]>('v', {\n        from: sp.from, to: sp.from, stiffness: sp.stiffness, damping: sp.damping, mass: sp.mass,\n      });\n    const handle = l.mix.cue({ patch, subjects: [id] });\n    if (sp.to) patch.to!(id, sp.to, 0);\n    patch.push!(id, sp.velocity, 0);\n    return { handle, patch };\n  };\n\n  const get = (id: number): Subject => {\n    const s = subjects.get(id);\n    if (!s) throw new Error(`codec: no subject ${id}`);\n    return s;\n  };\n  /** A spring subject's motion now: as its voice last read it, else where it was last placed. */\n  const current = (s: Subject, id: number): { value: number[]; velocity: number[] } =>\n    s.patch.read(id) ?? { value: s.spring!.from.slice(), velocity: s.spring!.velocity.slice() };\n\n  function stop(id: number): void {\n    const s = subjects.get(id);\n    if (!s) return;\n    if (s.queued) s.queued = undefined;\n    else {\n      s.handle.fade({ over: 0 });\n      s.lane.mix.drop(id);\n    }\n    depart(s, id);\n    subjects.delete(id);\n  }\n\n  return {\n    frame(dtMs) {\n      for (const sub of queue) {\n        const q = sub.queued;\n        if (!q) continue;\n        sub.queued = undefined;\n        const patch = tweenPatch<number, Out, number[]>('v', { from: q.from.slice(), to: q.from.slice(), ms: q.ms, ease: q.ease });\n        sub.handle = sub.lane.mix.cue({ patch, subjects: [q.id] });\n        sub.patch = patch;\n        patch.to(q.id, q.to.slice(), 0);\n        if (sub.queuedRate !== undefined) sub.handle.rate = sub.queuedRate;\n      }\n      queue.length = 0;\n      time += dtMs;\n      for (const l of lanes.values()) {\n        if (l.dirty) rebuild(l);\n        if (l.ids.length === 0 && ++l.idle >= 2) {\n          lanes.delete(l.axes);\n          continue;\n        }\n        l.mix.sync(time);\n        if (l.ids.length === 0) continue;\n        l.idle = 0;\n        l.mix.pull(l.ids, l.cols);\n      }\n    },\n    tween(s) {\n      if (s.to.length !== s.from.length) {\n        throw new Error(`codec: tween ${s.id} goes from ${s.from.length} axes to ${s.to.length}`);\n      }\n      const l = laneOf(s.from.length);\n      const held = Float64Array.from(s.from);\n      const sub = { kind: 'tween', lane: l, slot: -1, held, cols: held, at: 0, queued: s } as Subject;\n      subjects.set(s.id, sub);\n      join(sub, s.id);\n      queue.push(sub);\n      return sub;\n    },\n    spring(s) {\n      const sp = { ...s, from: s.from.slice(), to: s.to && s.to.slice(), velocity: s.velocity.slice() };\n      const l = laneOf(sp.axes);\n      const { handle, patch } = springVoice(l, s.id, sp);\n      const held = Float64Array.from(sp.from);\n      const sub: Subject = { kind: 'spring', lane: l, handle, patch, spring: sp, slot: -1, held, cols: held, at: 0 };\n      subjects.set(s.id, sub);\n      join(sub, s.id);\n      const id = s.id;\n      sub.motion = () => current(sub, id);\n      return sub as Subject & SpringReader;\n    },\n    retarget(id, to) {\n      const s = get(id);\n      if (s.kind === 'tween') throw new Error(`codec: subject ${id} is a tween; tweens are not retargeted`);\n      const sp = s.spring!;\n      if ((to == null) === (sp.to == null)) {\n        if (!to) return;\n        sp.to = to.slice();\n        s.patch.to!(id, sp.to);\n        return;\n      }\n      // Held and free run different patches, so the subject is re-cued from where it is.\n      const now = current(s, id);\n      const rate = s.handle.rate;\n      const next = { ...sp, to: to && to.slice(), from: now.value, velocity: now.velocity };\n      s.handle.fade({ over: 0 });\n      const { handle, patch } = springVoice(s.lane, id, next);\n      handle.rate = rate;\n      s.handle = handle;\n      s.patch = patch;\n      s.spring = next;\n    },\n    push(id, velocity) {\n      const s = get(id);\n      if (s.spring && !s.patch.read(id)) s.spring.velocity = velocity.slice();\n      s.patch.push?.(id, velocity);\n    },\n    rate(id, rate) {\n      const s = get(id);\n      if (s.queued) s.queuedRate = rate;\n      else s.handle.rate = rate;\n    },\n    stop,\n    has: (id) => subjects.has(id),\n    voiceCount() {\n      return subjects.size;\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/animation/engine/integrator.js

@@ -0,0 +1,12 @@
+//#region src/animation/engine/integrator.ts
+function e(e, t, n, r, i, a, o, s) {
+	let c = r ?? t, l = e.subtract(t, c), u = e.scale(l, r == null ? 0 : -i), d = e.scale(n, -a), f = e.scale(e.add(u, d), 1 / o), p = e.add(n, e.scale(f, s));
+	return {
+		value: e.add(t, e.scale(p, s)),
+		velocity: p
+	};
+}
+//#endregion
+export { e as stepSpring };
+
+//# sourceMappingURL=integrator.js.map

package/dist/animation/engine/integrator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"integrator.js","names":["stepSpring","ref","target","value","displacement","ops","springForce","k","dampingForce","velocity","damping","accel","mass","v","dt"],"sources":["../../../src/animation/engine/integrator.ts"],"sourcesContent":["export interface VectorOps<T> {\n  add(a: T, b: T): T;\n  subtract(a: T, b: T): T;\n  scale(v: T, k: number): T;\n}\n\n/** One semi-implicit Euler step of a damped spring toward `target`, or of pure damping when\n *  `target` is null. Returns the new value and velocity. */\nexport function stepSpring<T>(\n  ops: VectorOps<T>,\n  value: T, velocity: T, target: T | null,\n  k: number, damping: number, mass: number, dt: number,\n): { value: T; velocity: T } {\n  const ref = target ?? value;\n  const displacement = ops.subtract(value, ref);\n  const springForce = ops.scale(displacement, target == null ? 0 : -k);\n  const dampingForce = ops.scale(velocity, -damping);\n  const accel = ops.scale(ops.add(springForce, dampingForce), 1 / mass);\n  const v = ops.add(velocity, ops.scale(accel, dt));\n  return { value: ops.add(value, ops.scale(v, dt)), velocity: v };\n}\n"],"mappings":";AAQA,SAAgBA,EACd,GACA,GAAU,GAAa,GACvB,GAAW,GAAiB,GAAc,GACf;CAC3B,IAAMC,IAAMC,KAAUC,GAChBC,IAAeC,EAAI,SAASF,GAAOF,CAAG,GACtCK,IAAcD,EAAI,MAAMD,GAAcF,KAAU,OAAO,IAAI,CAACK,CAAC,GAC7DC,IAAeH,EAAI,MAAMI,GAAU,CAACC,CAAO,GAC3CC,IAAQN,EAAI,MAAMA,EAAI,IAAIC,GAAaE,CAAY,GAAG,IAAII,CAAI,GAC9DC,IAAIR,EAAI,IAAII,GAAUJ,EAAI,MAAMM,GAAOG,CAAE,CAAC;CAChD,OAAO;EAAE,OAAOT,EAAI,IAAIF,GAAOE,EAAI,MAAMQ,GAAGC,CAAE,CAAC;EAAG,UAAUD;CAAE;AAChE"}