@weasel-js/core 1.7.0 → 1.7.2

package/dist/animation/loop.js

@@ -0,0 +1,62 @@
+//#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 = () => {
+		if (!a) {
+			if (i >= r) {
+				o = null, a = !0, s.finish(), n.onDone?.();
+				return;
+			}
+			o = t(i++, c);
+		}
+	};
+	return c(), {
+		id: s.id,
+		cancel: () => s.cancel(),
+		pause: () => {
+			s.pause(), o?.pause();
+		},
+		resume: () => {
+			s.resume(), o?.resume();
+		},
+		setTimeScale: (e) => {
+			s.setTimeScale(e), o?.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

@@ -0,0 +1 @@
+{"version":3,"file":"loop.js","names":["createLoop","max","opts","iteration","cancelled","current","supervisor","createSupervisor","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 delegate to the current child; cancel stops the in-flight\n * 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 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  };\n\n  next();\n\n  return {\n    id: supervisor.id,\n    cancel: () => supervisor.cancel(),\n    pause: () => {\n      supervisor.pause();\n      current?.pause();\n    },\n    resume: () => {\n      supervisor.resume();\n      current?.resume();\n    },\n    setTimeScale: (s) => {\n      supervisor.setTimeScale(s);\n      current?.setTimeScale(s);\n    },\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,UAAmB;EACvB,IAAI,IACJ;OAAIL,KAAaF,GAAK;IAMpB,AALA,IAAU,MAGV,IAAY,IACZK,EAAW,OAAO,GAClBJ,EAAK,SAAS;IACd;GACF;GAEA,IAAUO,EAAQ,KAAGD,CAAI;EAFzB;CAGF;CAIA,OAFAA,EAAK,GAEE;EACL,IAAIF,EAAW;EACf,cAAcA,EAAW,OAAO;EAChC,aAAa;GAEX,AADAA,EAAW,MAAM,GACjBD,GAAS,MAAM;EACjB;EACA,cAAc;GAEZ,AADAC,EAAW,OAAO,GAClBD,GAAS,OAAO;EAClB;EACA,eAAe,MAAM;GAEnB,AADAC,EAAW,aAAaI,CAAC,GACzBL,GAAS,aAAaK,CAAC;EACzB;EACA,iBAAiBJ,EAAW,UAAU;EACtC,gBAAgBA,EAAW,SAAS;CACtC;AACF;AASA,SAAgBK,EACd,GACA,GACA,GACiB;CACjB,IAAMC,IAAYV,EAAK,aAAa;CACpC,OAAOF,GACJ,MAAMO,EAAiB;EAAE,GAAGM;EAAG,MAAM;CAAY,CAAC,IAClD,GAAG,MAAS;EACX,IAAMC,IAAUF,MAAc,aAAcA,MAAc,eAAeG,IAAI,KAAM,GAC7EC,IAAOF,IAAUZ,EAAK,KAAKA,EAAK,MAChCe,IAAKH,IAAUZ,EAAK,OAAOA,EAAK;EACtC,OAAOgB,EAAS,MAAM;GACpB;GACA;GACA,IAAIhB,EAAK;GACT,QAAQA,EAAK;GACb,aAAaA,EAAK;GAClB,QAAQA,EAAK;GACb,QAAQM;EACV,CAAC;CACH,GACA;EAAE,OAAON,EAAK;EAAO,QAAQA,EAAK;EAAQ,WAAWA,EAAK;EAAW,OAAOA,EAAK;CAAM,CACzF;AACF"}

package/dist/animation/observe.js

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

@@ -0,0 +1 @@
+{"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/poseHelpers.js

@@ -0,0 +1,50 @@
+import { createTransformOp as e } from "../core/ops/transform.js";
+import { RECT_POSE_DESCRIPTOR as t } from "../core/geometry/poseDescriptor.js";
+//#region src/animation/poseHelpers.ts
+var n = (e) => `pose:${e}`;
+function r(t, n, r, i, a) {
+	if (!t.applyOps) return;
+	let o = e({
+		id: n,
+		from: r,
+		to: i,
+		label: a
+	});
+	t.applyOps([o], a);
+}
+function i(e, i, a) {
+	let o = a.geometry ?? t;
+	if (!o.lerp) throw Error("tweenPose: geometry has no lerp; supply geometry: { ..., lerp }");
+	let s = o.lerp, c = i.getPose(a.id), l = a.recordOp ?? !0, u = a.opLabel ?? "animate";
+	return l && r(i, a.id, c, a.to, u), e.tween({
+		from: c,
+		to: a.to,
+		ms: a.ms,
+		easing: a.easing,
+		cancelKey: n(a.id),
+		interpolate: (e, t, n) => s(e, t, n),
+		onTick: (e) => i.setPose(a.id, e),
+		onDone: a.onDone
+	});
+}
+function a(e, i, a) {
+	let o = a.geometry ?? t;
+	if (!o.lerp) throw Error("springPose: geometry has no lerp; supply geometry: { ..., lerp }");
+	let s = o.lerp, c = i.getPose(a.id), l = a.recordOp ?? !0, u = a.opLabel ?? "animate";
+	return l && r(i, a.id, c, a.to, u), e.spring({
+		from: 0,
+		to: 1,
+		preset: a.preset,
+		stiffness: a.stiffness,
+		damping: a.damping,
+		mass: a.mass,
+		cancelKey: n(a.id),
+		interpolate: (e, t, n) => e + (t - e) * n,
+		onTick: (e) => i.setPose(a.id, s(c, a.to, e)),
+		onDone: a.onDone
+	});
+}
+//#endregion
+export { a as springPose, i as tweenPose };
+
+//# sourceMappingURL=poseHelpers.js.map

package/dist/animation/poseHelpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"poseHelpers.js","names":["cancelKeyFor","id","recordTransformOp","adapter","op","createTransformOp","label","tweenPose","geometry","opts","RECT_POSE_DESCRIPTOR","lerp","from","recordOp","animator","a","b","t","value","springPose","progress"],"sources":["../../src/animation/poseHelpers.ts"],"sourcesContent":["import { createTransformOp } from 'core/ops/transform';\nimport { RECT_POSE_DESCRIPTOR, type PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport type { SceneAdapter } from 'core/adapters/types';\nimport type { AnimationHandle, Animator, EasingSpec, SpringPresetName } from './types';\n\n/** Options for `tweenPose`. */\nexport interface TweenPoseOptions<TPose> {\n  id: string;\n  to: TPose;\n  ms: number;\n  easing?: EasingSpec;\n  /** Pose descriptor with a `lerp(from, to, t)` method. Defaults to\n   *  `RECT_POSE_DESCRIPTOR`, which interpolates x/y/width/height linearly. */\n  geometry?: PoseDescriptor<TPose>;\n  /** When true (default), emit a transform op before the tween so undo\n   *  restores the pre-animation pose. */\n  recordOp?: boolean;\n  /** Label for the recorded op. Default: `'animate'`. */\n  opLabel?: string;\n  onDone?: () => void;\n}\n\n/** Options for `springPose`. */\nexport interface SpringPoseOptions<TPose> {\n  id: string;\n  to: TPose;\n  preset?: SpringPresetName;\n  stiffness?: number;\n  damping?: number;\n  mass?: number;\n  geometry?: PoseDescriptor<TPose>;\n  recordOp?: boolean;\n  opLabel?: string;\n  onDone?: () => void;\n}\n\nconst cancelKeyFor = (id: string): string => `pose:${id}`;\n\nfunction recordTransformOp<TPose>(\n  adapter: SceneAdapter<{ id: string }, TPose>,\n  id: string,\n  from: TPose,\n  to: TPose,\n  label: string,\n): void {\n  if (!adapter.applyOps) return;\n  const op = createTransformOp<TPose>({ id, from, to, label });\n  adapter.applyOps([op], label);\n}\n\n/**\n * Animate one node's pose to `to` over `ms`, writing each frame through the\n * adapter.\n *\n * Unlike the color helpers this really does move the node. Undo therefore has\n * to be considered: by default a single transform op covering the whole\n * animation is recorded up front, so one undo returns the node to where it\n * started rather than replaying frames.\n */\nexport function tweenPose<TNode extends { id: string }, TPose>(\n  animator: Animator,\n  adapter: SceneAdapter<TNode, TPose>,\n  opts: TweenPoseOptions<TPose>,\n): AnimationHandle {\n  const geometry = (opts.geometry ?? (RECT_POSE_DESCRIPTOR as unknown as PoseDescriptor<TPose>));\n  if (!geometry.lerp) {\n    throw new Error('tweenPose: geometry has no lerp; supply geometry: { ..., lerp }');\n  }\n  const lerp = geometry.lerp;\n  const from = adapter.getPose(opts.id);\n  const recordOp = opts.recordOp ?? true;\n  const label = opts.opLabel ?? 'animate';\n  if (recordOp) recordTransformOp(adapter as never, opts.id, from, opts.to, label);\n  return animator.tween<TPose>({\n    from,\n    to: opts.to,\n    ms: opts.ms,\n    easing: opts.easing,\n    cancelKey: cancelKeyFor(opts.id),\n    interpolate: (a, b, t) => lerp(a, b, t),\n    onTick: (value) => adapter.setPose(opts.id, value),\n    onDone: opts.onDone,\n  });\n}\n\n/** `tweenPose` driven by a spring instead of a duration. Same op-recording\n *  behavior. */\nexport function springPose<TNode extends { id: string }, TPose>(\n  animator: Animator,\n  adapter: SceneAdapter<TNode, TPose>,\n  opts: SpringPoseOptions<TPose>,\n): AnimationHandle {\n  const geometry = (opts.geometry ?? (RECT_POSE_DESCRIPTOR as unknown as PoseDescriptor<TPose>));\n  if (!geometry.lerp) {\n    throw new Error('springPose: geometry has no lerp; supply geometry: { ..., lerp }');\n  }\n  const lerp = geometry.lerp;\n  const from = adapter.getPose(opts.id);\n  const recordOp = opts.recordOp ?? true;\n  const label = opts.opLabel ?? 'animate';\n  if (recordOp) recordTransformOp(adapter as never, opts.id, from, opts.to, label);\n  // For pose springs: integrate progress (0..1) as the spring's value, then\n  // use lerp(from, to, progress) for the actual visual write. This avoids\n  // requiring full add/subtract/scale/magnitude on TPose.\n  const progressLerp = (a: number, b: number, t: number) => a + (b - a) * t;\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(opts.id),\n    interpolate: progressLerp,\n    onTick: (progress) => adapter.setPose(opts.id, lerp(from, opts.to, progress)),\n    onDone: opts.onDone,\n  });\n}\n"],"mappings":";;;AAoCA,IAAMA,KAAgB,MAAuB,QAAQC;AAErD,SAASC,EACP,GACA,GACA,GACA,GACA,GACM;CACN,IAAI,CAACC,EAAQ,UAAU;CACvB,IAAMC,IAAKC,EAAyB;EAAE;EAAI;EAAM;EAAI;CAAM,CAAC;CAC3D,EAAQ,SAAS,CAACD,CAAE,GAAGE,CAAK;AAC9B;AAWA,SAAgBC,EACd,GACA,GACA,GACiB;CACjB,IAAMC,IAAYC,EAAK,YAAaC;CACpC,IAAI,CAACF,EAAS,MACZ,MAAU,MAAM,iEAAiE;CAEnF,IAAMG,IAAOH,EAAS,MAChBI,IAAOT,EAAQ,QAAQM,EAAK,EAAE,GAC9BI,IAAWJ,EAAK,YAAY,IAC5BH,IAAQG,EAAK,WAAW;CAE9B,OADII,KAAUX,EAAkBC,GAAkBM,EAAK,IAAIG,GAAMH,EAAK,IAAIH,CAAK,GACxEQ,EAAS,MAAa;EAC3B;EACA,IAAIL,EAAK;EACT,IAAIA,EAAK;EACT,QAAQA,EAAK;EACb,WAAWT,EAAaS,EAAK,EAAE;EAC/B,cAAc,GAAG,GAAG,MAAME,EAAKI,GAAGC,GAAGC,CAAC;EACtC,SAAS,MAAUd,EAAQ,QAAQM,EAAK,IAAIS,CAAK;EACjD,QAAQT,EAAK;CACf,CAAC;AACH;AAIA,SAAgBU,EACd,GACA,GACA,GACiB;CACjB,IAAMX,IAAYC,EAAK,YAAaC;CACpC,IAAI,CAACF,EAAS,MACZ,MAAU,MAAM,kEAAkE;CAEpF,IAAMG,IAAOH,EAAS,MAChBI,IAAOT,EAAQ,QAAQM,EAAK,EAAE,GAC9BI,IAAWJ,EAAK,YAAY,IAC5BH,IAAQG,EAAK,WAAW;CAM9B,OALII,KAAUX,EAAkBC,GAAkBM,EAAK,IAAIG,GAAMH,EAAK,IAAIH,CAAK,GAKxEQ,EAAS,OAAe;EAC7B,MAAM;EACN,IAAI;EACJ,QAAQL,EAAK;EACb,WAAWA,EAAK;EAChB,SAASA,EAAK;EACd,MAAMA,EAAK;EACX,WAAWT,EAAaS,EAAK,EAAE;EAC/B,cAToB,GAAW,GAAW,MAAcM,KAAKC,IAAID,KAAKE;EAUtE,SAAS,MAAad,EAAQ,QAAQM,EAAK,IAAIE,EAAKC,GAAMH,EAAK,IAAIW,CAAQ,CAAC;EAC5E,QAAQX,EAAK;CACf,CAAC;AACH"}

package/dist/animation/reflow.js

@@ -0,0 +1,121 @@
+import { documentPose as e, effectivePose as t } from "../core/scene/effectivePose.js";
+import { RECT_POSE_DESCRIPTOR as n } from "../core/geometry/poseDescriptor.js";
+import { useEffect as r, useMemo as i } from "react";
+import { useLatest as a } from "@weasel-js/react";
+//#region src/animation/reflow.ts
+var o = (e) => `reflow:${e}`;
+function s(e, t) {
+	if (Object.is(e, t)) return !0;
+	if (typeof e != "object" || typeof t != "object" || e === null || t === null || Array.isArray(e) !== Array.isArray(t)) return !1;
+	let n = Object.keys(e);
+	if (n.length !== Object.keys(t).length) return !1;
+	for (let r of n) if (!s(e[r], t[r])) return !1;
+	return !0;
+}
+function c(r, i, a) {
+	let c = /* @__PURE__ */ new Map(), l = !1, u = null, d = () => {
+		u ||= i.onTick(() => {
+			l && (l = !1, r.overrides.commit());
+		});
+	}, f = () => {
+		c.size > 0 || !u || (u(), u = null);
+	}, p = (e, t) => {
+		c.get(e) === t && c.delete(e);
+		let n = e;
+		r.overrides.get(n) === t.entry && r.overrides.clear(n), l = !0;
+	}, m = (e, t, c, u) => {
+		let m = t.entry.pose;
+		if (t.target = c, t.settling = u, s(m, c)) {
+			t.handle?.cancel(), t.handle = null, t.entry.pose = c, u && p(e, t), r.overrides.commit(), f();
+			return;
+		}
+		let h = a(), g = (h.geometry ?? n).lerp;
+		if (!g) throw Error("useAnimatedReflow: geometry has no lerp; supply geometry: { ..., lerp }");
+		let _ = (e) => {
+			t.entry.pose = g(m, c, e), l = !0;
+		}, v = () => {
+			t.handle = null, t.settling && (p(e, t), f());
+		}, y = o(e), b = h.label ?? "reflow";
+		d(), t.handle = h.spring ? i.spring({
+			from: 0,
+			to: 1,
+			...h.spring,
+			cancelKey: y,
+			label: b,
+			onTick: _,
+			onDone: v
+		}) : i.tween({
+			from: 0,
+			to: 1,
+			ms: h.ms ?? 200,
+			easing: h.easing,
+			cancelKey: y,
+			label: b,
+			onTick: _,
+			onDone: v
+		}), r.overrides.commit();
+	}, h = (e) => {
+		let t = c.get(e);
+		if (!t) return;
+		c.delete(e), t.handle?.cancel();
+		let n = e;
+		r.overrides.get(n) === t.entry && (r.overrides.clear(n), r.overrides.commit()), f();
+	}, g = (e, n, i, a) => {
+		if (i) a !== void 0 && (i.entry.pose = a);
+		else {
+			let o = a ?? t(r, n);
+			i = {
+				entry: { pose: o },
+				target: o,
+				settling: !1,
+				handle: null
+			}, c.set(e, i);
+		}
+		return r.overrides.get(e) !== i.entry && r.overrides.set(e, i.entry), i;
+	};
+	return {
+		glide(e, t, n) {
+			let i = r.get(e);
+			if (!i) return;
+			let a = n?.from, o = c.get(e);
+			o && a === void 0 && !o.settling && s(o.target, t) || m(e, g(e, i, o, a), t, !1);
+		},
+		settle(t, n) {
+			let i = n?.from, a = c.get(t);
+			if (!a && i === void 0) return;
+			let o = r.get(t);
+			if (!o) {
+				h(t);
+				return;
+			}
+			let l = e(r, o);
+			if (a && i === void 0) {
+				if (a.settling && s(a.target, l)) return;
+				m(t, a, l, !0);
+				return;
+			}
+			m(t, g(t, o, a, i), l, !0);
+		},
+		stop: h,
+		poseOf: (e) => c.get(e)?.entry.pose,
+		dispose() {
+			for (let e of [...c.keys()]) h(e);
+		}
+	};
+}
+function l(e, t, n = {}) {
+	return c(e, t, () => n);
+}
+function u(e, t, n) {
+	let o = a(n || {}), s = !!n, l = i(() => s ? c(e, t, () => o.current) : null, [
+		s,
+		e,
+		t,
+		o
+	]);
+	return r(() => () => l?.dispose(), [l]), l;
+}
+//#endregion
+export { l as createReflowTransition, u as useAnimatedReflow };
+
+//# sourceMappingURL=reflow.js.map

package/dist/animation/reflow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reflow.js","names":["keyFor","id","samePose","a","b","ka","k","makeReflow","glides","dirty","unsubscribe","subscribe","animator","scene","unsubscribeIfIdle","release","g","nid","run","from","to","settling","o","read","lerp","RECT_POSE_DESCRIPTOR","onTick","p","onDone","cancelKey","label","stop","claim","start","effectivePose","node","opts","pose","home","documentPose","createReflowTransition","useAnimatedReflow","latest","useLatest","enabled","reflow","useMemo","useEffect"],"sources":["../../src/animation/reflow.ts"],"sourcesContent":["import { useEffect, useMemo } from 'react';\nimport { useLatest } from '@weasel-js/react';\nimport { RECT_POSE_DESCRIPTOR, type PoseDescriptor } from '../core/geometry/poseDescriptor';\nimport { documentPose, effectivePose, type PosedNode, type PoseSource } from '../core/scene/effectivePose';\nimport type { NodeId, PoseOverride, PoseOverrides } from '../core/scene/types';\nimport type { ReflowTransition } from '../layout/types';\nimport type { AnimationHandle, Animator, EasingSpec, SpringPresetName } from './types';\n\n/** How a reflowed sibling travels: a duration and easing, or a spring. */\nexport interface ReflowTransitionOptions<TPose> {\n  /** Default 200. Ignored under `spring`. */\n  ms?: number;\n  easing?: EasingSpec;\n  /** Travel on a spring instead of a duration. A retarget restarts it from\n   *  the pose on screen, so position stays continuous and velocity does not\n   *  carry over. */\n  spring?: {\n    preset?: SpringPresetName;\n    stiffness?: number;\n    damping?: number;\n    mass?: number;\n  };\n  /** Supplies the `lerp` between two poses. Default `RECT_POSE_DESCRIPTOR`. */\n  geometry?: PoseDescriptor<TPose>;\n  /** Names each glide in `animator.watch` and `live()`. Default `'reflow'`. */\n  label?: string;\n}\n\n/** A {@link ReflowTransition} the animator drives. `dispose` drops every\n *  override it holds; the transition stays usable afterward. */\nexport interface AnimatedReflow<TPose = unknown> extends ReflowTransition<TPose> {\n  dispose(): void;\n}\n\n/** The part of a scene a reflow transition reads and overrides. */\nexport interface ReflowScene<TPose> extends PoseSource<TPose> {\n  readonly overrides: PoseOverrides<TPose>;\n}\n\ninterface Glide<TPose> {\n  entry: PoseOverride<TPose>;\n  target: TPose;\n  settling: boolean;\n  handle: AnimationHandle | null;\n}\n\n/** The animator's cancel-key for one node's glide. */\nconst keyFor = (id: string): string => `reflow:${id}`;\n\nfunction samePose(a: unknown, b: unknown): boolean {\n  if (Object.is(a, b)) return true;\n  if (typeof a !== 'object' || typeof b !== 'object' || a === null || b === null) return false;\n  if (Array.isArray(a) !== Array.isArray(b)) return false;\n  const ka = Object.keys(a);\n  if (ka.length !== Object.keys(b).length) return false;\n  for (const k of ka) {\n    if (!samePose((a as Record<string, unknown>)[k], (b as Record<string, unknown>)[k])) return false;\n  }\n  return true;\n}\n\nfunction makeReflow<TPose>(\n  scene: ReflowScene<TPose>,\n  animator: Animator,\n  read: () => ReflowTransitionOptions<TPose>,\n): AnimatedReflow<TPose> {\n  const glides = new Map<string, Glide<TPose>>();\n  let dirty = false;\n  let unsubscribe: (() => void) | null = null;\n\n  // Ticks only mark the frame dirty; one commit per animator frame publishes\n  // every glide at once.\n  const subscribe = (): void => {\n    if (unsubscribe) return;\n    unsubscribe = animator.onTick(() => {\n      if (!dirty) return;\n      dirty = false;\n      scene.overrides.commit();\n    });\n  };\n  const unsubscribeIfIdle = (): void => {\n    if (glides.size > 0 || !unsubscribe) return;\n    unsubscribe();\n    unsubscribe = null;\n  };\n\n  const release = (id: string, g: Glide<TPose>): void => {\n    if (glides.get(id) === g) glides.delete(id);\n    const nid = id as NodeId;\n    if (scene.overrides.get(nid) === g.entry) scene.overrides.clear(nid);\n    dirty = true;\n  };\n\n  const run = (id: string, g: Glide<TPose>, to: TPose, settling: boolean): void => {\n    const from = g.entry.pose as TPose;\n    g.target = to;\n    g.settling = settling;\n    if (samePose(from, to)) {\n      g.handle?.cancel();\n      g.handle = null;\n      g.entry.pose = to;\n      if (settling) release(id, g);\n      scene.overrides.commit();\n      unsubscribeIfIdle();\n      return;\n    }\n    const o = read();\n    const lerp = (o.geometry ?? (RECT_POSE_DESCRIPTOR as unknown as PoseDescriptor<TPose>)).lerp;\n    if (!lerp) throw new Error('useAnimatedReflow: geometry has no lerp; supply geometry: { ..., lerp }');\n    const onTick = (p: number): void => {\n      g.entry.pose = lerp(from, to, p);\n      dirty = true;\n    };\n    const onDone = (): void => {\n      g.handle = null;\n      if (!g.settling) return;\n      release(id, g);\n      unsubscribeIfIdle();\n    };\n    const cancelKey = keyFor(id);\n    const label = o.label ?? 'reflow';\n    subscribe();\n    // The shared key is what retargets: the new animation interrupts the old.\n    g.handle = o.spring\n      ? animator.spring<number>({ from: 0, to: 1, ...o.spring, cancelKey, label, onTick, onDone })\n      : animator.tween<number>({ from: 0, to: 1, ms: o.ms ?? 200, easing: o.easing, cancelKey, label, onTick, onDone });\n    scene.overrides.commit();\n  };\n\n  const stop = (id: string): void => {\n    const g = glides.get(id);\n    if (!g) return;\n    glides.delete(id);\n    g.handle?.cancel();\n    const nid = id as NodeId;\n    if (scene.overrides.get(nid) === g.entry) {\n      scene.overrides.clear(nid);\n      scene.overrides.commit();\n    }\n    unsubscribeIfIdle();\n  };\n\n  // The glide for `id`, created if absent, starting from `from` when given,\n  // and published over whatever override is showing the node.\n  const claim = (\n    id: string,\n    node: PosedNode<TPose>,\n    g: Glide<TPose> | undefined,\n    from: TPose | undefined,\n  ): Glide<TPose> => {\n    if (!g) {\n      const start = from ?? effectivePose(scene, node);\n      g = { entry: { pose: start }, target: start, settling: false, handle: null };\n      glides.set(id, g);\n    } else if (from !== undefined) {\n      g.entry.pose = from;\n    }\n    if (scene.overrides.get(id as NodeId) !== g.entry) scene.overrides.set(id as NodeId, g.entry);\n    return g;\n  };\n\n  return {\n    glide(id, pose, opts) {\n      const node = scene.get(id as NodeId);\n      if (!node) return;\n      const from = opts?.from;\n      const g = glides.get(id);\n      if (g && from === undefined && !g.settling && samePose(g.target, pose)) return;\n      run(id, claim(id, node, g, from), pose, false);\n    },\n    settle(id, opts) {\n      const from = opts?.from;\n      const g = glides.get(id);\n      if (!g && from === undefined) return;\n      const node = scene.get(id as NodeId);\n      if (!node) { stop(id); return; }\n      const home = documentPose(scene, node);\n      if (g && from === undefined) {\n        if (g.settling && samePose(g.target, home)) return;\n        run(id, g, home, true);\n        return;\n      }\n      run(id, claim(id, node, g, from), home, true);\n    },\n    stop,\n    poseOf: (id) => glides.get(id)?.entry.pose,\n    dispose() {\n      for (const id of [...glides.keys()]) stop(id);\n    },\n  };\n}\n\n/**\n * A reflow transition over `animator`: each glide is a tween (or spring) of\n * its own, keyed `reflow:<id>`, so a new target for a node interrupts the\n * glide it is on and `animator.cancelKey` reaches one node's. See\n * {@link useAnimatedReflow} for the hook form.\n */\nexport function createReflowTransition<TPose>(\n  scene: ReflowScene<TPose>,\n  animator: Animator,\n  opts: ReflowTransitionOptions<TPose> = {},\n): AnimatedReflow<TPose> {\n  return makeReflow(scene, animator, () => opts);\n}\n\n/**\n * Opt a canvas's layout reflow into animation: pass the result to\n * `<SceneCanvas reflowTransition>` and siblings a drag displaces glide to\n * their slots instead of snapping. `null` (or `false`) turns it off, and\n * whatever it was holding snaps home. Option changes apply from the next\n * glide on, without rebuilding.\n */\nexport function useAnimatedReflow<TPose>(\n  scene: ReflowScene<TPose>,\n  animator: Animator,\n  opts: ReflowTransitionOptions<TPose> | null | false | undefined,\n): AnimatedReflow<TPose> | null {\n  const latest = useLatest(opts || {});\n  const enabled = !!opts;\n  const reflow = useMemo(\n    () => (enabled ? makeReflow(scene, animator, () => latest.current) : null),\n    [enabled, scene, animator, latest],\n  );\n  useEffect(() => () => reflow?.dispose(), [reflow]);\n  return reflow;\n}\n"],"mappings":"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"}

package/dist/animation/rig/bindRig.js

@@ -0,0 +1,74 @@
+import { mat3 as e } from "../../renderer/math/mat3.js";
+import { AUTO_POSE_DESCRIPTOR as t } from "../../interactions/actions/resize/autoPoseDescriptor.js";
+import { resolveSkeleton as n } from "./resolveSkeleton.js";
+//#region src/animation/rig/bindRig.ts
+function r(t) {
+	return (n, { rest: r, fromRest: i }) => {
+		let a = t.getBounds(r), o = a.x + a.width / 2, s = a.y + a.height / 2, [c, l] = e.apply(i, o, s), u = t.translate ? t.translate(r, c - o, l - s) : t.remapBounds(r, a, {
+			...a,
+			x: a.x + c - o,
+			y: a.y + l - s
+		});
+		if (!t.withRotation) return u;
+		let d = t.getRotation?.(r) ?? 0, f = Math.cos(d), p = Math.sin(d);
+		return t.withRotation(u, Math.atan2(i[1] * f + i[4] * p, i[0] * f + i[3] * p));
+	};
+}
+function i(i) {
+	let { scene: a, skeleton: o } = i, s = i.apply ?? r(i.descriptor ?? t), c = n(o, {}), l = [];
+	for (let [t, n] of Object.entries(i.bindings)) {
+		let r = c.get(t);
+		if (!r) throw Error(`bindRig: the skeleton has no joint "${t}".`);
+		let i = e.invert(r);
+		if (!i) throw Error(`bindRig: joint "${t}" is singular at the bind pose.`);
+		for (let e of typeof n == "string" ? [n] : n) {
+			let n = a.get(e);
+			if (!n) throw Error(`bindRig: joint "${t}" is bound to node "${e}", which the scene lacks.`);
+			l.push({
+				node: e,
+				joint: t,
+				rest: n.pose,
+				restWorld: r,
+				restInverse: i,
+				entry: { pose: n.pose }
+			});
+		}
+	}
+	let u = c, d = !1, f = () => {
+		if (d) {
+			d = !1;
+			for (let e of l) a.overrides.clear(e.node);
+		}
+	};
+	return {
+		skeleton: o,
+		pose(t, r) {
+			let i = n(o, t);
+			if (r) for (let [t, n] of i) i.set(t, e.multiply(r, n));
+			u = i;
+			let c = /* @__PURE__ */ new Map();
+			for (let t of l) {
+				let n = i.get(t.joint), r = c.get(t.joint);
+				r || (r = e.multiply(n, t.restInverse), c.set(t.joint, r)), t.entry.pose = s(n, {
+					joint: t.joint,
+					node: t.node,
+					rest: t.rest,
+					restWorld: t.restWorld,
+					fromRest: r
+				}), d || a.overrides.set(t.node, t.entry);
+			}
+			d = !0, a.overrides.commit();
+		},
+		world: () => u,
+		bake(e = "Bake rig pose") {
+			d && (a.batch(e, () => {
+				for (let e of l) e.entry.pose !== void 0 && a.setPose(e.node, e.entry.pose);
+			}), f());
+		},
+		release: f
+	};
+}
+//#endregion
+export { i as bindRig, r as rigidRigApply };
+
+//# sourceMappingURL=bindRig.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bindRig.js","names":["rigidRigApply","b","descriptor","rest","cx","cy","nx","ny","mat3","fromRest","moved","r0","ux","uy","bindRig","options","apply","AUTO_POSE_DESCRIPTOR","restWorlds","resolveSkeleton","skeleton","bound","joint","ids","restWorld","restInverse","node","scene","world","installed","release","local","pose","root","name","m","w","delta","label"],"sources":["../../../src/animation/rig/bindRig.ts"],"sourcesContent":["import type { PoseDescriptor } from '../../core/geometry/poseDescriptor';\nimport type { NodeId, PoseOverride, PoseOverrides } from '../../core/scene/types';\nimport { AUTO_POSE_DESCRIPTOR } from '../../interactions/actions/resize/autoPoseDescriptor';\nimport { mat3, type GlMat3 } from '../../renderer/math/mat3';\nimport { resolveSkeleton } from './resolveSkeleton';\nimport type { Pose, Skeleton } from './types';\n\n/** The part of a scene a rig writes to. */\nexport interface RigScene<TPose> {\n  get(id: NodeId): { pose: TPose } | undefined;\n  readonly overrides: PoseOverrides<TPose>;\n  setPose(id: NodeId, pose: TPose): void;\n  batch<T>(label: string, fn: () => T): T;\n}\n\n/** What a `RigApply` knows about the node it is posing. */\nexport interface RigApplyContext<TPose> {\n  /** The joint the node rides. */\n  joint: string;\n  node: NodeId;\n  /** The node's document pose when the rig was bound — where it sits at the\n   *  bind pose. */\n  rest: TPose;\n  /** The joint's world transform at the bind pose. */\n  restWorld: GlMat3;\n  /** `world * inverse(restWorld)`: the motion since the bind pose, in world\n   *  space. Carrying `rest` by it is what welding the node to the joint means. */\n  fromRest: GlMat3;\n}\n\n/** Turns a joint's world transform into a pose for one bound node. The only\n *  part of a rig that knows the scene's pose shape. */\nexport type RigApply<TPose> = (world: GlMat3, ctx: RigApplyContext<TPose>) => TPose;\n\n/** Options for `bindRig`. */\nexport interface BindRigOptions<TPose> {\n  scene: RigScene<TPose>;\n  skeleton: Skeleton;\n  /** Joint name → the node or nodes that ride it. Each node keeps the offset\n   *  from its joint that it has at the bind pose. */\n  bindings: Readonly<Record<string, NodeId | readonly NodeId[]>>;\n  /** Default: {@link rigidRigApply} over `descriptor`. */\n  apply?: RigApply<TPose>;\n  /** The descriptor the default `apply` reads and writes poses through.\n   *  Default `AUTO_POSE_DESCRIPTOR`. */\n  descriptor?: PoseDescriptor<TPose>;\n}\n\n/** A skeleton bound to scene nodes, as `bindRig` returns it. */\nexport interface Rig {\n  readonly skeleton: Skeleton;\n  /**\n   * Resolve `pose` and move every bound node to it, through the scene's pose\n   * overrides — no history entry, no document write, no version bump — then\n   * commit them. The per-frame write. `root` places the rig in the world, and\n   * may mirror it.\n   */\n  pose(pose: Pose, root?: GlMat3): void;\n  /** The joint world transforms the last `pose` resolved, root applied. */\n  world(): ReadonlyMap<string, GlMat3>;\n  /** Write the current frame into the bound nodes' document poses as one\n   *  undo entry, and drop the overrides. Later frames stay relative to the\n   *  bind-time rest, so baking does not compound. */\n  bake(label?: string): void;\n  /** Drop the overrides; the nodes show their document poses again until the\n   *  next `pose`. */\n  release(): void;\n}\n\n/**\n * Carries a node rigidly with its joint: the rest pose's center moves by\n * `fromRest`, and its rotation turns with the rest pose's x-axis. Scale in the\n * joint chain moves positions but not sizes — the pose model holds no shear,\n * and a sized pose under anisotropic scale would need one. Write an `apply`\n * that reads `world` to size nodes from joint scale.\n */\nexport function rigidRigApply<TPose>(descriptor: PoseDescriptor<TPose>): RigApply<TPose> {\n  return (_world, { rest, fromRest }) => {\n    const b = descriptor.getBounds(rest);\n    const cx = b.x + b.width / 2;\n    const cy = b.y + b.height / 2;\n    const [nx, ny] = mat3.apply(fromRest, cx, cy);\n    const moved = descriptor.translate\n      ? descriptor.translate(rest, nx - cx, ny - cy)\n      : descriptor.remapBounds(rest, b, { ...b, x: b.x + nx - cx, y: b.y + ny - cy });\n    if (!descriptor.withRotation) return moved;\n    const r0 = descriptor.getRotation?.(rest) ?? 0;\n    const ux = Math.cos(r0);\n    const uy = Math.sin(r0);\n    return descriptor.withRotation(\n      moved,\n      Math.atan2(fromRest[1] * ux + fromRest[4] * uy, fromRest[0] * ux + fromRest[3] * uy),\n    );\n  };\n}\n\ninterface Bound<TPose> {\n  node: NodeId;\n  joint: string;\n  rest: TPose;\n  restWorld: GlMat3;\n  restInverse: GlMat3;\n  entry: PoseOverride<TPose>;\n}\n\n/**\n * Bind a skeleton's joints to scene nodes. Nodes are written in world space\n * and the rig resolves its own hierarchy, so bound nodes are best left\n * unparented, or under containers whose pose does not compose into theirs;\n * the scene's tree stays free to order and group them for drawing.\n */\nexport function bindRig<TPose>(options: BindRigOptions<TPose>): Rig {\n  const { scene, skeleton } = options;\n  const apply = options.apply ?? rigidRigApply(options.descriptor ?? (AUTO_POSE_DESCRIPTOR as PoseDescriptor<TPose>));\n  const restWorlds = resolveSkeleton(skeleton, {});\n\n  const bound: Bound<TPose>[] = [];\n  for (const [joint, ids] of Object.entries(options.bindings)) {\n    const restWorld = restWorlds.get(joint);\n    if (!restWorld) throw new Error(`bindRig: the skeleton has no joint \"${joint}\".`);\n    const restInverse = mat3.invert(restWorld);\n    if (!restInverse) throw new Error(`bindRig: joint \"${joint}\" is singular at the bind pose.`);\n    for (const node of typeof ids === 'string' ? [ids] : (ids as readonly NodeId[])) {\n      const n = scene.get(node);\n      if (!n) throw new Error(`bindRig: joint \"${joint}\" is bound to node \"${node}\", which the scene lacks.`);\n      bound.push({ node, joint, rest: n.pose, restWorld, restInverse, entry: { pose: n.pose } });\n    }\n  }\n\n  let world: ReadonlyMap<string, GlMat3> = restWorlds;\n  let installed = false;\n\n  const release = () => {\n    if (!installed) return;\n    installed = false;\n    for (const b of bound) scene.overrides.clear(b.node);\n  };\n\n  return {\n    skeleton,\n    pose(pose, root) {\n      const local = resolveSkeleton(skeleton, pose);\n      if (root) for (const [name, m] of local) local.set(name, mat3.multiply(root, m));\n      world = local;\n      const fromRest = new Map<string, GlMat3>();\n      for (const b of bound) {\n        const w = local.get(b.joint)!;\n        let delta = fromRest.get(b.joint);\n        if (!delta) {\n          delta = mat3.multiply(w, b.restInverse);\n          fromRest.set(b.joint, delta);\n        }\n        b.entry.pose = apply(w, { joint: b.joint, node: b.node, rest: b.rest, restWorld: b.restWorld, fromRest: delta });\n        if (!installed) scene.overrides.set(b.node, b.entry);\n      }\n      installed = true;\n      scene.overrides.commit();\n    },\n    world: () => world,\n    bake(label = 'Bake rig pose') {\n      if (!installed) return;\n      scene.batch(label, () => {\n        for (const b of bound) if (b.entry.pose !== undefined) scene.setPose(b.node, b.entry.pose);\n      });\n      release();\n    },\n    release,\n  };\n}\n"],"mappings":"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"}

package/dist/animation/rig/blendPoses.js

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

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

package/dist/animation/rig/mirrorPose.js

@@ -0,0 +1,19 @@
+//#region src/animation/rig/mirrorPose.ts
+function e(e, t) {
+	let n = {}, r = /* @__PURE__ */ new Map();
+	for (let t of e.joints) r.set(t.name, t.bind);
+	let i = /* @__PURE__ */ new Set([...r.keys(), ...Object.keys(t)]);
+	for (let e of i) {
+		let i = r.get(e), a = t[e];
+		n[e] = {
+			...a,
+			x: -2 * (i?.x ?? 0) - (a?.x ?? 0),
+			rotation: -2 * (i?.rotation ?? 0) - (a?.rotation ?? 0)
+		};
+	}
+	return n;
+}
+//#endregion
+export { e as mirrorPose };
+
+//# sourceMappingURL=mirrorPose.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mirrorPose.js","names":["mirrorPose","out","binds","joint","skeleton","names","pose","name","bind","d"],"sources":["../../../src/animation/rig/mirrorPose.ts"],"sourcesContent":["import type { JointTransform, Pose, Skeleton } from './types';\n\n/**\n * `pose` reflected across the rig's y axis, as deltas against the same\n * skeleton — so the mirrored pose still blends, samples and resolves like any\n * other.\n *\n * Reflecting a joint chain is conjugation: every local transform `T·R·S`\n * becomes `F·T·R·S·F` with `F` the flip, which is again a plain transform\n * with `x` and `rotation` negated. Every resolved joint is then exactly the\n * original's reflection, which is how a rig faces the other way without a\n * negative scale anywhere — a scene pose such as `RectPose` has no term to\n * carry one. The negation applies to bind plus delta, so the delta for a\n * joint the pose leaves at its bind is nonzero whenever the bind is.\n *\n * Applying it twice gives the original pose back.\n */\nexport function mirrorPose(skeleton: Skeleton, pose: Pose): Pose {\n  const out: Pose = {};\n  const binds = new Map<string, JointTransform>();\n  for (const joint of skeleton.joints) binds.set(joint.name, joint.bind);\n  const names = new Set([...binds.keys(), ...Object.keys(pose)]);\n  for (const name of names) {\n    const bind = binds.get(name);\n    const d = pose[name];\n    out[name] = {\n      ...d,\n      x: -2 * (bind?.x ?? 0) - (d?.x ?? 0),\n      rotation: -2 * (bind?.rotation ?? 0) - (d?.rotation ?? 0),\n    };\n  }\n  return out;\n}\n"],"mappings":";AAiBA,SAAgBA,EAAW,GAAoB,GAAkB;CAC/D,IAAMC,IAAY,CAAC,GACbC,oBAAQ,IAAI,IAA4B;CAC9C,KAAK,IAAMC,KAASC,EAAS,QAAQ,EAAM,IAAID,EAAM,MAAMA,EAAM,IAAI;CACrE,IAAME,oBAAQ,IAAI,IAAI,CAAC,GAAGH,EAAM,KAAK,GAAG,GAAG,OAAO,KAAKI,CAAI,CAAC,CAAC;CAC7D,KAAK,IAAMC,KAAQF,GAAO;EACxB,IAAMG,IAAON,EAAM,IAAIK,CAAI,GACrBE,IAAIH,EAAKC;EACf,EAAIA,KAAQ;GACV,GAAGE;GACH,GAAG,MAAMD,GAAM,KAAK,MAAMC,GAAG,KAAK;GAClC,UAAU,MAAMD,GAAM,YAAY,MAAMC,GAAG,YAAY;EACzD;CACF;CACA,OAAOR;AACT"}

package/dist/animation/rig/resolveSkeleton.js

@@ -0,0 +1,33 @@
+import { mat3 as e } from "../../renderer/math/mat3.js";
+//#region src/animation/rig/resolveSkeleton.ts
+function t(e, t) {
+	return t ? {
+		x: e.x + (t.x ?? 0),
+		y: e.y + (t.y ?? 0),
+		rotation: e.rotation + (t.rotation ?? 0),
+		scaleX: e.scaleX * (t.scaleX ?? 1),
+		scaleY: e.scaleY * (t.scaleY ?? 1)
+	} : e;
+}
+function n(e) {
+	let t = Math.cos(e.rotation), n = Math.sin(e.rotation), r = /* @__PURE__ */ new Float32Array(9);
+	return r[0] = t * e.scaleX, r[1] = n * e.scaleX, r[2] = 0, r[3] = -n * e.scaleY, r[4] = t * e.scaleY, r[5] = 0, r[6] = e.x, r[7] = e.y, r[8] = 1, r;
+}
+function r(r, i) {
+	let a = /* @__PURE__ */ new Map();
+	for (let o of r.joints) {
+		let r = n(t(o.bind, i[o.name]));
+		if (o.parent == null) {
+			a.set(o.name, r);
+			continue;
+		}
+		let s = a.get(o.parent);
+		if (!s) throw Error(`resolveSkeleton: joint "${o.name}" names parent "${o.parent}", which has not been resolved. Skeleton.joints must be in topological order.`);
+		a.set(o.name, e.multiply(s, r));
+	}
+	return a;
+}
+//#endregion
+export { t as compose, r as resolveSkeleton, n as toMat3 };
+
+//# sourceMappingURL=resolveSkeleton.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resolveSkeleton.js","names":["compose","delta","bind","toMat3","c","t","s","m","resolveSkeleton","out","joint","skeleton","local","pose","parent","mat3"],"sources":["../../../src/animation/rig/resolveSkeleton.ts"],"sourcesContent":["import { mat3, type GlMat3 } from '../../renderer/math/mat3';\nimport type { JointTransform, Pose, Skeleton } from './types';\n\n/** bind + delta, field by field. Scale is multiplicative, the rest additive. */\nexport function compose(bind: JointTransform, delta: Partial<JointTransform> | undefined): JointTransform {\n  if (!delta) return bind;\n  return {\n    x: bind.x + (delta.x ?? 0),\n    y: bind.y + (delta.y ?? 0),\n    rotation: bind.rotation + (delta.rotation ?? 0),\n    scaleX: bind.scaleX * (delta.scaleX ?? 1),\n    scaleY: bind.scaleY * (delta.scaleY ?? 1),\n  };\n}\n\n/** TRS as a GlMat3: translate * rotate * scale, applied to a column vector. */\nexport function toMat3(t: JointTransform): GlMat3 {\n  const c = Math.cos(t.rotation);\n  const s = Math.sin(t.rotation);\n  const m = new Float32Array(9) as GlMat3;\n  m[0] = c * t.scaleX;  m[1] = s * t.scaleX;  m[2] = 0;\n  m[3] = -s * t.scaleY; m[4] = c * t.scaleY;  m[5] = 0;\n  m[6] = t.x;           m[7] = t.y;           m[8] = 1;\n  return m;\n}\n\n/**\n * Resolve every joint's world transform by walking the skeleton once and\n * composing each joint onto its already-resolved parent.\n *\n * `skeleton.joints` must be in topological order — a joint whose parent has not\n * been resolved yet throws rather than silently resolving against identity,\n * because that failure is otherwise invisible until a limb renders in the wrong\n * place.\n */\nexport function resolveSkeleton(skeleton: Skeleton, pose: Pose): Map<string, GlMat3> {\n  const out = new Map<string, GlMat3>();\n  for (const joint of skeleton.joints) {\n    const local = toMat3(compose(joint.bind, pose[joint.name]));\n    if (joint.parent == null) {\n      out.set(joint.name, local);\n      continue;\n    }\n    const parent = out.get(joint.parent);\n    if (!parent) {\n      throw new Error(\n        `resolveSkeleton: joint \"${joint.name}\" names parent \"${joint.parent}\", which has not ` +\n        'been resolved. Skeleton.joints must be in topological order.',\n      );\n    }\n    out.set(joint.name, mat3.multiply(parent, local));\n  }\n  return out;\n}\n"],"mappings":";;AAIA,SAAgBA,EAAQ,GAAsB,GAA4D;CAExG,OADKC,IACE;EACL,GAAGC,EAAK,KAAKD,EAAM,KAAK;EACxB,GAAGC,EAAK,KAAKD,EAAM,KAAK;EACxB,UAAUC,EAAK,YAAYD,EAAM,YAAY;EAC7C,QAAQC,EAAK,UAAUD,EAAM,UAAU;EACvC,QAAQC,EAAK,UAAUD,EAAM,UAAU;CACzC,IAPmBC;AAQrB;AAGA,SAAgBC,EAAO,GAA2B;CAChD,IAAMC,IAAI,KAAK,IAAIC,EAAE,QAAQ,GACvBC,IAAI,KAAK,IAAID,EAAE,QAAQ,GACvBE,oBAAI,IAAI,aAAa,CAAC;CAI5B,OAHA,EAAE,KAAKH,IAAIC,EAAE,QAAS,EAAE,KAAKC,IAAID,EAAE,QAAS,EAAE,KAAK,GACnD,EAAE,KAAK,CAACC,IAAID,EAAE,QAAQ,EAAE,KAAKD,IAAIC,EAAE,QAAS,EAAE,KAAK,GACnD,EAAE,KAAKA,EAAE,GAAa,EAAE,KAAKA,EAAE,GAAa,EAAE,KAAK,GAC5CE;AACT;AAWA,SAAgBC,EAAgB,GAAoB,GAAiC;CACnF,IAAMC,oBAAM,IAAI,IAAoB;CACpC,KAAK,IAAMC,KAASC,EAAS,QAAQ;EACnC,IAAMC,IAAQT,EAAOH,EAAQU,EAAM,MAAMG,EAAKH,EAAM,KAAK,CAAC;EAC1D,IAAIA,EAAM,UAAU,MAAM;GACxB,EAAI,IAAIA,EAAM,MAAME,CAAK;GACzB;EACF;EACA,IAAME,IAASL,EAAI,IAAIC,EAAM,MAAM;EACnC,IAAI,CAACI,GACH,MAAU,MACR,2BAA2BJ,EAAM,KAAK,kBAAkBA,EAAM,OAAO,8EAEvE;EAEF,EAAI,IAAIA,EAAM,MAAMK,EAAK,SAASD,GAAQF,CAAK,CAAC;CAClD;CACA,OAAOH;AACT"}

package/dist/animation/rig/solveIk.js

@@ -0,0 +1,103 @@
+import { mat3 as e } from "../../renderer/math/mat3.js";
+import { compose as t, resolveSkeleton as n, toMat3 as r } from "./resolveSkeleton.js";
+//#region src/animation/rig/solveIk.ts
+var i = Math.PI * 2;
+function a(e) {
+	return e - i * Math.round(e / i);
+}
+function o(e, t) {
+	if (!t) return e;
+	for (let n of [
+		e,
+		e - i,
+		e + i
+	]) if (n >= t.min && n <= t.max) return n;
+	return Math.abs(a(e - t.min)) <= Math.abs(a(e - t.max)) ? t.min : t.max;
+}
+var s = (e, t, n, r) => e * r - t * n;
+function c(i, c, l) {
+	let { tip: u, target: d, limits: f } = l, p = l.iterations ?? 32, m = l.tolerance ?? .01, h = /* @__PURE__ */ new Map();
+	for (let e of i.joints) h.set(e.name, e);
+	let g = l.joints.map((e, t) => {
+		let n = h.get(e);
+		if (!n) throw Error(`solveIk: the skeleton has no joint "${e}".`);
+		if (t > 0 && n.parent !== l.joints[t - 1]) throw Error(`solveIk: chain joint "${e}" names parent "${n.parent}", not "${l.joints[t - 1]}". Each chain joint must be the parent of the next.`);
+		return n;
+	}), _ = g.length;
+	if (_ === 0) return {
+		pose: { ...c },
+		distance: Infinity,
+		reached: !1,
+		iterations: 0
+	};
+	let v = g[0].parent, y = v == null ? e.identity() : n(i, c).get(v), b = g.map((e) => o(a(c[e.name]?.rotation ?? 0), f?.[e.name])), x = [], S = () => {
+		x = [];
+		let n = y;
+		for (let i = 0; i < _; i += 1) {
+			let a = g[i];
+			n = e.multiply(n, r(t(a.bind, {
+				...c[a.name],
+				rotation: b[i]
+			}))), x.push(n);
+		}
+	}, C = (t) => e.apply(x[t], 0, 0), w = () => e.apply(x[_ - 1], u.x, u.y), T = (e) => e + 1 < _ ? C(e + 1) : w(), E = (t, n, r) => {
+		let i = e.invert(t === 0 ? y : x[t - 1]);
+		if (!i) return !1;
+		let [s, c] = e.apply(i, ...C(t)), [l, u] = e.apply(i, ...n), [d, p] = e.apply(i, r.x, r.y);
+		if (Math.hypot(l - s, u - c) < 1e-9 || Math.hypot(d - s, p - c) < 1e-9) return !1;
+		let m = a(b[t] + Math.atan2(p - c, d - s) - Math.atan2(u - c, l - s));
+		return b[t] = o(m, f?.[g[t].name]), S(), Math.abs(a(b[t] - m)) > 1e-9;
+	}, D = () => {
+		let [e, t] = w();
+		return Math.hypot(e - d.x, t - d.y);
+	}, O = (e) => {
+		let t = { ...c };
+		g.forEach((e, n) => {
+			t[e.name] = {
+				...c[e.name],
+				rotation: b[n]
+			};
+		});
+		let n = D();
+		return {
+			pose: t,
+			distance: n,
+			reached: n <= m,
+			iterations: e
+		};
+	};
+	S();
+	let [k, A] = C(0), j = 0;
+	for (let e = 0; e < _; e += 1) {
+		let [t, n] = C(e), [r, i] = T(e);
+		j += Math.hypot(r - t, i - n);
+	}
+	let M = Math.hypot(d.x - k, d.y - A);
+	if (M >= j) {
+		for (let e = 0; e < _; e += 1) E(e, T(e), d);
+		return O(0);
+	}
+	if (_ === 2 && M > 1e-9) {
+		let e = b.slice(), [t, n] = C(1), [r, i] = w(), a = Math.hypot(t - k, n - A), o = Math.hypot(r - t, i - n), c = d.x - k, u = d.y - A, f = (l.pole ? s(c, u, l.pole.x - k, l.pole.y - A) : s(c, u, t - k, n - A)) < 0 ? -1 : 1, p = Math.acos(Math.max(-1, Math.min(1, (a * a + M * M - o * o) / (2 * a * M)))), h = Math.atan2(u, c), g = (t) => {
+			b.splice(0, 2, ...e), S();
+			let n = {
+				x: k + a * Math.cos(h + t * p),
+				y: A + a * Math.sin(h + t * p)
+			}, r = E(0, C(1), n);
+			return E(1, w(), d) || r;
+		};
+		if (!g(f) || !g(-f)) {
+			if (D() <= m) return O(0);
+		} else g(f);
+	}
+	let N = 0;
+	for (; N < p && D() > m;) {
+		for (let e = _ - 1; e >= 0; --e) E(e, w(), d);
+		N += 1;
+	}
+	return O(N);
+}
+//#endregion
+export { c as solveIk };
+
+//# sourceMappingURL=solveIk.js.map