@weasel-js/core 1.9.4 → 1.10.1

package/dist/animation/colorHelpers.js

@@ -1,135 +0,0 @@
-import { hslToRgb as e } from "../renderer/math/color.js";
-import { lerpColorArray as t } from "@weasel-js/paint";
-import { linear as n, resolveEasing as r } from "@weasel-js/geom";
-//#region src/animation/colorHelpers.ts
-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 a(e) {
-	if (e.interpolate) return e.interpolate;
-	let n = e.interpolation ?? "rgb";
-	return (e, r, i) => t(e, r, i, n);
-}
-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: o(r, s),
-		interpolate: (e, t, n) => e + (t - e) * n,
-		onTick: (i) => {
-			e.colorOverrides.set(r, s, n(t.from, t.to, i));
-		},
-		onDone: () => {
-			e.colorOverrides.clear(r, s), t.onDone?.();
-		}
-	});
-}
-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,
-		preset: t.preset,
-		stiffness: t.stiffness,
-		damping: t.damping,
-		mass: t.mass,
-		cancelKey: o(r, s),
-		interpolate: (e, t, n) => e + (t - e) * n,
-		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(r, s), t.onDone?.();
-		}
-	});
-}
-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 = 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 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 = 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(i, o), l();
-	} };
-}
-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(c, l, v(0)), e.tween({
-		from: 0,
-		to: 1,
-		ms: _,
-		easing: n,
-		cancelKey: o(c, l),
-		interpolate: (e, t, n) => e + (t - e) * n,
-		onTick: (t) => {
-			e.colorOverrides.set(c, l, v(t * _));
-		},
-		onDone: () => {
-			e.colorOverrides.clear(c, l), t.onDone?.();
-		}
-	});
-}
-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] = p(t * 360 / Math.max(1, e), n, r);
-		a.push(o, s, c, i);
-	}
-	return a;
-}
-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 p(t, n, r) {
-	return e(t, n, r);
-}
-//#endregion
-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 +0,0 @@
-{"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/colorRegistry.js

@@ -1,37 +0,0 @@
-//#region src/animation/colorRegistry.ts
-var e = class {
-	map = /* @__PURE__ */ new Map();
-	_version = 0;
-	set(e, t, n) {
-		let r = this.map.get(e);
-		r || (r = {}, this.map.set(e, r)), r[t] = n, this._version++;
-	}
-	clear(e, t) {
-		let n = this.map.get(e);
-		n && t in n && (delete n[t], !n.fill && !n.stroke && this.map.delete(e), this._version++);
-	}
-	clearAll() {
-		this.map.size !== 0 && (this.map.clear(), this._version++);
-	}
-	get(e, t) {
-		return this.map.get(e)?.[t];
-	}
-	has(e) {
-		return this.map.has(e);
-	}
-	resolve(e, t, n, r) {
-		let i = this.get(e, t);
-		if (i === void 0) return n;
-		if (typeof i != "function") return i;
-		if (n === void 0) return;
-		let a = i(n, r);
-		return a.length === n.length ? a : n;
-	}
-	version() {
-		return this._version;
-	}
-};
-//#endregion
-export { e as ColorOverrideRegistry };
-
-//# sourceMappingURL=colorRegistry.js.map

package/dist/animation/colorRegistry.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"colorRegistry.js","names":["ColorOverrideRegistry","entry","id","channel","override","base","result","tMs"],"sources":["../../src/animation/colorRegistry.ts"],"sourcesContent":["/** Which of a node's two per-anchor color arrays an override applies to. */\nexport type VertexColorChannel = 'fill' | 'stroke';\n\n/** Function-form override: receives the consumer-supplied base color\n *  array and the current animation timestamp (ms, from the animator's\n *  clock). Returns a flat RGBA float array (values in 0..1, matching\n *  the renderer's `stroke.vertexColors` / `PathDrawCommand.vertexColors`\n *  color space) of the same length as `base`. */\nexport type ColorOverrideFn = (base: readonly number[], tMs: number) => number[];\n\n/** Either a static per-anchor RGBA float array (0..1) or a function-form\n *  override (see {@link ColorOverrideFn}). */\nexport type ColorOverride = readonly number[] | ColorOverrideFn;\n\ninterface NodeOverrides {\n  fill?: ColorOverride;\n  stroke?: ColorOverride;\n}\n\n/** Per-node, per-channel store of color overrides. Attached to `useAnimator` as\n *  `animator.colorOverrides`; painted onto scene nodes by `<SceneCanvas animator>`\n *  and onto a `createPathLayer`'s nodes by its `colorOverrides` option. */\nexport class ColorOverrideRegistry {\n  private readonly map = new Map<string, NodeOverrides>();\n  private _version = 0;\n\n  set(id: string, channel: VertexColorChannel, override: ColorOverride): void {\n    let entry = this.map.get(id);\n    if (!entry) {\n      entry = {};\n      this.map.set(id, entry);\n    }\n    entry[channel] = override;\n    this._version++;\n  }\n\n  clear(id: string, channel: VertexColorChannel): void {\n    const entry = this.map.get(id);\n    if (!entry) return;\n    if (!(channel in entry)) return;\n    delete entry[channel];\n    if (!entry.fill && !entry.stroke) this.map.delete(id);\n    this._version++;\n  }\n\n  clearAll(): void {\n    if (this.map.size === 0) return;\n    this.map.clear();\n    this._version++;\n  }\n\n  get(id: string, channel: VertexColorChannel): ColorOverride | undefined {\n    return this.map.get(id)?.[channel];\n  }\n\n  /** Whether anything overrides `id`, on either channel. */\n  has(id: string): boolean {\n    return this.map.has(id);\n  }\n\n  /**\n   * The colors to paint on `id`'s `channel`, given the colors the painter would\n   * otherwise paint and the frame's timestamp. A function override needs that\n   * `base` and must return an array of its length; failing either, `base`\n   * stands.\n   */\n  resolve(\n    id: string,\n    channel: VertexColorChannel,\n    base: readonly number[] | undefined,\n    tMs: number,\n  ): readonly number[] | undefined {\n    const override = this.get(id, channel);\n    if (override === undefined) return base;\n    if (typeof override !== 'function') return override;\n    if (base === undefined) return undefined;\n    const result = override(base, tMs);\n    return result.length === base.length ? result : base;\n  }\n\n  version(): number {\n    return this._version;\n  }\n}\n"],"mappings":";AAsBA,IAAaA,IAAb,MAAmC;CACjC,sBAAuB,IAAI,IAA2B;CACtD,WAAmB;CAEnB,IAAI,GAAY,GAA6B,GAA+B;EAC1E,IAAIC,IAAQ,KAAK,IAAI,IAAIC,CAAE;EAM3B,AALKD,MACH,IAAQ,CAAC,GACT,KAAK,IAAI,IAAIC,GAAID,CAAK,IAExB,EAAME,KAAWC,GACjB,KAAK;CACP;CAEA,MAAM,GAAY,GAAmC;EACnD,IAAMH,IAAQ,KAAK,IAAI,IAAIC,CAAE;EAC7B,AAAKD,KACCE,KAAWF,MACjB,OAAOA,EAAME,IACT,CAACF,EAAM,QAAQ,CAACA,EAAM,UAAQ,KAAK,IAAI,OAAOC,CAAE,GACpD,KAAK;CACP;CAEA,WAAiB;EACf,AAAI,KAAK,IAAI,SAAS,MACtB,KAAK,IAAI,MAAM,GACf,KAAK;CACP;CAEA,IAAI,GAAY,GAAwD;EACtE,OAAO,KAAK,IAAI,IAAIA,CAAE,CAAC,GAAGC;CAC5B;CAGA,IAAI,GAAqB;EACvB,OAAO,KAAK,IAAI,IAAID,CAAE;CACxB;CAQA,QACE,GACA,GACA,GACA,GAC+B;EAC/B,IAAME,IAAW,KAAK,IAAIF,GAAIC,CAAO;EACrC,IAAIC,MAAa,KAAA,GAAW,OAAOC;EACnC,IAAI,OAAOD,KAAa,YAAY,OAAOA;EAC3C,IAAIC,MAAS,KAAA,GAAW;EACxB,IAAMC,IAASF,EAASC,GAAME,CAAG;EACjC,OAAOD,EAAO,WAAWD,EAAK,SAASC,IAASD;CAClD;CAEA,UAAkB;EAChB,OAAO,KAAK;CACd;AACF"}

package/dist/animation/engine/axes.js

@@ -1,36 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,170 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,12 +0,0 @@
-//#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

@@ -1 +0,0 @@
-{"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"}

package/dist/animation/loop.js

@@ -1,60 +0,0 @@
-//#region src/animation/loop.ts
-function e(e, t, n = {}) {
-	let r = n.count ?? Infinity, i = 0, a = !1, o = null, s = e({
-		kind: "loop",
-		cancelKey: n.cancelKey,
-		label: n.label
-	});
-	s.setOnCancel(() => {
-		a = !0, o?.cancel(), o = null;
-	});
-	let c = (e, t) => {
-		o && (e ? o.pause() : o.resume(), o.setTimeScale(t));
-	};
-	s.setOnRate(c);
-	let l = () => {
-		if (!a) {
-			if (i >= r) {
-				o = null, a = !0, s.finish(), n.onDone?.();
-				return;
-			}
-			o = t(i++, l), (s.isPaused() || s.timeScale() !== 1) && c(s.isPaused(), s.timeScale());
-		}
-	};
-	return l(), {
-		id: s.id,
-		cancel: () => s.cancel(),
-		pause: () => s.pause(),
-		resume: () => s.resume(),
-		setTimeScale: (e) => s.setTimeScale(e),
-		timeScale: () => s.timeScale(),
-		isPaused: () => s.isPaused()
-	};
-}
-function t(t, n, r) {
-	let i = r.direction ?? "restart";
-	return e((e) => n({
-		...e,
-		kind: "tweenLoop"
-	}), (e, n) => {
-		let a = i === "reverse" || i === "alternate" && e % 2 == 1, o = a ? r.to : r.from, s = a ? r.from : r.to;
-		return t.tween({
-			from: o,
-			to: s,
-			ms: r.ms,
-			easing: r.easing,
-			interpolate: r.interpolate,
-			onTick: r.onTick,
-			onDone: n
-		});
-	}, {
-		count: r.count,
-		onDone: r.onDone,
-		cancelKey: r.cancelKey,
-		label: r.label
-	});
-}
-//#endregion
-export { e as createLoop, t as createTweenLoop };
-
-//# sourceMappingURL=loop.js.map

package/dist/animation/loop.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"loop.js","names":["createLoop","max","opts","iteration","cancelled","current","supervisor","createSupervisor","applyRate","paused","timeScale","next","factory","s","createTweenLoop","direction","o","flipped","i","from","to","animator"],"sources":["../../src/animation/loop.ts"],"sourcesContent":["import type { SupervisorFactory } from './supervisor';\nimport type {\n  AnimationHandle,\n  Animator,\n  LoopFactory,\n  LoopOptions,\n  TweenLoopOptions,\n} from './types';\n\n/**\n * Loop primitive. Repeatedly invokes `factory(i, next)` to produce a child\n * animation. The factory is responsible for wiring its returned handle's\n * `onDone` to call `next` — that's how the loop advances. Pause/resume/\n * setTimeScale reach the current child and each later one; cancel stops the\n * in-flight child and prevents future iterations.\n *\n * The loop is registered with the animator under a supervisor entry, so\n * `animator.cancel(handle)`, `animator.cancelKey(key)`, and\n * `animator.isActive(key)` all work for it.\n */\nexport function createLoop(\n  createSupervisor: SupervisorFactory,\n  factory: LoopFactory,\n  opts: LoopOptions = {},\n): AnimationHandle {\n  const max = opts.count ?? Infinity;\n  let iteration = 0;\n  let cancelled = false;\n  let current: AnimationHandle | null = null;\n\n  const supervisor = createSupervisor({ kind: 'loop', cancelKey: opts.cancelKey, label: opts.label });\n  supervisor.setOnCancel(() => {\n    // External cancel path (animator.cancel/cancelKey or handle.cancel).\n    // Mark cancelled so `next` short-circuits; tear down the current child.\n    cancelled = true;\n    current?.cancel();\n    current = null;\n  });\n\n  const applyRate = (paused: boolean, timeScale: number): void => {\n    if (!current) return;\n    if (paused) current.pause();\n    else current.resume();\n    current.setTimeScale(timeScale);\n  };\n  supervisor.setOnRate(applyRate);\n\n  const next = (): void => {\n    if (cancelled) return;\n    if (iteration >= max) {\n      current = null;\n      // Natural completion: deregister the supervisor so isActive() goes\n      // false. `cancelled` makes a late `next` a no-op.\n      cancelled = true;\n      supervisor.finish();\n      opts.onDone?.();\n      return;\n    }\n    const i = iteration++;\n    current = factory(i, next);\n    if (supervisor.isPaused() || supervisor.timeScale() !== 1) {\n      applyRate(supervisor.isPaused(), supervisor.timeScale());\n    }\n  };\n\n  next();\n\n  return {\n    id: supervisor.id,\n    cancel: () => supervisor.cancel(),\n    pause: () => supervisor.pause(),\n    resume: () => supervisor.resume(),\n    setTimeScale: (s) => supervisor.setTimeScale(s),\n    timeScale: () => supervisor.timeScale(),\n    isPaused: () => supervisor.isPaused(),\n  };\n}\n\n/**\n * Sugar over `createLoop` for the common case of looping a tween between two\n * values. `direction` controls per-iteration from/to:\n *   - `restart` (default): from→to every iteration\n *   - `reverse`: to→from every iteration\n *   - `alternate`: even iterations from→to, odd iterations to→from\n */\nexport function createTweenLoop<T>(\n  animator: Animator,\n  createSupervisor: SupervisorFactory,\n  opts: TweenLoopOptions<T>,\n): AnimationHandle {\n  const direction = opts.direction ?? 'restart';\n  return createLoop(\n    (o) => createSupervisor({ ...o, kind: 'tweenLoop' }),\n    (i, next) => {\n      const flipped = direction === 'reverse' || (direction === 'alternate' && i % 2 === 1);\n      const from = flipped ? opts.to : opts.from;\n      const to = flipped ? opts.from : opts.to;\n      return animator.tween({\n        from,\n        to,\n        ms: opts.ms,\n        easing: opts.easing,\n        interpolate: opts.interpolate,\n        onTick: opts.onTick,\n        onDone: next,\n      });\n    },\n    { count: opts.count, onDone: opts.onDone, cancelKey: opts.cancelKey, label: opts.label },\n  );\n}\n"],"mappings":";AAoBA,SAAgBA,EACd,GACA,GACA,IAAoB,CAAC,GACJ;CACjB,IAAMC,IAAMC,EAAK,SAAS,UACtBC,IAAY,GACZC,IAAY,IACZC,IAAkC,MAEhCC,IAAaC,EAAiB;EAAE,MAAM;EAAQ,WAAWL,EAAK;EAAW,OAAOA,EAAK;CAAM,CAAC;CAClG,EAAW,kBAAkB;EAK3B,AAFA,IAAY,IACZG,GAAS,OAAO,GAChB,IAAU;CACZ,CAAC;CAED,IAAMG,KAAa,GAAiB,MAA4B;EAC9D,AAAKH,MACDI,IAAQJ,EAAQ,MAAM,IACrBA,EAAQ,OAAO,GACpBA,EAAQ,aAAaK,CAAS;CAChC;CACA,EAAW,UAAUF,CAAS;CAE9B,IAAMG,UAAmB;EACvB,IAAI,IACJ;OAAIR,KAAaF,GAAK;IAMpB,AALA,IAAU,MAGV,IAAY,IACZK,EAAW,OAAO,GAClBJ,EAAK,SAAS;IACd;GACF;GAGA,AADA,IAAUU,EAAQ,KAAGD,CAAI,IACrBL,EAAW,SAAS,KAAKA,EAAW,UAAU,MAAM,MACtDE,EAAUF,EAAW,SAAS,GAAGA,EAAW,UAAU,CAAC;EAJzD;CAMF;CAIA,OAFAK,EAAK,GAEE;EACL,IAAIL,EAAW;EACf,cAAcA,EAAW,OAAO;EAChC,aAAaA,EAAW,MAAM;EAC9B,cAAcA,EAAW,OAAO;EAChC,eAAe,MAAMA,EAAW,aAAaO,CAAC;EAC9C,iBAAiBP,EAAW,UAAU;EACtC,gBAAgBA,EAAW,SAAS;CACtC;AACF;AASA,SAAgBQ,EACd,GACA,GACA,GACiB;CACjB,IAAMC,IAAYb,EAAK,aAAa;CACpC,OAAOF,GACJ,MAAMO,EAAiB;EAAE,GAAGS;EAAG,MAAM;CAAY,CAAC,IAClD,GAAG,MAAS;EACX,IAAMC,IAAUF,MAAc,aAAcA,MAAc,eAAeG,IAAI,KAAM,GAC7EC,IAAOF,IAAUf,EAAK,KAAKA,EAAK,MAChCkB,IAAKH,IAAUf,EAAK,OAAOA,EAAK;EACtC,OAAOmB,EAAS,MAAM;GACpB;GACA;GACA,IAAInB,EAAK;GACT,QAAQA,EAAK;GACb,aAAaA,EAAK;GAClB,QAAQA,EAAK;GACb,QAAQS;EACV,CAAC;CACH,GACA;EAAE,OAAOT,EAAK;EAAO,QAAQA,EAAK;EAAQ,WAAWA,EAAK;EAAW,OAAOA,EAAK;CAAM,CACzF;AACF"}

package/dist/animation/observe.js

@@ -1,23 +0,0 @@
-//#region src/animation/observe.ts
-var e = class {
-	listeners = /* @__PURE__ */ new Set();
-	get watched() {
-		return this.listeners.size > 0;
-	}
-	add(e) {
-		return this.listeners.add(e), () => {
-			this.listeners.delete(e);
-		};
-	}
-	emit(e) {
-		for (let t of this.listeners) try {
-			t(e);
-		} catch (e) {
-			console.error("useAnimator: watch listener threw", e);
-		}
-	}
-};
-//#endregion
-export { e as AnimatorEventHub };
-
-//# sourceMappingURL=observe.js.map

package/dist/animation/observe.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"observe.js","names":["AnimatorEventHub","listener","event","err"],"sources":["../../src/animation/observe.ts"],"sourcesContent":["import type { AnimatorEvent, AnimatorListener } from './types';\n\n/** The listener set behind `animator.watch`. Every emit site checks `watched`\n *  first and builds its event only then, so an unwatched animator allocates\n *  nothing for observability. */\nexport class AnimatorEventHub {\n  private readonly listeners = new Set<AnimatorListener>();\n\n  get watched(): boolean {\n    return this.listeners.size > 0;\n  }\n\n  add(listener: AnimatorListener): () => void {\n    this.listeners.add(listener);\n    return () => { this.listeners.delete(listener); };\n  }\n\n  emit(event: AnimatorEvent): void {\n    for (const listener of this.listeners) {\n      try { listener(event); } catch (err) { console.error('useAnimator: watch listener threw', err); }\n    }\n  }\n}\n"],"mappings":";AAKA,IAAaA,IAAb,MAA8B;CAC5B,4BAA6B,IAAI,IAAsB;CAEvD,IAAI,UAAmB;EACrB,OAAO,KAAK,UAAU,OAAO;CAC/B;CAEA,IAAI,GAAwC;EAE1C,OADA,KAAK,UAAU,IAAIC,CAAQ,SACd;GAAE,KAAK,UAAU,OAAOA,CAAQ;EAAG;CAClD;CAEA,KAAK,GAA4B;EAC/B,KAAK,IAAMA,KAAY,KAAK,WAC1B,IAAI;GAAE,EAASC,CAAK;EAAG,SAASC,GAAK;GAAE,QAAQ,MAAM,qCAAqCA,CAAG;EAAG;CAEpG;AACF"}

package/dist/animation/rig/blendPoses.js

@@ -1,43 +0,0 @@
-import { IDENTITY_JOINT as e } from "./types.js";
-//#region src/animation/rig/blendPoses.ts
-var t = Math.PI * 2;
-function n(e, n) {
-	let r = (n - e) % t;
-	return r > Math.PI && (r -= t), r < -Math.PI && (r += t), r;
-}
-var r = [
-	"x",
-	"y",
-	"scaleX",
-	"scaleY"
-];
-function i(t, i) {
-	if (t.length !== i.length) throw Error("blendPoses: poses and weights must have the same length");
-	let a = i.reduce((e, t) => e + t, 0);
-	if (a === 0) return {};
-	let o = i.map((e) => e / a), s = /* @__PURE__ */ new Set();
-	for (let e of t) for (let t of Object.keys(e)) s.add(t);
-	let c = {};
-	for (let i of s) {
-		let a = {};
-		for (let n of r) {
-			let r = 0;
-			for (let a = 0; a < t.length; a += 1) {
-				let s = t[a][i]?.[n];
-				r += (s ?? e[n]) * o[a];
-			}
-			a[n] = r;
-		}
-		let s = t[0][i]?.rotation ?? 0, l = 0;
-		for (let e = 0; e < t.length; e += 1) {
-			let r = t[e][i]?.rotation ?? 0;
-			l += n(s, r) * o[e];
-		}
-		a.rotation = s + l, c[i] = a;
-	}
-	return c;
-}
-//#endregion
-export { i as blendPoses };
-
-//# sourceMappingURL=blendPoses.js.map

package/dist/animation/rig/blendPoses.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"blendPoses.js","names":["TAU","shortestDelta","d","b","a","FIELDS","blendPoses","poses","weights","total","s","w","norm","names","p","k","out","name","joint","field","acc","i","v","IDENTITY_JOINT","base","rot"],"sources":["../../../src/animation/rig/blendPoses.ts"],"sourcesContent":["import { IDENTITY_JOINT, type JointTransform, type Pose } from './types';\n\nconst TAU = Math.PI * 2;\n\n/** Shortest signed angular delta from `a` to `b`, in (-PI, PI]. */\nfunction shortestDelta(a: number, b: number): number {\n  let d = (b - a) % TAU;\n  if (d > Math.PI) d -= TAU;\n  if (d < -Math.PI) d += TAU;\n  return d;\n}\n\nconst FIELDS: (keyof JointTransform)[] = ['x', 'y', 'scaleX', 'scaleY'];\n\n/**\n * Weighted blend of poses. Weights are normalized, so `[1, 1]` means an even\n * mix. A joint absent from a pose contributes its identity delta, and a field\n * absent from a joint contributes that field's identity — 0 for translation and\n * rotation, 1 for scale. Blending scale toward 0 for an absent field would\n * collapse the joint, which is the bug this avoids.\n *\n * Rotation blends the short way around the circle, so 0.1 and TAU-0.1 average\n * to 0 rather than to PI.\n *\n * This doubles as the interpolator for a `SampledTrack<Pose>`: interpolating\n * between two poses at `u` is `blendPoses([a, b], [1 - u, u])`.\n */\nexport function blendPoses(poses: Pose[], weights: number[]): Pose {\n  if (poses.length !== weights.length) {\n    throw new Error('blendPoses: poses and weights must have the same length');\n  }\n  const total = weights.reduce((s, w) => s + w, 0);\n  if (total === 0) return {};\n  const norm = weights.map((w) => w / total);\n\n  const names = new Set<string>();\n  for (const p of poses) for (const k of Object.keys(p)) names.add(k);\n\n  const out: Pose = {};\n  for (const name of names) {\n    const joint: Partial<JointTransform> = {};\n\n    for (const field of FIELDS) {\n      let acc = 0;\n      for (let i = 0; i < poses.length; i += 1) {\n        const v = poses[i][name]?.[field];\n        acc += (v ?? IDENTITY_JOINT[field]) * norm[i];\n      }\n      joint[field] = acc;\n    }\n\n    // Rotation accumulates as a delta from the first pose's value so wrapping\n    // is handled once, against a fixed reference.\n    const base = poses[0][name]?.rotation ?? 0;\n    let rot = 0;\n    for (let i = 0; i < poses.length; i += 1) {\n      const v = poses[i][name]?.rotation ?? 0;\n      rot += shortestDelta(base, v) * norm[i];\n    }\n    joint.rotation = base + rot;\n\n    out[name] = joint;\n  }\n  return out;\n}\n"],"mappings":";;AAEA,IAAMA,IAAM,KAAK,KAAK;AAGtB,SAASC,EAAc,GAAW,GAAmB;CACnD,IAAIC,KAAKC,IAAIC,KAAKJ;CAGlB,OAFIE,IAAI,KAAK,OAAI,KAAKF,IAClBE,IAAI,CAAC,KAAK,OAAI,KAAKF,IAChBE;AACT;AAEA,IAAMG,IAAmC;CAAC;CAAK;CAAK;CAAU;AAAQ;AAetE,SAAgBC,EAAW,GAAe,GAAyB;CACjE,IAAIC,EAAM,WAAWC,EAAQ,QAC3B,MAAU,MAAM,yDAAyD;CAE3E,IAAMC,IAAQD,EAAQ,QAAQ,GAAG,MAAME,IAAIC,GAAG,CAAC;CAC/C,IAAIF,MAAU,GAAG,OAAO,CAAC;CACzB,IAAMG,IAAOJ,EAAQ,KAAK,MAAMG,IAAIF,CAAK,GAEnCI,oBAAQ,IAAI,IAAY;CAC9B,KAAK,IAAMC,KAAKP,GAAO,KAAK,IAAMQ,KAAK,OAAO,KAAKD,CAAC,GAAG,EAAM,IAAIC,CAAC;CAElE,IAAMC,IAAY,CAAC;CACnB,KAAK,IAAMC,KAAQJ,GAAO;EACxB,IAAMK,IAAiC,CAAC;EAExC,KAAK,IAAMC,KAASd,GAAQ;GAC1B,IAAIe,IAAM;GACV,KAAK,IAAIC,IAAI,GAAGA,IAAId,EAAM,QAAQ,KAAK,GAAG;IACxC,IAAMe,IAAIf,EAAMc,EAAE,CAACJ,EAAK,GAAGE;IAC3B,MAAQG,KAAKC,EAAeJ,MAAUP,EAAKS;GAC7C;GACA,EAAMF,KAASC;EACjB;EAIA,IAAMI,IAAOjB,EAAM,EAAE,CAACU,EAAK,EAAE,YAAY,GACrCQ,IAAM;EACV,KAAK,IAAIJ,IAAI,GAAGA,IAAId,EAAM,QAAQ,KAAK,GAAG;GACxC,IAAMe,IAAIf,EAAMc,EAAE,CAACJ,EAAK,EAAE,YAAY;GACtC,KAAOhB,EAAcuB,GAAMF,CAAC,IAAIV,EAAKS;EACvC;EAGA,AAFA,EAAM,WAAWG,IAAOC,GAExB,EAAIR,KAAQC;CACd;CACA,OAAOF;AACT"}