@weasel-js/core 1.7.0 → 1.7.2

package/dist/animation/useAnimator.js

@@ -0,0 +1,329 @@
+import { useVisibleRaf as e } from "../scheduling/useVisibleRaf.js";
+import { createLoop as t, createTweenLoop as n } from "./loop.js";
+import { createStagger as r } from "./stagger.js";
+import { createTimeline as i } from "./timeline/createTimeline.js";
+import { ColorOverrideRegistry as a } from "./colorRegistry.js";
+import { AnimatorEventHub as o } from "./observe.js";
+import { SPRING_PRESETS as s, easeOut as c, resolveEasing as l } from "@weasel-js/geom";
+import { useCallback as u, useEffect as d, useInsertionEffect as f, useMemo as p, useRef as m } from "react";
+import { useLatest as h } from "@weasel-js/react";
+//#region src/animation/useAnimator.ts
+var g = (e, t, n) => e + (t - e) * n;
+function _(e) {
+	let t = e.preset ? s[e.preset] : null;
+	return {
+		stiffness: e.stiffness ?? t?.stiffness ?? 170,
+		damping: e.damping ?? t?.damping ?? 26,
+		mass: e.mass ?? t?.mass ?? 1
+	};
+}
+function v(s = {}) {
+	let v = h(s), y = m(/* @__PURE__ */ new Map()), b = m(1), x = m(0), S = m(1), C = m(!1), w = m(new a()), T = m(/* @__PURE__ */ new Set()), E = m(null), D = e(u((e) => {
+		E.current?.(e);
+	}, []), {
+		requestFrame: s.requestFrame,
+		cancelFrame: s.cancelFrame,
+		onResume: () => {
+			for (let e of y.current.values()) e.lastRealNow = null;
+		}
+	}), O = h(D), k = m(!0), A = m(!1), j = () => !k.current && (A.current || (A.current = !0, (typeof process > "u" || process.env.NODE_ENV !== "production") && console.error("weasel useAnimator: animation tick fired after the host component unmounted. This usually means cleanup logic was bypassed — check for refactors that removed the unmount effect or replaced cancelAll with a custom path.")), !0), { api: M, tickAll: N } = p(() => {
+		let e = () => (v.current.now ?? (typeof performance < "u" ? performance.now.bind(performance) : Date.now))(), a = {
+			setTimer: (e, t) => (v.current.setTimer ?? ((e, t) => setTimeout(e, t)))(e, t),
+			clearTimer: (e) => (v.current.clearTimer ?? ((e) => clearTimeout(e)))(e),
+			now: e
+		}, s = /* @__PURE__ */ new Map(), u = (e) => {
+			let t = s.get(e);
+			if (t) {
+				s.delete(e);
+				for (let e of t) e();
+			}
+		}, d = (e, t) => {
+			let n = s.get(e) ?? [];
+			return n.push(t), s.set(e, n), () => {
+				let n = s.get(e);
+				if (!n) return;
+				let r = n.indexOf(t);
+				r >= 0 && n.splice(r, 1), n.length === 0 && s.delete(e);
+			};
+		}, f = new o(), p = (e) => {
+			if (!e.info) {
+				let t = {
+					id: e.id,
+					kind: e.kind
+				};
+				e.cancelKey != null && (t.key = e.cancelKey), e.label != null && (t.label = e.label), e.info = t;
+			}
+			return e.info;
+		}, m = (e) => {
+			let t = y.current.get(e);
+			t && !t.ended && (t.ended = !0, f.watched && f.emit({
+				type: "end",
+				animation: p(t)
+			}));
+		}, h = (e, t) => {
+			let n = y.current.get(e);
+			n && (n.onCancel?.(), y.current.delete(e), u(e), f.watched && !n.ended && f.emit(t ? {
+				type: "interrupt",
+				animation: p(n),
+				by: p(t)
+			} : {
+				type: "cancel",
+				animation: p(n)
+			}));
+		}, E = (e) => {
+			let t = [];
+			for (let n of y.current.values()) {
+				let r = n.lastRealNow == null ? 0 : Math.max(0, e - n.lastRealNow);
+				n.lastRealNow = e;
+				let i = C.current ? 0 : S.current * (n.paused ? 0 : n.timeScale);
+				n.virtualNow += r * i, x.current += 1;
+				try {
+					n.tick(n.virtualNow, i) && t.push(n);
+				} finally {
+					--x.current;
+				}
+			}
+			for (let e of t) y.current.get(e.id) === e && (m(e.id), y.current.delete(e.id), u(e.id));
+			for (let e of T.current) try {
+				e();
+			} catch (e) {
+				console.error("useAnimator: onTick subscriber threw", e);
+			}
+			y.current.size > 0 && O.current.request();
+		}, D = () => {
+			y.current.size !== 0 && O.current.request();
+		}, k = (e, t) => {
+			let n = [];
+			for (let t of y.current.values()) t.cancelKey === e && n.push(t.id);
+			for (let e of n) h(e, t);
+		}, A = (t) => {
+			let n = t;
+			return t.cancelKey != null && !t.keepExisting && k(t.cancelKey, n), n.paused = !1, n.timeScale = 1, n.virtualNow = 0, n.lastRealNow = e(), y.current.set(n.id, n), f.watched && f.emit({
+				type: "start",
+				animation: p(n)
+			}), D(), {
+				id: n.id,
+				cancel: () => h(n.id),
+				pause: () => {
+					let e = y.current.get(n.id);
+					e && (e.paused = !0);
+				},
+				resume: () => {
+					let e = y.current.get(n.id);
+					e && (e.paused = !1);
+				},
+				setTimeScale: (e) => {
+					let t = y.current.get(n.id);
+					t && (t.timeScale = e);
+				},
+				timeScale: () => y.current.get(n.id)?.timeScale ?? 1,
+				isPaused: () => y.current.get(n.id)?.paused ?? !1
+			};
+		}, M = ({ kind: e, cancelKey: t, label: n }) => {
+			let r = b.current++, i, a = A({
+				id: r,
+				kind: e,
+				cancelKey: t,
+				label: n,
+				tick: () => !1,
+				onCancel: () => i?.()
+			});
+			return {
+				id: a.id,
+				cancel: a.cancel,
+				pause: a.pause,
+				resume: a.resume,
+				setTimeScale: a.setTimeScale,
+				timeScale: a.timeScale,
+				isPaused: a.isPaused,
+				setOnCancel: (e) => {
+					i = e;
+				},
+				finish: () => {
+					y.current.has(r) && (m(r), y.current.delete(r), u(r));
+				},
+				cancelKey: t
+			};
+		}, N = (e) => {
+			let t = b.current++, n = l(e.easing ?? c), r = e.interpolator ? e.interpolator(e.from, e.to) : null, i = r ? null : e.interpolate ?? ((e, t, n) => {
+				if (typeof e == "number" && typeof t == "number") return g(e, t, n);
+				throw Error("tween: interpolate or interpolator is required for non-numeric T");
+			}), a = !1;
+			return A({
+				id: t,
+				kind: "tween",
+				cancelKey: e.cancelKey,
+				label: e.label,
+				progress: (t) => e.ms <= 0 ? 1 : Math.min(1, t / e.ms),
+				tick(o) {
+					if (j()) return !0;
+					let s = o - 0, c = e.ms <= 0 ? 1 : Math.min(1, Math.max(0, s / e.ms)), l = n(c), u = r ? r(l) : i(e.from, e.to, l);
+					return e.onTick(u), c >= 1 && !a && (a = !0, y.current.has(t) && (m(t), e.onDone?.()), !0);
+				}
+			});
+		}, P = (e, t = "physics") => {
+			let n = b.current++;
+			if (typeof e.from != "number" && (!e.add || !e.subtract || !e.scale || !e.magnitude)) throw Error("physics: add/subtract/scale/magnitude are required for non-numeric T");
+			let r = e.add ?? ((e, t) => e + t), i = e.subtract ?? ((e, t) => e - t), a = e.scale ?? ((e, t) => e * t), o = e.magnitude ?? ((e) => Math.abs(e)), { stiffness: s, damping: c, mass: l } = _(e), u = e.restThreshold ?? .01, d = e.to ?? null, f = e.from, p = e.velocity ?? a(e.from, 0), h = null;
+			return {
+				...A({
+					id: n,
+					kind: t,
+					cancelKey: e.cancelKey,
+					label: e.label,
+					tick(t) {
+						if (j()) return !0;
+						if (h == null) return h = t, d == null && o(p) < u ? (m(n), e.onDone?.(), !0) : (e.onTick(f), !1);
+						let g = Math.min(.064, (t - h) / 1e3);
+						h = t;
+						let _ = i(f, d ?? f), v = a(_, d == null ? 0 : -s), y = a(p, -c), b = a(r(v, y), 1 / l);
+						p = r(p, a(b, g)), f = r(f, a(p, g)), e.onTick(f);
+						let x = o(p) < u, S = d == null || o(i(f, d)) < u;
+						return x && S ? (d != null && e.onTick(d), m(n), e.onDone?.(), !0) : !1;
+					}
+				}),
+				setTarget: (e) => {
+					d = e;
+				},
+				setVelocity: (e) => {
+					p = e;
+				}
+			};
+		}, F = {
+			tween: N,
+			spring: (e) => P(e, "spring"),
+			decay: (e) => {
+				let t = e.friction ?? .95, n = -Math.log(t);
+				return P({
+					from: e.from,
+					to: null,
+					velocity: e.velocity,
+					stiffness: 0,
+					damping: n,
+					mass: 1,
+					restThreshold: e.threshold ?? .5,
+					add: e.add,
+					subtract: (t, n) => e.add(t, e.scale(n, -1)),
+					scale: e.scale,
+					magnitude: e.magnitude,
+					onTick: e.onTick,
+					onDone: e.onDone,
+					cancelKey: e.cancelKey,
+					label: e.label
+				}, "decay");
+			},
+			physics: P,
+			cancel: (e) => h(e.id),
+			cancelKey: (e) => k(e),
+			cancelAll: () => {
+				let e = [];
+				for (let t of y.current.values()) t.onCancel?.(), e.push(t);
+				y.current.clear();
+				for (let t of e) u(t.id);
+				if (f.watched) for (let t of e) f.emit({
+					type: "cancel",
+					animation: p(t)
+				});
+				O.current.cancel();
+			},
+			isActive: (e) => {
+				if (e == null) return y.current.size > 0;
+				for (let t of y.current.values()) if (t.cancelKey === e) return !0;
+				return !1;
+			},
+			isTicking: () => x.current > 0,
+			pause: () => {
+				C.current = !0;
+			},
+			resume: () => {
+				C.current = !1;
+			},
+			isPaused: () => C.current,
+			setTimeScale: (e) => {
+				S.current = e;
+			},
+			timeScale: () => S.current,
+			pauseKey: (e) => {
+				for (let t of y.current.values()) t.cancelKey === e && (t.paused = !0);
+			},
+			resumeKey: (e) => {
+				for (let t of y.current.values()) t.cancelKey === e && (t.paused = !1);
+			},
+			setTimeScaleByKey: (e, t) => {
+				for (let n of y.current.values()) n.cancelKey === e && (n.timeScale = t);
+			},
+			loop: (e, n) => t(M, e, n),
+			tweenLoop: (e) => n(F, M, e),
+			stagger: ((e, t, n, i) => r(F, a, M, d, e, t, n, i)),
+			timeline: (e) => {
+				let t = b.current++, n = () => {
+					let e = y.current.get(t);
+					return e && p(e);
+				};
+				return i(A, t, e, {
+					get watched() {
+						return f.watched;
+					},
+					fire: (e, t, r, i) => {
+						let a = n();
+						a && f.emit({
+							type: "fire",
+							animation: a,
+							track: e,
+							path: t.slice(),
+							event: r,
+							lateBy: i
+						});
+					},
+					lap: (e) => {
+						let t = n();
+						t && f.emit({
+							type: "lap",
+							animation: t,
+							lap: e
+						});
+					}
+				});
+			},
+			colorOverrides: w.current,
+			onTick: (e) => (T.current.add(e), () => {
+				T.current.delete(e);
+			}),
+			keepAlive: () => {
+				let e = M({ kind: "keepAlive" });
+				return () => e.cancel();
+			},
+			watch: (e) => f.add(e),
+			live: () => {
+				let e = [];
+				for (let t of y.current.values()) {
+					let n = {
+						...p(t),
+						paused: t.paused,
+						timeScale: t.timeScale,
+						elapsed: t.virtualNow,
+						...t.progress ? { progress: t.progress(t.virtualNow) } : {}
+					};
+					e.push(n);
+				}
+				return e;
+			}
+		};
+		return {
+			api: F,
+			tickAll: E
+		};
+	}, [O, v]);
+	return f(() => {
+		E.current = N;
+	}, [N]), d(() => {
+		let e = w.current;
+		return k.current = !0, () => {
+			k.current = !1, M.cancelAll(), e.clearAll();
+		};
+	}, [M]), M;
+}
+//#endregion
+export { v as useAnimator };
+
+//# sourceMappingURL=useAnimator.js.map

package/dist/animation/useAnimator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAnimator.js","names":["numericLerp","a","b","t","resolveSpringConstants","preset","o","SPRING_PRESETS","useAnimator","optsRef","useLatest","opts","animations","useRef","nextId","tickDepth","globalTimeScale","globalPaused","colorOverrides","ColorOverrideRegistry","tickSubscribers","tickAllRef","frameLoop","useVisibleRaf","useCallback","anim","frameLoopRef","mountedRef","trippedRef","tripwire","useMemo","now","staggerTimers","c","m","cb","ms","x","h","completionListeners","fireCompletion","ls","id","watchCompletion","cur","idx","hub","AnimatorEventHub","infoOf","info","reportEnd","retire","by","tickAll","finished","realDt","scale","sub","err","ensureLoop","cancelByKey","ids","key","register","seed","s","createSupervisor","onCancelCb","base","tween","easing","resolveEasing","easeOut","factoryFn","perTickInterp","lastValueEmitted","virtualNow","elapsed","nowMs","eased","value","physics","add","subtract","v","k","magnitude","kBase","restThreshold","target","velocity","lastTime","dt","displacement","springForce","dampingForce","damping","accel","mass","velRested","posRested","newTo","api","friction","handle","retired","createLoop","factory","loopOpts","createTweenLoop","tweenLoopOpts","createStagger","items","delay","staggerOpts","createTimeline","animation","path","sup","listener","rows","row","useInsertionEffect","useEffect","overrides"],"sources":["../../src/animation/useAnimator.ts"],"sourcesContent":["import { useCallback, useEffect, useInsertionEffect, useMemo, useRef } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { useVisibleRaf } from '../scheduling/useVisibleRaf';\nimport { easeOut, SPRING_PRESETS, resolveEasing } from '@weasel-js/geom';\nimport { createLoop, createTweenLoop } from './loop';\nimport { createStagger, type StaggerTimers } from './stagger';\nimport { createTimeline } from './timeline/createTimeline';\nimport { ColorOverrideRegistry } from './colorRegistry';\nimport { AnimatorEventHub } from './observe';\nimport type { Supervisor, SupervisorOptions, WatchCompletion } from './supervisor';\nimport type {\n  AnimationHandle,\n  AnimationInfo,\n  AnimationKind,\n  Animator,\n  TweenOptions,\n  SpringOptions,\n  DecayOptions,\n  PhysicsOptions,\n  PhysicsHandle,\n  UseAnimatorOptions,\n  LiveAnimation,\n} from './types';\nimport type { TimelineOptions } from './timeline/types';\n\ninterface ActiveAnimation {\n  id: number;\n  kind: AnimationKind;\n  cancelKey?: string;\n  label?: string;\n  /** Built the first time something reports on this entry, then shared. */\n  info?: AnimationInfo;\n  /** 0–1 where the animation has an end to measure against. */\n  progress?(virtualNow: number): number;\n  /** Its `end` is reported, though the entry stays on the table until the\n   *  frame's ticks are done. */\n  ended?: boolean;\n  paused: boolean;\n  timeScale: number;\n  virtualNow: number;\n  lastRealNow: number | null;\n  /** Returns true when finished. Called once per frame with the current\n   *  virtual-ms timestamp and the effective scale it advanced at this frame. */\n  tick(virtualNow: number, scale: number): boolean;\n  /** Called when the animation is cancelled. Skips onDone. */\n  onCancel?(): void;\n}\n\nconst numericLerp = (a: number, b: number, t: number): number => a + (b - a) * t;\n\nfunction resolveSpringConstants(o: { preset?: string; stiffness?: number; damping?: number; mass?: number }) {\n  const preset = o.preset ? SPRING_PRESETS[o.preset as keyof typeof SPRING_PRESETS] : null;\n  return {\n    stiffness: o.stiffness ?? preset?.stiffness ?? 170,\n    damping: o.damping ?? preset?.damping ?? 26,\n    mass: o.mass ?? preset?.mass ?? 1,\n  };\n}\n\n/** Create the animator for a canvas. One rAF loop drives every animation it\n *  owns, and everything still running is cancelled on unmount. */\nexport function useAnimator(opts: UseAnimatorOptions = {}): Animator {\n  const optsRef = useLatest(opts);\n  const animations = useRef<Map<number, ActiveAnimation>>(new Map());\n  const nextId = useRef(1);\n  /**\n   * Re-entrancy counter incremented around each animation tick in tickAll.\n   * Exposed via `isTicking()`. > 0 ⇒ we're currently inside an animation's\n   * onTick; an adapter wrapper (`animateOnSetPose`) seeing this flag should\n   * write through to the base adapter rather than schedule a new tween.\n   */\n  const tickDepth = useRef(0);\n  const globalTimeScale = useRef(1);\n  const globalPaused = useRef(false);\n  const colorOverrides = useRef<ColorOverrideRegistry>(new ColorOverrideRegistry());\n  // Per-frame tick subscribers. Notified after each batch of animation\n  // ticks (i.e. after `colorOverrides` has settled to its latest values\n  // but before the next RAF schedules). Used by `<SceneCanvas animator>`\n  // to request a redraw on every active frame.\n  const tickSubscribers = useRef<Set<() => void>>(new Set());\n\n  // The loop runs behind the visibility gate. `tickAll` is built inside the\n  // memo below, so the frame callback reaches it through a ref, published\n  // once the memo's render commits.\n  const tickAllRef = useRef<((t: number) => void) | null>(null);\n  const frameLoop = useVisibleRaf(\n    useCallback((t: number) => { tickAllRef.current?.(t); }, []),\n    {\n      requestFrame: opts.requestFrame,\n      cancelFrame: opts.cancelFrame,\n      // An hour spent hidden is not an hour the animation ran: dropping each\n      // animation's last timestamp makes the resuming frame's `realDt` zero.\n      onResume: () => {\n        for (const anim of animations.current.values()) anim.lastRealNow = null;\n      },\n    },\n  );\n  const frameLoopRef = useLatest(frameLoop);\n\n  // Tripwire: dev-only flag that every tween/spring/decay's tick reads to\n  // detect \"animation fired after the host component unmounted.\" This is a\n  // symptom of cleanup not running (regression) — typically because someone\n  // refactored useAnimator and forgot to wire the unmount effect. The flag\n  // flips false on cleanup; ticks see it and log a one-time error so the\n  // bug is loud rather than just visually-doubled animation.\n  const mountedRef = useRef(true);\n  const trippedRef = useRef(false);\n  const tripwire = (): boolean => {\n    if (mountedRef.current) return false;\n    if (!trippedRef.current) {\n      trippedRef.current = true;\n      const isDev = typeof process !== 'undefined' ? process.env.NODE_ENV !== 'production' : true;\n      if (isDev) {\n        console.error(\n          'weasel useAnimator: animation tick fired after the host component unmounted. ' +\n          'This usually means cleanup logic was bypassed — check for refactors that ' +\n          'removed the unmount effect or replaced cancelAll with a custom path.',\n        );\n      }\n    }\n    return true;\n  };\n\n  const { api, tickAll } = useMemo(() => {\n    // Default to performance.now() so the time origin matches the\n    // requestAnimationFrame callback's DOMHighResTimeStamp argument.\n    // Using Date.now() here would mix epoch-millis with page-relative-millis,\n    // producing huge negative `elapsed` values that clamp tween `t` to 0\n    // forever (never reaching completion).\n    const now = (): number =>\n      (optsRef.current.now ?? (typeof performance !== 'undefined' ? performance.now.bind(performance) : Date.now))();\n    // Resolved timer pair, snapshotted lazily from optsRef on each call so a\n    // test that updates the injection after mount still wins. Kept internal —\n    // not exposed on the public Animator surface; passed directly into\n    // `createStagger` at bind time below.\n    const staggerTimers: StaggerTimers = {\n      setTimer: (cb, ms) =>\n        (optsRef.current.setTimer ?? ((c, m) => setTimeout(c, m)))(cb, ms),\n      clearTimer: (h) =>\n        (optsRef.current.clearTimer ??\n          ((x) => clearTimeout(x as ReturnType<typeof setTimeout>)))(h),\n      now,\n    };\n\n    // Per-id one-shot completion listeners. Used by stagger to detect when\n    // each child has left the registry (natural completion OR cancel) so the\n    // supervising composite can retire itself when the last child finishes.\n    const completionListeners = new Map<number, (() => void)[]>();\n    const fireCompletion = (id: number): void => {\n      const ls = completionListeners.get(id);\n      if (!ls) return;\n      completionListeners.delete(id);\n      for (const cb of ls) cb();\n    };\n    const watchCompletion: WatchCompletion = (id, cb) => {\n      const ls = completionListeners.get(id) ?? [];\n      ls.push(cb);\n      completionListeners.set(id, ls);\n      return () => {\n        const cur = completionListeners.get(id);\n        if (!cur) return;\n        const idx = cur.indexOf(cb);\n        if (idx >= 0) cur.splice(idx, 1);\n        if (cur.length === 0) completionListeners.delete(id);\n      };\n    };\n\n    const hub = new AnimatorEventHub();\n    const infoOf = (a: ActiveAnimation): AnimationInfo => {\n      if (!a.info) {\n        const info: { -readonly [K in keyof AnimationInfo]: AnimationInfo[K] } = { id: a.id, kind: a.kind };\n        if (a.cancelKey != null) info.key = a.cancelKey;\n        if (a.label != null) info.label = a.label;\n        a.info = info;\n      }\n      return a.info;\n    };\n\n    /** Report `id` as finished, ahead of its `onDone`, so whatever that\n     *  handler starts is heard after it. Nothing revives a primitive; a\n     *  timeline, which can be revived, is reported as it leaves the table. */\n    const reportEnd = (id: number): void => {\n      const a = animations.current.get(id);\n      if (!a || a.ended) return;\n      a.ended = true;\n      if (hub.watched) hub.emit({ type: 'end', animation: infoOf(a) });\n    };\n\n    /** Take `id` off the table as canceled — or, given `by`, as interrupted by\n     *  the animation claiming its key. */\n    const retire = (id: number, by?: ActiveAnimation): void => {\n      const a = animations.current.get(id);\n      if (!a) return;\n      a.onCancel?.();\n      animations.current.delete(id);\n      fireCompletion(id);\n      if (!hub.watched || a.ended) return;\n      hub.emit(by\n        ? { type: 'interrupt', animation: infoOf(a), by: infoOf(by) }\n        : { type: 'cancel', animation: infoOf(a) });\n    };\n\n    const tickAll = (t: number): void => {\n      const finished: ActiveAnimation[] = [];\n      for (const anim of animations.current.values()) {\n        // `t` comes from the frame clock; `lastRealNow` is seeded at register()\n        // from `now()`. The two share a time origin in a browser, where the rAF\n        // timestamp and `performance.now()` are both page-relative — but not\n        // everywhere: jsdom starts them ~600ms apart, which made the first\n        // frame's delta hugely negative and left `virtualNow` climbing back\n        // toward zero for dozens of frames before a tween advanced at all.\n        // Time never runs backwards, so a negative sample is never real.\n        const realDt = anim.lastRealNow == null ? 0 : Math.max(0, t - anim.lastRealNow);\n        anim.lastRealNow = t;\n        const scale = globalPaused.current\n          ? 0\n          : globalTimeScale.current * (anim.paused ? 0 : anim.timeScale);\n        anim.virtualNow += realDt * scale;\n        // Increment tick depth around each animation's tick so re-entrant\n        // calls (e.g. `decay.onTick` → `adapter.setPose` →\n        // `animateOnSetPose` checking `isTicking()`) see the flag and\n        // skip scheduling a new wrap-tween that would fight the caller.\n        tickDepth.current += 1;\n        try {\n          if (anim.tick(anim.virtualNow, scale)) finished.push(anim);\n        } finally {\n          tickDepth.current -= 1;\n        }\n      }\n      for (const anim of finished) {\n        // Gone already if its own tick canceled it; replaced if something\n        // revived it under the same id since.\n        if (animations.current.get(anim.id) !== anim) continue;\n        reportEnd(anim.id);\n        animations.current.delete(anim.id);\n        fireCompletion(anim.id);\n      }\n      // Notify every onTick subscriber AFTER the tick batch so they\n      // see the latest `colorOverrides` / pose values. Errors in one\n      // subscriber don't suppress the others.\n      for (const sub of tickSubscribers.current) {\n        try { sub(); } catch (err) { console.error('useAnimator: onTick subscriber threw', err); }\n      }\n      if (animations.current.size > 0) frameLoopRef.current.request();\n    };\n\n    const ensureLoop = (): void => {\n      if (animations.current.size === 0) return;\n      frameLoopRef.current.request();\n    };\n\n    const cancelByKey = (key: string, by?: ActiveAnimation): void => {\n      const ids: number[] = [];\n      for (const anim of animations.current.values()) {\n        if (anim.cancelKey === key) ids.push(anim.id);\n      }\n      for (const id of ids) retire(id, by);\n    };\n\n    type AnimationSeed =\n      Omit<ActiveAnimation, 'paused' | 'timeScale' | 'virtualNow' | 'lastRealNow'>\n      & {\n        /** Registers under an existing `cancelKey` without cancelling whoever\n         *  holds it. For an animation re-registering itself — a revived\n         *  timeline — which is not a new claim on the key. */\n        keepExisting?: boolean;\n      };\n    const register = (seed: AnimationSeed): AnimationHandle => {\n      const anim = seed as ActiveAnimation;\n      if (seed.cancelKey != null && !seed.keepExisting) cancelByKey(seed.cancelKey, anim);\n      anim.paused = false;\n      anim.timeScale = 1;\n      anim.virtualNow = 0;\n      // Seed lastRealNow at registration so the first frame's realDt reflects\n      // the gap between register() and the first RAF callback. Preserves prior\n      // wall-clock-anchored start behavior for tween and gives spring/decay a\n      // non-zero first dt sample matching the pre-virtual-clock code.\n      anim.lastRealNow = now();\n      animations.current.set(anim.id, anim);\n      if (hub.watched) hub.emit({ type: 'start', animation: infoOf(anim) });\n      ensureLoop();\n      return {\n        id: anim.id,\n        cancel: () => retire(anim.id),\n        pause: () => { const a = animations.current.get(anim.id); if (a) a.paused = true; },\n        resume: () => { const a = animations.current.get(anim.id); if (a) a.paused = false; },\n        setTimeScale: (s) => { const a = animations.current.get(anim.id); if (a) a.timeScale = s; },\n        timeScale: () => animations.current.get(anim.id)?.timeScale ?? 1,\n        isPaused: () => animations.current.get(anim.id)?.paused ?? false,\n      };\n    };\n\n    // Supervisor: a registered animation whose tick is a no-op (never\n    // finishes naturally) so loop/stagger can sit in the animator's id table\n    // and benefit from `cancel`/`cancelKey`/`isActive`. The owning composite\n    // (loop/stagger) installs an onCancel to actually tear down its children.\n    const createSupervisor = ({ kind, cancelKey, label }: SupervisorOptions): Supervisor => {\n      const id = nextId.current++;\n      let onCancelCb: (() => void) | undefined;\n      const base = register({\n        id,\n        kind,\n        cancelKey,\n        label,\n        // tick is a no-op: the supervisor only ends when the owner calls\n        // `cancel()` (either via animator.cancel, animator.cancelKey, or the\n        // composite's natural-completion path which forwards to `cancel`).\n        tick: () => false,\n        onCancel: () => onCancelCb?.(),\n      });\n      return {\n        id: base.id,\n        cancel: base.cancel,\n        pause: base.pause,\n        resume: base.resume,\n        setTimeScale: base.setTimeScale,\n        timeScale: base.timeScale,\n        isPaused: base.isPaused,\n        setOnCancel: (cb) => { onCancelCb = cb; },\n        finish: () => {\n          if (!animations.current.has(id)) return;\n          reportEnd(id);\n          animations.current.delete(id);\n          fireCompletion(id);\n        },\n        cancelKey,\n      };\n    };\n\n    const tween = <T,>(o: TweenOptions<T>): AnimationHandle => {\n      const id = nextId.current++;\n      // start is captured in *virtual* time; since virtualNow begins at 0 on\n      // registration, that's our reference. The tween's \"elapsed\" is just\n      // virtualNow itself — naturally freezing when paused (virtualNow stops\n      // advancing) and decoupled from wall time.\n      const start = 0;\n      const easing = resolveEasing(o.easing ?? easeOut);\n      // Precedence: factory > per-tick > default numeric lerp. Factory is built\n      // once at tween start so expensive setup (color space conversion etc.)\n      // doesn't repeat per frame.\n      const factoryFn = o.interpolator ? o.interpolator(o.from, o.to) : null;\n      const perTickInterp =\n        factoryFn\n          ? null\n          : o.interpolate ??\n            ((a: T, b: T, t: number) => {\n              if (typeof a === 'number' && typeof b === 'number') {\n                return numericLerp(a as number, b as number, t) as unknown as T;\n              }\n              throw new Error('tween: interpolate or interpolator is required for non-numeric T');\n            });\n      let lastValueEmitted = false;\n      return register({\n        id,\n        kind: 'tween',\n        cancelKey: o.cancelKey,\n        label: o.label,\n        progress: (virtualNow) => (o.ms <= 0 ? 1 : Math.min(1, virtualNow / o.ms)),\n        tick(nowMs) {\n          if (tripwire()) return true;\n          const elapsed = nowMs - start;\n          const t = o.ms <= 0 ? 1 : Math.min(1, Math.max(0, elapsed / o.ms));\n          const eased = easing(t);\n          const value = factoryFn ? factoryFn(eased) : perTickInterp!(o.from, o.to, eased);\n          o.onTick(value);\n          if (t >= 1 && !lastValueEmitted) {\n            lastValueEmitted = true;\n            // That last onTick may have cancelled us — deregistering the id.\n            // A cancelled tween never completes, whenever the cancel landed.\n            if (animations.current.has(id)) {\n              reportEnd(id);\n              o.onDone?.();\n            }\n            return true;\n          }\n          return false;\n        },\n      });\n    };\n\n    const physics = <T,>(o: PhysicsOptions<T>, kind: AnimationKind = 'physics'): PhysicsHandle<T> => {\n      const id = nextId.current++;\n      const isNumeric = typeof o.from === 'number';\n      if (!isNumeric && (!o.add || !o.subtract || !o.scale || !o.magnitude)) {\n        throw new Error('physics: add/subtract/scale/magnitude are required for non-numeric T');\n      }\n      const add = o.add ?? ((a: T, b: T) => ((a as unknown as number) + (b as unknown as number)) as unknown as T);\n      const subtract = o.subtract ?? ((a: T, b: T) => ((a as unknown as number) - (b as unknown as number)) as unknown as T);\n      const scale = o.scale ?? ((v: T, k: number) => ((v as unknown as number) * k) as unknown as T);\n      const magnitude = o.magnitude ?? ((v: T) => Math.abs(v as unknown as number));\n      const { stiffness: kBase, damping, mass } = resolveSpringConstants(o);\n      const restThreshold = o.restThreshold ?? 0.01;\n\n      let target: T | null = o.to ?? null;\n      let value = o.from;\n      // Default to zero velocity: assumes scale(_, 0) returns the zero vector of T. Pass an explicit velocity for unusual T where this isn't true.\n      let velocity: T = o.velocity ?? scale(o.from, 0);\n      let lastTime: number | null = null;\n\n      const baseHandle = register({\n        id,\n        kind,\n        cancelKey: o.cancelKey,\n        label: o.label,\n        tick(nowMs) {\n          if (tripwire()) return true;\n          if (lastTime == null) {\n            lastTime = nowMs;\n            // Already-at-rest short-circuit: decay-mode (target == null)\n            // with starting velocity below threshold should complete\n            // immediately rather than emit a tick and wait a frame.\n            if (target == null && magnitude(velocity) < restThreshold) {\n              reportEnd(id);\n              o.onDone?.();\n              return true;\n            }\n            o.onTick(value);\n            return false;\n          }\n          const dt = Math.min(0.064, (nowMs - lastTime) / 1000);\n          lastTime = nowMs;\n          // Semi-implicit Euler. When target == null, stiffness == 0 ⇒\n          // no spring force; only damping acts on velocity (exponential decay).\n          const ref = target ?? value;\n          const displacement = subtract(value, ref);\n          const springForce = scale(displacement, target == null ? 0 : -kBase);\n          const dampingForce = scale(velocity, -damping);\n          const accel = scale(add(springForce, dampingForce), 1 / mass);\n          velocity = add(velocity, scale(accel, dt));\n          value = add(value, scale(velocity, dt));\n          o.onTick(value);\n          const velRested = magnitude(velocity) < restThreshold;\n          const posRested = target == null\n            ? true\n            : magnitude(subtract(value, target)) < restThreshold;\n          if (velRested && posRested) {\n            if (target != null) o.onTick(target);\n            reportEnd(id);\n            o.onDone?.();\n            return true;\n          }\n          return false;\n        },\n      });\n\n      const handle: PhysicsHandle<T> = {\n        ...baseHandle,\n        setTarget: (newTo: T | null) => { target = newTo; },\n        setVelocity: (v: T) => { velocity = v; },\n      };\n      return handle;\n    };\n\n    const spring = <T,>(o: SpringOptions<T>): AnimationHandle => physics<T>(o, 'spring');\n\n    const decay = <T,>(o: DecayOptions<T>): AnimationHandle => {\n      const friction = o.friction ?? 0.95;\n      // Per-second friction v(t) = v0 * friction^t corresponds to\n      // m*dv/dt = -c*v with c = -ln(friction), m = 1, k = 0.\n      const damping = -Math.log(friction);\n      return physics<T>({\n        from: o.from,\n        to: null,\n        velocity: o.velocity,\n        stiffness: 0,\n        damping,\n        mass: 1,\n        restThreshold: o.threshold ?? 0.5,\n        add: o.add,\n        // DecayOptions doesn't carry subtract; derive from add+scale.\n        subtract: (a, b) => o.add(a, o.scale(b, -1)),\n        scale: o.scale,\n        magnitude: o.magnitude,\n        onTick: o.onTick,\n        onDone: o.onDone,\n        cancelKey: o.cancelKey,\n        label: o.label,\n      }, 'decay');\n    };\n\n    const cancelAll = (): void => {\n      const retired: ActiveAnimation[] = [];\n      for (const a of animations.current.values()) {\n        a.onCancel?.();\n        retired.push(a);\n      }\n      animations.current.clear();\n      for (const a of retired) fireCompletion(a.id);\n      if (hub.watched) for (const a of retired) hub.emit({ type: 'cancel', animation: infoOf(a) });\n      frameLoopRef.current.cancel();\n    };\n    const api: Animator = {\n      tween,\n      spring,\n      decay,\n      physics,\n      cancel: (handle) => retire(handle.id),\n      cancelKey: (key) => cancelByKey(key),\n      cancelAll,\n      isActive: (key) => {\n        if (key == null) return animations.current.size > 0;\n        for (const a of animations.current.values()) {\n          if (a.cancelKey === key) return true;\n        }\n        return false;\n      },\n      isTicking: () => tickDepth.current > 0,\n      pause: () => { globalPaused.current = true; },\n      resume: () => { globalPaused.current = false; },\n      isPaused: () => globalPaused.current,\n      setTimeScale: (s) => { globalTimeScale.current = s; },\n      timeScale: () => globalTimeScale.current,\n      pauseKey: (key) => {\n        for (const a of animations.current.values()) if (a.cancelKey === key) a.paused = true;\n      },\n      resumeKey: (key) => {\n        for (const a of animations.current.values()) if (a.cancelKey === key) a.paused = false;\n      },\n      setTimeScaleByKey: (key, s) => {\n        for (const a of animations.current.values()) if (a.cancelKey === key) a.timeScale = s;\n      },\n      loop: (factory, loopOpts) => createLoop(createSupervisor, factory, loopOpts),\n      tweenLoop: (tweenLoopOpts) =>\n        createTweenLoop(api, createSupervisor, tweenLoopOpts),\n      stagger: ((items, delay, factory, staggerOpts) =>\n        createStagger(\n          api,\n          staggerTimers,\n          createSupervisor,\n          watchCompletion,\n          items,\n          delay,\n          factory as never,\n          staggerOpts,\n        )) as Animator['stagger'],\n      timeline: (o: TimelineOptions) => {\n        const id = nextId.current++;\n        const info = (): AnimationInfo | undefined => {\n          const a = animations.current.get(id);\n          return a && infoOf(a);\n        };\n        return createTimeline(register, id, o, {\n          get watched() { return hub.watched; },\n          fire: (track, path, event, lateBy) => {\n            const animation = info();\n            if (animation) hub.emit({ type: 'fire', animation, track, path: path.slice(), event, lateBy });\n          },\n          lap: (lap) => {\n            const animation = info();\n            if (animation) hub.emit({ type: 'lap', animation, lap });\n          },\n        });\n      },\n      colorOverrides: colorOverrides.current,\n      onTick: (cb) => {\n        tickSubscribers.current.add(cb);\n        return () => { tickSubscribers.current.delete(cb); };\n      },\n      keepAlive: () => {\n        const sup = createSupervisor({ kind: 'keepAlive' });\n        return () => sup.cancel();\n      },\n      watch: (listener) => hub.add(listener),\n      live: () => {\n        const rows: LiveAnimation[] = [];\n        for (const a of animations.current.values()) {\n          const row: LiveAnimation = {\n            ...infoOf(a),\n            paused: a.paused,\n            timeScale: a.timeScale,\n            elapsed: a.virtualNow,\n            ...(a.progress ? { progress: a.progress(a.virtualNow) } : {}),\n          };\n          rows.push(row);\n        }\n        return rows;\n      },\n    };\n    return { api, tickAll };\n  }, [frameLoopRef, optsRef]);\n\n  useInsertionEffect(() => {\n    tickAllRef.current = tickAll;\n  }, [tickAll]);\n\n  // StrictMode-safe cleanup: when the component unmounts (including the\n  // dev-mode double-mount that StrictMode performs), cancel every running\n  // animation and stop the RAF loop. Without this, the FIRST mount's\n  // animator keeps ticking with stale callbacks pointing at the unmounted\n  // adapter, while the SECOND mount creates its own animator on top —\n  // visible to the user as every animation playing twice.\n  useEffect(() => {\n    const overrides = colorOverrides.current;\n    mountedRef.current = true;\n    return () => {\n      mountedRef.current = false;\n      api.cancelAll();\n      overrides.clearAll();\n    };\n  }, [api]);\n\n  return api;\n}\n"],"mappings":"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"}

package/dist/animation/wrappers/animateLifecycle.js

@@ -0,0 +1,40 @@
+import { tweenPose as e } from "../poseHelpers.js";
+//#region src/animation/wrappers/animateLifecycle.ts
+function t(t, n, r) {
+	let i = r.ms ?? 200;
+	return {
+		...t,
+		insertNode(a, o) {
+			if (t.insertNode(a, o), !r.enterFrom) return;
+			let s = t.getPose(a.id), c = r.enterFrom(s);
+			t.setPose(a.id, c), e(n, t, {
+				id: a.id,
+				to: s,
+				ms: i,
+				easing: r.easing,
+				geometry: r.geometry,
+				recordOp: !1
+			});
+		},
+		removeNode(a) {
+			if (!r.exitTo) {
+				t.removeNode(a);
+				return;
+			}
+			let o = t.getPose(a);
+			e(n, t, {
+				id: a,
+				to: r.exitTo(o),
+				ms: i,
+				easing: r.easing,
+				geometry: r.geometry,
+				recordOp: !1,
+				onDone: () => t.removeNode(a)
+			});
+		}
+	};
+}
+//#endregion
+export { t as animateLifecycle };
+
+//# sourceMappingURL=animateLifecycle.js.map

package/dist/animation/wrappers/animateLifecycle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"animateLifecycle.js","names":["animateLifecycle","ms","opts","adapter","object","index","final","start","tweenPose","animator","id","current"],"sources":["../../../src/animation/wrappers/animateLifecycle.ts"],"sourcesContent":["import { tweenPose } from '../poseHelpers';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport type { SceneAdapter } from 'core/adapters/types';\nimport type { Animator, EasingSpec } from '../types';\n\n/** How nodes enter and leave. `enterFrom` derives the pose a new node starts\n *  at, given where it belongs; `exitTo` derives the pose a departing node\n *  animates to before it is actually removed. Omit either to leave that\n *  transition instant. */\nexport interface LifecycleAnimation<TPose> {\n  /** Pose to animate the new object FROM at insert. */\n  enterFrom?: (final: TPose) => TPose;\n  /** Pose to animate the existing object TO at remove. */\n  exitTo?: (current: TPose) => TPose;\n  ms?: number;\n  easing?: EasingSpec;\n  geometry?: PoseDescriptor<TPose>;\n}\n\n/** Wrap an adapter so inserts and removals animate — the scene-graph\n *  equivalent of CSS enter/leave transitions. */\nexport function animateLifecycle<TNode extends { id: string; pose?: TPose }, TPose>(\n  adapter: SceneAdapter<TNode, TPose>,\n  animator: Animator,\n  opts: LifecycleAnimation<TPose>,\n): SceneAdapter<TNode, TPose> {\n  const ms = opts.ms ?? 200;\n\n  return {\n    ...adapter,\n    insertNode(object: TNode, index?: number): void {\n      adapter.insertNode(object, index);\n      if (!opts.enterFrom) return;\n      const final = adapter.getPose(object.id);\n      const start = opts.enterFrom(final);\n      adapter.setPose(object.id, start);\n      tweenPose(animator, adapter as never, {\n        id: object.id,\n        to: final,\n        ms,\n        easing: opts.easing,\n        geometry: opts.geometry,\n        recordOp: false,\n      });\n    },\n    removeNode(id: string): void {\n      if (!opts.exitTo) {\n        adapter.removeNode(id);\n        return;\n      }\n      const current = adapter.getPose(id);\n      tweenPose(animator, adapter as never, {\n        id,\n        to: opts.exitTo(current),\n        ms,\n        easing: opts.easing,\n        geometry: opts.geometry,\n        recordOp: false,\n        onDone: () => adapter.removeNode(id),\n      });\n    },\n  };\n}\n"],"mappings":";;AAqBA,SAAgBA,EACd,GACA,GACA,GAC4B;CAC5B,IAAMC,IAAKC,EAAK,MAAM;CAEtB,OAAO;EACL,GAAGC;EACH,WAAW,GAAe,GAAsB;GAE9C,IADAA,EAAQ,WAAWC,GAAQC,CAAK,GAC5B,CAACH,EAAK,WAAW;GACrB,IAAMI,IAAQH,EAAQ,QAAQC,EAAO,EAAE,GACjCG,IAAQL,EAAK,UAAUI,CAAK;GAElC,AADAH,EAAQ,QAAQC,EAAO,IAAIG,CAAK,GAChCC,EAAUC,GAAUN,GAAkB;IACpC,IAAIC,EAAO;IACX,IAAIE;IACJ;IACA,QAAQJ,EAAK;IACb,UAAUA,EAAK;IACf,UAAU;GACZ,CAAC;EACH;EACA,WAAW,GAAkB;GAC3B,IAAI,CAACA,EAAK,QAAQ;IAChB,EAAQ,WAAWQ,CAAE;IACrB;GACF;GACA,IAAMC,IAAUR,EAAQ,QAAQO,CAAE;GAClC,EAAUD,GAAUN,GAAkB;IACpC;IACA,IAAID,EAAK,OAAOS,CAAO;IACvB;IACA,QAAQT,EAAK;IACb,UAAUA,EAAK;IACf,UAAU;IACV,cAAcC,EAAQ,WAAWO,CAAE;GACrC,CAAC;EACH;CACF;AACF"}

package/dist/animation/wrappers/animateOnSetPose.js

@@ -0,0 +1,44 @@
+import { springPose as e, tweenPose as t } from "../poseHelpers.js";
+//#region src/animation/wrappers/animateOnSetPose.ts
+function n(n, r, i = {}) {
+	let a = i.ms ?? 200, o = (e, t, n) => i.shouldAnimate ? !i.shouldAnimate(e, t, n) : !!(i.skipDuringGesture && i.gestureScope?.has(e));
+	return {
+		...n,
+		setPose(s, c) {
+			let l = n.getPose(s);
+			if (o(s, l, c)) {
+				n.setPose(s, c);
+				return;
+			}
+			if (r.isTicking()) {
+				n.setPose(s, c);
+				return;
+			}
+			if (r.isActive("pose:" + s)) {
+				n.setPose(s, c);
+				return;
+			}
+			i.spring ? e(r, n, {
+				id: s,
+				to: c,
+				preset: i.spring.preset,
+				stiffness: i.spring.stiffness,
+				damping: i.spring.damping,
+				mass: i.spring.mass,
+				geometry: i.geometry,
+				opLabel: i.opLabel
+			}) : t(r, n, {
+				id: s,
+				to: c,
+				ms: a,
+				easing: i.easing,
+				geometry: i.geometry,
+				opLabel: i.opLabel
+			});
+		}
+	};
+}
+//#endregion
+export { n as animateOnSetPose };
+
+//# sourceMappingURL=animateOnSetPose.js.map

package/dist/animation/wrappers/animateOnSetPose.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"animateOnSetPose.js","names":["animateOnSetPose","ms","opts","skipPredicate","id","from","to","adapter","pose","animator","springPose","tweenPose"],"sources":["../../../src/animation/wrappers/animateOnSetPose.ts"],"sourcesContent":["import { tweenPose, springPose } from '../poseHelpers';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport type { SceneAdapter } from 'core/adapters/types';\nimport type { Animator, EasingSpec, SpringPresetName } from '../types';\n\n/** Options for `animateOnSetPose`. */\nexport interface AnimateOnSetPoseOptions<TPose> {\n  /** Default: 200ms tween with easeOut. */\n  ms?: number;\n  easing?: EasingSpec;\n  /** Use a spring instead of a duration tween. Mutually exclusive with ms/easing. */\n  spring?: {\n    preset?: SpringPresetName;\n    stiffness?: number;\n    damping?: number;\n    mass?: number;\n  };\n  geometry?: PoseDescriptor<TPose>;\n  /** Predicate: return false to skip animation and write through immediately. */\n  shouldAnimate?: (id: string, from: TPose, to: TPose) => boolean;\n  /** Convenience: when true, auto-skip animation if the id is currently being\n   *  manipulated by an active gesture. Implementation: see `gestureScope` —\n   *  the wrapper consults a shared \"in-flight ids\" Set if one is provided,\n   *  otherwise this option is a no-op (treat as `shouldAnimate` returning true).\n   *  Mutually exclusive with `shouldAnimate`. */\n  skipDuringGesture?: boolean;\n  /** Optional: a Set the kit (or app) populates with ids currently being\n   *  manipulated by a gesture. When `skipDuringGesture` is true and the id\n   *  is in this Set, the wrapper writes through immediately. */\n  gestureScope?: ReadonlySet<string>;\n  /** Op label for the recorded transform op. Default: `'animate'`. */\n  opLabel?: string;\n}\n\n/**\n * Wrap an adapter so every `setPose` animates to the new pose instead of\n * jumping to it. Anything that moves a node — a layout strategy, an action, a\n * consumer's own code — is animated without knowing it, since the adapter is\n * the single write path.\n *\n * Poses written from inside another animation's tick, and (optionally) poses\n * written for a node currently under a gesture, are passed straight through:\n * animating those would fight whatever is already driving the node.\n */\nexport function animateOnSetPose<TNode extends { id: string }, TPose>(\n  adapter: SceneAdapter<TNode, TPose>,\n  animator: Animator,\n  opts: AnimateOnSetPoseOptions<TPose> = {},\n): SceneAdapter<TNode, TPose> {\n  const ms = opts.ms ?? 200;\n  const skipPredicate = (id: string, from: TPose, to: TPose): boolean => {\n    if (opts.shouldAnimate) return !opts.shouldAnimate(id, from, to);\n    if (opts.skipDuringGesture && opts.gestureScope?.has(id)) return true;\n    return false;\n  };\n\n  return {\n    ...adapter,\n    setPose(id: string, pose: TPose): void {\n      const from = adapter.getPose(id);\n      if (skipPredicate(id, from, pose)) {\n        adapter.setPose(id, pose);\n        return;\n      }\n      // Re-entrant short-circuit (a): the caller IS another animation's tick\n      // (momentum decay, in-flight tween, spring) writing setPose ~60×/sec.\n      // Wrapping each call in a fresh 250ms tween fights the caller — the\n      // new tween's t=0 sample writes back the previous `from`, undoing\n      // this onTick — and when each wrap-tween settles, the very next\n      // caller-tick spawns another, looping visibly forever (cards never\n      // stop after a flick). Detect via animator.isTicking() and write\n      // through.\n      if (animator.isTicking()) {\n        adapter.setPose(id, pose);\n        return;\n      }\n      // Re-entrant short-circuit (b): a prior wrap-tween for this id is\n      // still in flight. Let it finish rather than registering a competing\n      // tween. (Earlier guard from 3af4ed8; kept alongside (a) for the case\n      // where setPose is called from outside the animator's own tick loop\n      // but a pose:<id> tween is still mid-transition.)\n      if (animator.isActive('pose:' + id)) {\n        adapter.setPose(id, pose);\n        return;\n      }\n      if (opts.spring) {\n        springPose(animator, adapter as never, {\n          id,\n          to: pose,\n          preset: opts.spring.preset,\n          stiffness: opts.spring.stiffness,\n          damping: opts.spring.damping,\n          mass: opts.spring.mass,\n          geometry: opts.geometry,\n          opLabel: opts.opLabel,\n        });\n      } else {\n        tweenPose(animator, adapter as never, {\n          id,\n          to: pose,\n          ms,\n          easing: opts.easing,\n          geometry: opts.geometry,\n          opLabel: opts.opLabel,\n        });\n      }\n    },\n  };\n}\n"],"mappings":";;AA4CA,SAAgBA,EACd,GACA,GACA,IAAuC,CAAC,GACZ;CAC5B,IAAMC,IAAKC,EAAK,MAAM,KAChBC,KAAiB,GAAY,GAAa,MAC1CD,EAAK,gBAAsB,CAACA,EAAK,cAAcE,GAAIC,GAAMC,CAAE,IAC/D,GAAIJ,EAAK,qBAAqBA,EAAK,cAAc,IAAIE,CAAE;CAIzD,OAAO;EACL,GAAGG;EACH,QAAQ,GAAY,GAAmB;GACrC,IAAMF,IAAOE,EAAQ,QAAQH,CAAE;GAC/B,IAAID,EAAcC,GAAIC,GAAMG,CAAI,GAAG;IACjC,EAAQ,QAAQJ,GAAII,CAAI;IACxB;GACF;GASA,IAAIC,EAAS,UAAU,GAAG;IACxB,EAAQ,QAAQL,GAAII,CAAI;IACxB;GACF;GAMA,IAAIC,EAAS,SAAS,UAAUL,CAAE,GAAG;IACnC,EAAQ,QAAQA,GAAII,CAAI;IACxB;GACF;GACA,AAAIN,EAAK,SACPQ,EAAWD,GAAUF,GAAkB;IACrC;IACA,IAAIC;IACJ,QAAQN,EAAK,OAAO;IACpB,WAAWA,EAAK,OAAO;IACvB,SAASA,EAAK,OAAO;IACrB,MAAMA,EAAK,OAAO;IAClB,UAAUA,EAAK;IACf,SAASA,EAAK;GAChB,CAAC,IAEDS,EAAUF,GAAUF,GAAkB;IACpC;IACA,IAAIC;IACJ;IACA,QAAQN,EAAK;IACb,UAAUA,EAAK;IACf,SAASA,EAAK;GAChB,CAAC;EAEL;CACF;AACF"}

package/dist/{autoPoseDescriptor-_XOyF7t4.d.ts → autoPoseDescriptor-vCdt55xm.d.ts}

@@ -1,5 +1,5 @@
-import { P as Path } from './path-JEV2c5If.js';
-import { P as PoseDescriptor } from './poseDescriptor-rZa9W5hJ.js';
+import { Path } from '@weasel-js/geom';
+import { P as PoseDescriptor } from './poseDescriptor-D-OH-tu5.js';
 
 /** True for Path-shaped poses (`{kind: 'polygon' | 'rect'}`). Useful for
  *  callers that need to fork between `pathPoseDescriptor` and