@weasel-js/core 1.6.1 → 1.7.1

package/dist/animation/index.js

@@ -0,0 +1,20 @@
+import { springPose as e, tweenPose as t } from "./poseHelpers.js";
+import { sampleTrack as n } from "./timeline/sampleTrack.js";
+import { ColorOverrideRegistry as r } from "./colorRegistry.js";
+import { useAnimator as i } from "./useAnimator.js";
+import { animateOnSetPose as a } from "./wrappers/animateOnSetPose.js";
+import { animateLifecycle as o } from "./wrappers/animateLifecycle.js";
+import { createReflowTransition as s, useAnimatedReflow as c } from "./reflow.js";
+import { momentum as l } from "./behaviors/momentum.js";
+import { createSlew as u, slewToward as d } from "./slew.js";
+import { cycleVertexColors as f, rainbowVertexColors as p, solidVertexColors as m, springVertexColors as h, staggerVertexColors as g, tweenVertexColors as _ } from "./colorHelpers.js";
+import { IDENTITY_JOINT as v } from "./rig/types.js";
+import { blendPoses as y } from "./rig/blendPoses.js";
+import { mirrorPose as b } from "./rig/mirrorPose.js";
+import { resolveSkeleton as x } from "./rig/resolveSkeleton.js";
+import { bindRig as S, rigidRigApply as C } from "./rig/bindRig.js";
+import { solveIk as w } from "./rig/solveIk.js";
+import { useRig as T } from "./rig/useRig.js";
+import { hexToOklchDeg as E, hslToSrgb as D, interpolateSrgb as O, lerpColorArray as k, lerpOklab as A, lerpOklch as j, linearSrgbToOklab as M, linearToSrgb as N, oklabToLinearSrgb as P, oklabToOklch as F, oklabToSrgbU8 as I, oklchDegToHex as L, oklchToOklab as R, srgbFloatToOklab as z, srgbToHsl as B, srgbToLinear as V, srgbU8ToOklab as H } from "@weasel-js/paint";
+import { EASINGS as U, SPRING_PRESETS as W, cubicBezierEasing as G, easeIn as K, easeInBack as q, easeInBounce as J, easeInCirc as Y, easeInCubic as X, easeInElastic as Z, easeInExpo as Q, easeInOut as $, easeInOutBack as ee, easeInOutBounce as te, easeInOutCirc as ne, easeInOutCubic as re, easeInOutElastic as ie, easeInOutExpo as ae, easeInOutQuad as oe, easeInOutQuart as se, easeInOutQuint as ce, easeInOutSine as le, easeInQuad as ue, easeInQuart as de, easeInQuint as fe, easeInSine as pe, easeOut as me, easeOutBack as he, easeOutBounce as ge, easeOutCirc as _e, easeOutCubic as ve, easeOutElastic as ye, easeOutExpo as be, easeOutQuad as xe, easeOutQuart as Se, easeOutQuint as Ce, easeOutSine as we, linear as Te, resolveEasing as Ee } from "@weasel-js/geom";
+export { r as ColorOverrideRegistry, U as EASINGS, v as IDENTITY_JOINT, W as SPRING_PRESETS, o as animateLifecycle, a as animateOnSetPose, S as bindRig, y as blendPoses, s as createReflowTransition, u as createSlew, G as cubicBezierEasing, f as cycleVertexColors, K as easeIn, q as easeInBack, J as easeInBounce, Y as easeInCirc, X as easeInCubic, Z as easeInElastic, Q as easeInExpo, $ as easeInOut, ee as easeInOutBack, te as easeInOutBounce, ne as easeInOutCirc, re as easeInOutCubic, ie as easeInOutElastic, ae as easeInOutExpo, oe as easeInOutQuad, se as easeInOutQuart, ce as easeInOutQuint, le as easeInOutSine, ue as easeInQuad, de as easeInQuart, fe as easeInQuint, pe as easeInSine, me as easeOut, he as easeOutBack, ge as easeOutBounce, _e as easeOutCirc, ve as easeOutCubic, ye as easeOutElastic, be as easeOutExpo, xe as easeOutQuad, Se as easeOutQuart, Ce as easeOutQuint, we as easeOutSine, E as hexToOklchDeg, D as hslToSrgb, O as interpolateSrgb, k as lerpColorArray, A as lerpOklab, j as lerpOklch, Te as linear, M as linearSrgbToOklab, N as linearToSrgb, b as mirrorPose, l as momentum, P as oklabToLinearSrgb, F as oklabToOklch, I as oklabToSrgbU8, L as oklchDegToHex, R as oklchToOklab, p as rainbowVertexColors, Ee as resolveEasing, x as resolveSkeleton, C as rigidRigApply, n as sampleTrack, d as slewToward, m as solidVertexColors, w as solveIk, e as springPose, h as springVertexColors, z as srgbFloatToOklab, B as srgbToHsl, V as srgbToLinear, H as srgbU8ToOklab, g as staggerVertexColors, t as tweenPose, _ as tweenVertexColors, c as useAnimatedReflow, i as useAnimator, T as useRig };

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":";;;;AA4EA,SAAgBA,EAAqB,GAAoD;CACvF,QAAQ,GAAQ,EAAE,SAAM,kBAAe;EACrC,IAAMC,IAAIC,EAAW,UAAUC,CAAI,GAC7BC,IAAKH,EAAE,IAAIA,EAAE,QAAQ,GACrBI,IAAKJ,EAAE,IAAIA,EAAE,SAAS,GACtB,CAACK,GAAIC,KAAMC,EAAK,MAAMC,GAAUL,GAAIC,CAAE,GACtCK,IAAQR,EAAW,YACrBA,EAAW,UAAUC,GAAMG,IAAKF,GAAIG,IAAKF,CAAE,IAC3CH,EAAW,YAAYC,GAAMF,GAAG;GAAE,GAAGA;GAAG,GAAGA,EAAE,IAAIK,IAAKF;GAAI,GAAGH,EAAE,IAAIM,IAAKF;EAAG,CAAC;EAChF,IAAI,CAACH,EAAW,cAAc,OAAOQ;EACrC,IAAMC,IAAKT,EAAW,cAAcC,CAAI,KAAK,GACvCS,IAAK,KAAK,IAAID,CAAE,GAChBE,IAAK,KAAK,IAAIF,CAAE;EACtB,OAAOT,EAAW,aAChBQ,GACA,KAAK,MAAMD,EAAS,KAAKG,IAAKH,EAAS,KAAKI,GAAIJ,EAAS,KAAKG,IAAKH,EAAS,KAAKI,CAAE,CACrF;CACF;AACF;AAiBA,SAAgBC,EAAe,GAAqC;CAClE,IAAM,EAAE,UAAO,gBAAaC,GACtBC,IAAQD,EAAQ,SAASf,EAAce,EAAQ,cAAeE,CAA8C,GAC5GC,IAAaC,EAAgBC,GAAU,CAAC,CAAC,GAEzCC,IAAwB,CAAC;CAC/B,KAAK,IAAM,CAACC,GAAOC,MAAQ,OAAO,QAAQR,EAAQ,QAAQ,GAAG;EAC3D,IAAMS,IAAYN,EAAW,IAAII,CAAK;EACtC,IAAI,CAACE,GAAW,MAAU,MAAM,uCAAuCF,EAAM,GAAG;EAChF,IAAMG,IAAcjB,EAAK,OAAOgB,CAAS;EACzC,IAAI,CAACC,GAAa,MAAU,MAAM,mBAAmBH,EAAM,gCAAgC;EAC3F,KAAK,IAAMI,KAAQ,OAAOH,KAAQ,WAAW,CAACA,CAAG,IAAKA,GAA2B;GAC/E,IAAM,IAAII,EAAM,IAAID,CAAI;GACxB,IAAI,CAAC,GAAG,MAAU,MAAM,mBAAmBJ,EAAM,sBAAsBI,EAAK,0BAA0B;GACtG,EAAM,KAAK;IAAE;IAAM;IAAO,MAAM,EAAE;IAAM;IAAW;IAAa,OAAO,EAAE,MAAM,EAAE,KAAK;GAAE,CAAC;EAC3F;CACF;CAEA,IAAIE,IAAqCV,GACrCW,IAAY,IAEVC,UAAgB;EACpB,IAAKD,GACL;OAAY;GACZ,KAAK,IAAM5B,KAAKoB,GAAO,EAAM,UAAU,MAAMpB,EAAE,IAAI;EADvC;CAEd;CAEA,OAAO;EACL;EACA,KAAK,GAAM,GAAM;GACf,IAAM8B,IAAQZ,EAAgBC,GAAUY,CAAI;GAC5C,IAAIC,GAAM,KAAK,IAAM,CAACC,GAAMC,MAAMJ,GAAO,EAAM,IAAIG,GAAM1B,EAAK,SAASyB,GAAME,CAAC,CAAC;GAC/E,IAAQJ;GACR,IAAMtB,oBAAW,IAAI,IAAoB;GACzC,KAAK,IAAMR,KAAKoB,GAAO;IACrB,IAAMe,IAAIL,EAAM,IAAI9B,EAAE,KAAK,GACvBoC,IAAQ5B,EAAS,IAAIR,EAAE,KAAK;IAMhC,AALKoC,MACH,IAAQ7B,EAAK,SAAS4B,GAAGnC,EAAE,WAAW,GACtCQ,EAAS,IAAIR,EAAE,OAAOoC,CAAK,IAE7B,EAAE,MAAM,OAAOrB,EAAMoB,GAAG;KAAE,OAAOnC,EAAE;KAAO,MAAMA,EAAE;KAAM,MAAMA,EAAE;KAAM,WAAWA,EAAE;KAAW,UAAUoC;IAAM,CAAC,GAC1GR,KAAWF,EAAM,UAAU,IAAI1B,EAAE,MAAMA,EAAE,KAAK;GACrD;GAEA,AADA,IAAY,IACZ0B,EAAM,UAAU,OAAO;EACzB;EACA,aAAaC;EACb,KAAK,IAAQ,iBAAiB;GAC5B,AAAKC,MACLF,EAAM,MAAMW,SAAa;IACvB,KAAK,IAAMrC,KAAKoB,GAAO,AAAIpB,EAAE,MAAM,SAAS,KAAA,KAAW0B,EAAM,QAAQ1B,EAAE,MAAMA,EAAE,MAAM,IAAI;GAC3F,CAAC,GACD6B,EAAQ;EACV;EACA;CACF;AACF"}

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"}