@weasel-js/core 1.9.3 → 1.10.0

package/dist/animation/rig/bindRig.js

@@ -1,74 +1,106 @@
-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";
+import { AUTO_POSE_DESCRIPTOR as e } from "../../core/geometry/autoPoseDescriptor.js";
+import { createRigSeat as t } from "./rigSeat.js";
+import { bindSkins as n, dataRestPath as r } from "./skinBinding.js";
+import { mat3 as i } from "@weasel-js/geom";
+import { resolveSkeleton as a } from "@weasel-js/animator";
 //#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, {
+function o(e) {
+	return (t, { rest: n, fromRest: r }) => {
+		let a = e.getBounds(n), o = a.x + a.width / 2, s = a.y + a.height / 2, [c, l] = i.apply(r, o, s), u = e.translate ? e.translate(n, c - o, l - s) : e.remapBounds(n, 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));
+		if (!e.withRotation) return u;
+		let d = e.getRotation?.(n) ?? 0, f = Math.cos(d), p = Math.sin(d);
+		return e.withRotation(u, Math.atan2(r[1] * f + r[4] * p, r[0] * f + r[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,
+function s(e) {
+	let n = t(e.skeleton), { rig: r, binding: i } = c(e, n);
+	return n.binding = i, r;
+}
+function c(t, s) {
+	let { scene: c, skeleton: l } = t, u = t.descriptor ?? e, d = t.apply ?? o(u), f = a(l, {}), p = /* @__PURE__ */ new Map(), m = (e) => {
+		let t = p.get(e);
+		if (t) return t;
+		let n = f.get(e);
+		if (!n) throw Error(`bindRig: the skeleton has no joint "${e}".`);
+		if (t = i.invert(n) ?? void 0, !t) throw Error(`bindRig: joint "${e}" is singular at the bind pose.`);
+		return p.set(e, t), t;
+	}, h = n(c, t.skins ?? {}, t.restPath ?? r, u);
+	h.joints.forEach(m);
+	let g = [];
+	for (let [e, n] of Object.entries(t.bindings ?? {})) {
+		m(e);
+		let r = f.get(e);
+		for (let i of typeof n == "string" ? [n] : n) {
+			if (t.skins && i in t.skins) throw Error(`bindRig: node "${i}" is both bound to joint "${e}" and skinned.`);
+			let n = c.get(i);
+			if (!n) throw Error(`bindRig: joint "${e}" is bound to node "${i}", which the scene lacks.`);
+			g.push({
+				node: i,
+				joint: e,
 				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);
+	let _ = f, v = !1, y = () => {
+		if (v) {
+			v = !1;
+			for (let e of g) c.overrides.clear(e.node);
+			h.release();
 		}
-	};
+	}, b = () => {
+		s.shown = !1, y();
+	}, x = (e) => {
+		let t = a(l, e), { root: n } = s;
+		if (n) for (let [e, r] of t) t.set(e, i.multiply(n, r));
+		_ = t;
+		let r = /* @__PURE__ */ new Map(), o = (e) => {
+			let n = r.get(e);
+			return n || (n = i.multiply(t.get(e), m(e)), r.set(e, n)), n;
+		};
+		for (let e of g) {
+			let n = t.get(e.joint);
+			e.entry.pose = d(n, {
+				joint: e.joint,
+				node: e.node,
+				rest: e.rest,
+				restWorld: e.restWorld,
+				fromRest: o(e.joint)
+			}), v || c.overrides.set(e.node, e.entry);
+		}
+		h.joints.forEach(o), h.show(r), v = !0, s.shown = !0, c.overrides.commit();
+	}, { target: S } = s;
 	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();
+		rig: {
+			skeleton: l,
+			target: S,
+			pose(e, t) {
+				s.committed = e, t && (s.root = t), x(S.read());
+			},
+			place(e) {
+				s.root = e, x(S.read());
+			},
+			world: () => _,
+			bake(e = "Bake rig pose") {
+				v && (c.batch(e, () => {
+					for (let e of g) e.entry.pose !== void 0 && c.setPose(e.node, e.entry.pose);
+					h.write();
+				}), b());
+			},
+			release: b
 		},
-		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
+		binding: {
+			show: x,
+			drop: y
+		}
 	};
 }
 //#endregion
-export { i as bindRig, r as rigidRigApply };
+export { s as bindRig, c as bindRigOn, o as rigidRigApply };
 
 //# sourceMappingURL=bindRig.js.map

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

@@ -1 +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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"}
+{"version":3,"file":"bindRig.js","names":["rigidRigApply","b","descriptor","rest","cx","cy","nx","ny","mat3","fromRest","moved","r0","ux","uy","bindRig","seat","createRigSeat","options","bindRigOn","binding","rig","AUTO_POSE_DESCRIPTOR","apply","restWorlds","resolveSkeleton","skeleton","restInverses","restInverseOf","inverse","joint","restWorld","skins","bindSkins","scene","dataRestPath","bound","ids","node","world","installed","drop","release","show","local","pose","root","name","m","motionOf","delta","w","at","target","label"],"sources":["../../../src/animation/rig/bindRig.ts"],"sourcesContent":["import type { PoseDescriptor } from '../../core/geometry/poseDescriptor';\nimport type { NodeId, PoseOverride } from '../../core/scene/types';\nimport { AUTO_POSE_DESCRIPTOR } from 'core/geometry/autoPoseDescriptor';\nimport { mat3, type GlMat3 } from '@weasel-js/geom';\nimport type { Target } from '@weasel-js/animator';\nimport { resolveSkeleton } from '@weasel-js/animator';\nimport type { Pose, Skeleton } from '@weasel-js/animator';\nimport type { Skin } from '@weasel-js/animator';\nimport { createRigSeat, type RigBinding, type RigSeat } from './rigSeat';\nimport { bindSkins, dataRestPath, type RestPath, type SkinScene } from './skinBinding';\n\n/** The part of a scene a rig writes to. */\nexport interface RigScene<TPose> extends SkinScene<TPose> {\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  /** Node id → the weights its path bends by. Where a bound node moves whole with one joint,\n   *  a skinned node's points each follow their own joints, and the rig shows the bent path\n   *  through the node's pose override, posed at the path's bounds. */\n  skins?: Readonly<Record<NodeId, Skin>>;\n  /** Where a skinned node's path is drawn when the rig is bound. Default\n   *  {@link dataRestPath}: the node's `data.path`, through its pose. */\n  restPath?: RestPath<TPose>;\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   * The rig's pose as a value an animator moves. Its committed value starts as `{}`, the bind\n   * pose, and each frame the rig is posed with what the target shows. A clip is a\n   * `SampledTrack<Pose>` given this as its `target`: clips on one rig crossfade by their\n   * `weight`s, weights short of 1 leave the rest to the committed pose, and a `spring` or\n   * `tween` from a pose away from the committed one adds on top. `animator.hold` shows a pose made elsewhere the same way, an\n   * IK solve included.\n   */\n  readonly target: Target<Pose>;\n  /**\n   * Commit `pose` and move every bound node to what the target now shows, which is `pose`\n   * unless something is animating the target; a hold on it weighs the new pose in when it is\n   * next read, at the animator's next frame or the hold's `touch()`. Writes go through the scene's pose overrides —\n   * no history entry, no document write, no version bump — and are committed. `root`, where\n   * given, replaces the placement, as {@link Rig.place}.\n   */\n  pose(pose: Pose, root?: GlMat3): void;\n  /** Place the rig in the world by `root`, which may mirror it, and pose it there. It stays\n   *  until placed again; with no `root`, the rig goes back to where its skeleton puts it. */\n  place(root?: GlMat3): void;\n  /** The joint world transforms as the rig was last posed, 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. A skinned node's bent path goes into\n   *  its `data.path`. Later frames stay relative to the bind-time rest, so\n   *  baking does not compound. */\n  bake(label?: string): void;\n  /** Drop the overrides; the nodes show their document poses again until the\n   *  rig is next posed. */\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  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 seat = createRigSeat(options.skeleton);\n  const { rig, binding } = bindRigOn(options, seat);\n  seat.binding = binding;\n  return rig;\n}\n\n/** {@link bindRig} on a seat the caller keeps. The rig shows the seat's target once its\n *  `binding` is the seat's. */\nexport function bindRigOn<TPose>(\n  options: BindRigOptions<TPose>,\n  seat: RigSeat,\n): { rig: Rig; binding: RigBinding } {\n  const { scene, skeleton } = options;\n  const descriptor = options.descriptor ?? (AUTO_POSE_DESCRIPTOR as PoseDescriptor<TPose>);\n  const apply = options.apply ?? rigidRigApply(descriptor);\n  const restWorlds = resolveSkeleton(skeleton, {});\n  const restInverses = new Map<string, GlMat3>();\n  const restInverseOf = (joint: string): GlMat3 => {\n    let inverse = restInverses.get(joint);\n    if (inverse) return inverse;\n    const restWorld = restWorlds.get(joint);\n    if (!restWorld) throw new Error(`bindRig: the skeleton has no joint \"${joint}\".`);\n    inverse = mat3.invert(restWorld) ?? undefined;\n    if (!inverse) throw new Error(`bindRig: joint \"${joint}\" is singular at the bind pose.`);\n    restInverses.set(joint, inverse);\n    return inverse;\n  };\n\n  const skins = bindSkins(scene, options.skins ?? {}, options.restPath ?? dataRestPath, descriptor);\n  skins.joints.forEach(restInverseOf);\n\n  const bound: Bound<TPose>[] = [];\n  for (const [joint, ids] of Object.entries(options.bindings ?? {})) {\n    restInverseOf(joint);\n    const restWorld = restWorlds.get(joint)!;\n    for (const node of typeof ids === 'string' ? [ids] : (ids as readonly NodeId[])) {\n      if (options.skins && node in options.skins) {\n        throw new Error(`bindRig: node \"${node}\" is both bound to joint \"${joint}\" and skinned.`);\n      }\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, entry: { pose: n.pose } });\n    }\n  }\n\n  let world: ReadonlyMap<string, GlMat3> = restWorlds;\n  let installed = false;\n\n  const drop = () => {\n    if (!installed) return;\n    installed = false;\n    for (const b of bound) scene.overrides.clear(b.node);\n    skins.release();\n  };\n  const release = () => {\n    seat.shown = false;\n    drop();\n  };\n\n  const show = (pose: Pose): void => {\n    const local = resolveSkeleton(skeleton, pose);\n    const { root } = seat;\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    const motionOf = (joint: string): GlMat3 => {\n      let delta = fromRest.get(joint);\n      if (!delta) {\n        delta = mat3.multiply(local.get(joint)!, restInverseOf(joint));\n        fromRest.set(joint, delta);\n      }\n      return delta;\n    };\n    for (const b of bound) {\n      const w = local.get(b.joint)!;\n      b.entry.pose = apply(w, { joint: b.joint, node: b.node, rest: b.rest, restWorld: b.restWorld, fromRest: motionOf(b.joint) });\n      if (!installed) scene.overrides.set(b.node, b.entry);\n    }\n    skins.joints.forEach(motionOf);\n    skins.show(fromRest);\n    installed = true;\n    seat.shown = true;\n    scene.overrides.commit();\n  };\n\n  const { target } = seat;\n  const rig: Rig = {\n    skeleton,\n    target,\n    pose(pose, at) {\n      seat.committed = pose;\n      if (at) seat.root = at;\n      show(target.read());\n    },\n    place(at) {\n      seat.root = at;\n      show(target.read());\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        skins.write();\n      });\n      release();\n    },\n    release,\n  };\n  return { rig, binding: { show, drop } };\n}\n"],"mappings":"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"}

package/dist/animation/rig/rigNode.js

@@ -0,0 +1,93 @@
+import { AUTO_POSE_DESCRIPTOR as e } from "../../core/geometry/autoPoseDescriptor.js";
+import { createRigSeat as t } from "./rigSeat.js";
+import { useSeatedRig as n } from "./useRig.js";
+import { poseFrameInverseOf as r, poseFrameOf as i } from "@weasel-js/geom";
+import { useMemo as a, useState as o, useSyncExternalStore as s } from "react";
+//#region src/animation/rig/rigNode.ts
+var c = (e, t, n) => e ? [e[0] * t + e[2] * n + e[4], e[1] * t + e[3] * n + e[5]] : [t, n];
+function l(t, n, r = e) {
+	let a = r.getBounds(n), o = i(n), s = r.getRotation?.(n) ?? 0;
+	return { joints: t.joints.map((e) => {
+		if (e.parent != null) return e;
+		let [t, n] = c(o, a.x + e.bind.x, a.y + e.bind.y);
+		return {
+			...e,
+			bind: {
+				...e.bind,
+				x: t,
+				y: n,
+				rotation: e.bind.rotation + s
+			}
+		};
+	}) };
+}
+function u(t, n, i = e) {
+	let a = i.getBounds(n), o = r(n), s = i.getRotation?.(n) ?? 0;
+	return { joints: t.joints.map((e) => {
+		if (e.parent != null) return e;
+		let [t, n] = c(o, e.bind.x, e.bind.y);
+		return {
+			...e,
+			bind: {
+				...e.bind,
+				x: t - a.x,
+				y: n - a.y,
+				rotation: e.bind.rotation - s
+			}
+		};
+	}) };
+}
+var d = /* @__PURE__ */ new Map(), f = () => () => {}, p = () => d;
+function m(e, t, n, r = d) {
+	let i = e.get(t);
+	if (!i) throw Error(`rigFromNode: the rig is node "${t}", which the scene lacks.`);
+	let a = i.data?.skeleton;
+	if (!a) throw Error(`rigFromNode: node "${t}" has no skeleton in its data.`);
+	let o = {
+		skeleton: l(a, i.pose, n),
+		bindings: {},
+		skins: {},
+		refs: [i.pose, i.data]
+	}, s = (t) => {
+		for (let n of e.childrenOf(t)) {
+			let t = e.get(n);
+			if (!t) continue;
+			let i = t.data, a = r.get(n) ?? i?.skin;
+			o.refs.push(n, t.pose, t.data, a), a ? o.skins[n] = a : i?.joint !== void 0 && (o.bindings[i.joint] ??= []).push(n), s(n);
+		}
+	};
+	return s(t), o;
+}
+var h = (e, t) => e === t || e.refs.length === t.refs.length && e.refs.every((e, n) => e === t.refs[n]);
+function g(t, n, r = e) {
+	let { skeleton: i, bindings: a, skins: o } = m(t, n, r);
+	return {
+		skeleton: i,
+		bindings: a,
+		skins: o
+	};
+}
+function _(r) {
+	let { scene: i, node: c, apply: l, descriptor: u, restPath: d, painting: g } = r, _ = s(i.subscribe, i.getVersion), v = s(g?.listen ?? f, g?.painted ?? p), y = a(() => m(i, c, u ?? e, v), [
+		i,
+		c,
+		u,
+		_,
+		v
+	]), [b, x] = o(y), S = h(b, y) ? b : y;
+	S !== b && x(y);
+	let C = JSON.stringify(S.skeleton.joints.map((e) => e.name)), w = a(() => t(S.skeleton), [C]);
+	return n({
+		scene: i,
+		skeleton: S.skeleton,
+		bindings: S.bindings,
+		skins: S.skins,
+		apply: l,
+		descriptor: u,
+		restPath: d
+	}, w);
+}
+//#endregion
+export { l as placeSkeleton, g as rigFromNode, u as unplaceSkeleton, _ as useRigNode };
+
+//# sourceMappingURL=rigNode.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rigNode.js","names":["through","m","x","y","placeSkeleton","AUTO_POSE_DESCRIPTOR","box","descriptor","pose","frame","poseFrameOf","turn","skeleton","joint","unplaceSkeleton","inverse","poseFrameInverseOf","UNPAINTED","noWord","unpainted","read","node","scene","id","local","out","walk","child","parent","n","data","skin","painted","sameRefs","a","b","r","i","rigFromNode","useRigNode","options","version","useSyncExternalStore","painting","next","useMemo","held","setHeld","useState","parts","joints","seat","createRigSeat","useSeatedRig"],"sources":["../../../src/animation/rig/rigNode.ts"],"sourcesContent":["import { useMemo, useState, useSyncExternalStore } from 'react';\nimport { poseFrameInverseOf, poseFrameOf } from '@weasel-js/geom';\nimport { AUTO_POSE_DESCRIPTOR } from 'core/geometry/autoPoseDescriptor';\nimport type { PoseDescriptor } from '../../core/geometry/poseDescriptor';\nimport type { NodeId } from '../../core/scene/types';\nimport type { BindRigOptions, Rig, RigScene } from './bindRig';\nimport type { Skin } from '@weasel-js/animator';\nimport type { Skeleton } from '@weasel-js/animator';\nimport { createRigSeat } from './rigSeat';\nimport { useSeatedRig } from './useRig';\n\n/** What a rig reads from node data: a `skeleton` on the node that is the rig, and on the nodes\n *  under it a `skin` for a path that bends or a `joint` for a node that rides one whole. */\nexport interface RigNodeData {\n  /** Joints relative to the node's pose: its box's top-left corner, turned as the node is. */\n  skeleton?: Skeleton;\n  skin?: Skin;\n  joint?: string;\n}\n\n/** Weights to bind in place of the document's, and word of when they change. A `RigEditState`\n *  is one: it holds what a stroke of the weight tool has painted and not yet written. */\nexport interface PaintedSkins {\n  /** By node. A new map whenever the weights change. */\n  painted(): ReadonlyMap<NodeId, Skin>;\n  listen(fn: () => void): () => void;\n}\n\n/** The part of a scene `rigFromNode` reads. */\nexport interface RigNodeSource<TPose> {\n  get(id: NodeId): { pose: TPose; data?: unknown } | undefined;\n  childrenOf(id: NodeId): readonly NodeId[];\n}\n\n/** The skeleton, bindings, and skins a rig node declares, as `bindRig` takes them. */\nexport interface RigNodeParts {\n  skeleton: Skeleton;\n  bindings: Record<string, NodeId[]>;\n  skins: Record<NodeId, Skin>;\n}\n\ninterface Reading extends RigNodeParts {\n  /** Every node, pose, and data object the parts were read from, to tell when they are stale. */\n  refs: unknown[];\n}\n\ntype Affine = readonly [number, number, number, number, number, number];\nconst through = (m: Affine | null, x: number, y: number): [number, number] =>\n  (m ? [m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5]] : [x, y]);\n\n/**\n * A skeleton as a rig node's data keeps it, moved to where the node's pose puts it: its root\n * joints are offset from the pose box's top-left corner and turned as the node is. Joints\n * under a root are relative to their parents and are left as they are.\n */\nexport function placeSkeleton<TPose>(\n  skeleton: Skeleton,\n  pose: TPose,\n  descriptor: PoseDescriptor<TPose> = AUTO_POSE_DESCRIPTOR as PoseDescriptor<TPose>,\n): Skeleton {\n  const box = descriptor.getBounds(pose);\n  const frame = poseFrameOf(pose);\n  const turn = descriptor.getRotation?.(pose) ?? 0;\n  return {\n    joints: skeleton.joints.map((joint) => {\n      if (joint.parent != null) return joint;\n      const [x, y] = through(frame, box.x + joint.bind.x, box.y + joint.bind.y);\n      return { ...joint, bind: { ...joint.bind, x, y, rotation: joint.bind.rotation + turn } };\n    }),\n  };\n}\n\n/** The inverse of {@link placeSkeleton}: a skeleton in the scene's space, as the node at\n *  `pose` would keep it in its data. */\nexport function unplaceSkeleton<TPose>(\n  skeleton: Skeleton,\n  pose: TPose,\n  descriptor: PoseDescriptor<TPose> = AUTO_POSE_DESCRIPTOR as PoseDescriptor<TPose>,\n): Skeleton {\n  const box = descriptor.getBounds(pose);\n  const inverse = poseFrameInverseOf(pose);\n  const turn = descriptor.getRotation?.(pose) ?? 0;\n  return {\n    joints: skeleton.joints.map((joint) => {\n      if (joint.parent != null) return joint;\n      const [x, y] = through(inverse, joint.bind.x, joint.bind.y);\n      return { ...joint, bind: { ...joint.bind, x: x - box.x, y: y - box.y, rotation: joint.bind.rotation - turn } };\n    }),\n  };\n}\n\nconst UNPAINTED: ReadonlyMap<NodeId, Skin> = new Map();\nconst noWord = (): (() => void) => () => {};\nconst unpainted = (): ReadonlyMap<NodeId, Skin> => UNPAINTED;\n\nfunction read<TPose>(\n  scene: RigNodeSource<TPose>,\n  id: NodeId,\n  descriptor: PoseDescriptor<TPose>,\n  painted: ReadonlyMap<NodeId, Skin> = UNPAINTED,\n): Reading {\n  const node = scene.get(id);\n  if (!node) throw new Error(`rigFromNode: the rig is node \"${id}\", which the scene lacks.`);\n  const local = (node.data as RigNodeData | null | undefined)?.skeleton;\n  if (!local) throw new Error(`rigFromNode: node \"${id}\" has no skeleton in its data.`);\n\n  const skeleton = placeSkeleton(local, node.pose, descriptor);\n\n  const out: Reading = { skeleton, bindings: {}, skins: {}, refs: [node.pose, node.data] };\n  const walk = (parent: NodeId): void => {\n    for (const child of scene.childrenOf(parent)) {\n      const n = scene.get(child);\n      if (!n) continue;\n      const data = n.data as RigNodeData | null | undefined;\n      const skin = painted.get(child) ?? data?.skin;\n      out.refs.push(child, n.pose, n.data, skin);\n      if (skin) out.skins[child] = skin;\n      else if (data?.joint !== undefined) (out.bindings[data.joint] ??= []).push(child);\n      walk(child);\n    }\n  };\n  walk(id);\n  return out;\n}\n\nconst sameRefs = (a: Reading, b: Reading): boolean =>\n  a === b || (a.refs.length === b.refs.length && a.refs.every((r, i) => r === b.refs[i]));\n\n/**\n * Read a rig out of the scene: the skeleton in `id`'s `data.skeleton`, placed by that node's\n * pose, and under it every node whose data has a `skin` or names a `joint`.\n */\nexport function rigFromNode<TPose>(\n  scene: RigNodeSource<TPose>,\n  id: NodeId,\n  descriptor: PoseDescriptor<TPose> = AUTO_POSE_DESCRIPTOR as PoseDescriptor<TPose>,\n): RigNodeParts {\n  const { skeleton, bindings, skins } = read(scene, id, descriptor);\n  return { skeleton, bindings, skins };\n}\n\n/** Options for `useRigNode`. */\nexport interface UseRigNodeOptions<TPose>\n  extends Pick<BindRigOptions<TPose>, 'apply' | 'descriptor' | 'restPath'> {\n  scene: RigScene<TPose> & RigNodeSource<TPose> & {\n    subscribe(listener: () => void): () => void;\n    getVersion(): number;\n  };\n  /** The node whose data holds the skeleton. */\n  node: NodeId;\n  /** Weights bound in place of a node's `data.skin` while they are held. Give it the\n   *  `RigEditState` the weight tool has, and a stroke bends the path as it is painted. */\n  painting?: PaintedSkins;\n}\n\n/**\n * A {@link Rig} read from a node, as {@link rigFromNode} reads it. It is bound again when the\n * rig node or a node under it changes its pose or data, or when nodes under it come or go; an\n * edit elsewhere in the scene leaves it alone. A rig bound again keeps its `target`, with the\n * animations running on it, its committed pose, and its placement, unless the skeleton's\n * joints were added, removed, renamed, or reordered: then it starts at the bind pose with a\n * new `target`.\n */\nexport function useRigNode<TPose>(options: UseRigNodeOptions<TPose>): Rig {\n  const { scene, node, apply, descriptor, restPath, painting } = options;\n  const version = useSyncExternalStore(scene.subscribe, scene.getVersion);\n  const painted = useSyncExternalStore(painting?.listen ?? noWord, painting?.painted ?? unpainted);\n  const next = useMemo(\n    () => read(scene, node, descriptor ?? (AUTO_POSE_DESCRIPTOR as PoseDescriptor<TPose>), painted),\n    // `version` is what says the scene may answer differently.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    [scene, node, descriptor, version, painted],\n  );\n  // Each read makes new objects; the rig must outlive a read that found nothing changed.\n  const [held, setHeld] = useState(next);\n  const parts = sameRefs(held, next) ? held : next;\n  if (parts !== held) setHeld(next);\n  const joints = JSON.stringify(parts.skeleton.joints.map((joint) => joint.name));\n  // A pose target's axes are its joints' names in order, so the seat holds while those do.\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  const seat = useMemo(() => createRigSeat(parts.skeleton), [joints]);\n  return useSeatedRig({\n    scene, skeleton: parts.skeleton, bindings: parts.bindings, skins: parts.skins, apply, descriptor, restPath,\n  }, seat);\n}\n"],"mappings":"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"}

package/dist/animation/rig/rigSeat.js

@@ -0,0 +1,26 @@
+import { createTarget as e, skeletonAxes as t } from "@weasel-js/animator";
+//#region src/animation/rig/rigSeat.ts
+function n(n) {
+	let r = {
+		committed: {},
+		root: void 0,
+		binding: null,
+		shown: !1,
+		target: e({
+			get: () => r.committed,
+			set: (e) => {
+				r.committed = e;
+			},
+			axes: t(n),
+			show: (e) => r.binding?.show(e)
+		})
+	};
+	return r;
+}
+function r(e, t) {
+	e.binding = t, e.shown && t.show(e.target.read());
+}
+//#endregion
+export { n as createRigSeat, r as seatBinding };
+
+//# sourceMappingURL=rigSeat.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rigSeat.js","names":["createRigSeat","seat","createTarget","pose","skeletonAxes","skeleton","seatBinding","binding"],"sources":["../../../src/animation/rig/rigSeat.ts"],"sourcesContent":["import type { GlMat3 } from '@weasel-js/geom';\nimport { createTarget, skeletonAxes, type Pose, type Skeleton, type Target } from '@weasel-js/animator';\n\n/** One binding of a rig to the scene: what a seat shows its pose through. */\nexport interface RigBinding {\n  show(pose: Pose): void;\n  /** Drop the overrides, leaving the seat as it is. */\n  drop(): void;\n}\n\n/**\n * A rig's pose apart from the binding that shows it: the target, the committed pose, and the\n * placement. A rig bound again on the seat it had goes on under the animations running on its\n * target.\n */\nexport interface RigSeat {\n  readonly target: Target<Pose>;\n  committed: Pose;\n  root: GlMat3 | undefined;\n  binding: RigBinding | null;\n  /** Whether the pose is on screen: set as a binding shows it, cleared as the rig is released. */\n  shown: boolean;\n}\n\n/** A seat at the bind pose, for a skeleton with these joints in this order. */\nexport function createRigSeat(skeleton: Skeleton): RigSeat {\n  const seat: RigSeat = {\n    committed: {},\n    root: undefined,\n    binding: null,\n    shown: false,\n    target: createTarget<Pose>({\n      get: () => seat.committed,\n      set: (pose) => { seat.committed = pose; },\n      axes: skeletonAxes(skeleton),\n      show: (pose) => seat.binding?.show(pose),\n    }),\n  };\n  return seat;\n}\n\n/** Make `binding` the one `seat` shows through, and show it what the last one had on screen. */\nexport function seatBinding(seat: RigSeat, binding: RigBinding): void {\n  seat.binding = binding;\n  if (seat.shown) binding.show(seat.target.read());\n}\n"],"mappings":";;AAyBA,SAAgBA,EAAc,GAA6B;CACzD,IAAMC,IAAgB;EACpB,WAAW,CAAC;EACZ,MAAM,KAAA;EACN,SAAS;EACT,OAAO;EACP,QAAQC,EAAmB;GACzB,WAAWD,EAAK;GAChB,MAAM,MAAS;IAAE,EAAK,YAAYE;GAAM;GACxC,MAAMC,EAAaC,CAAQ;GAC3B,OAAO,MAASJ,EAAK,SAAS,KAAKE,CAAI;EACzC,CAAC;CACH;CACA,OAAOF;AACT;AAGA,SAAgBK,EAAY,GAAe,GAA2B;CAEpE,AADA,EAAK,UAAUC,GACXN,EAAK,SAAOM,EAAQ,KAAKN,EAAK,OAAO,KAAK,CAAC;AACjD"}

package/dist/animation/rig/skinBinding.js

@@ -0,0 +1,56 @@
+import { boundsOfPath as e, pathInWorld as t } from "@weasel-js/geom";
+import { skinPath as n } from "@weasel-js/animator";
+//#region src/animation/rig/skinBinding.ts
+function r(e) {
+	let n = e.data?.path;
+	return n ? t(n, e.pose) : null;
+}
+function i(t, r, i, a) {
+	let o = [], s = /* @__PURE__ */ new Set();
+	for (let [e, n] of Object.entries(r)) {
+		let r = t.get(e);
+		if (!r) throw Error(`bindRig: a skin names node "${e}", which the scene lacks.`);
+		let a = i(r);
+		if (!a) throw Error(`bindRig: node "${e}" has no path to skin.`);
+		for (let e in n) s.add(e);
+		o.push({
+			node: e,
+			skin: n,
+			rest: a,
+			restPose: r.pose,
+			entry: {}
+		});
+	}
+	let c = !1;
+	return {
+		joints: [...s],
+		show(r) {
+			for (let i of o) {
+				let o = n(i.rest, i.skin, r);
+				i.entry.path = o, i.entry.pose = a.fromBounds(e(o), i.restPose), c || t.overrides.set(i.node, i.entry);
+			}
+			c = !0;
+		},
+		write() {
+			for (let e of o) {
+				let { path: n, pose: r } = e.entry;
+				if (n === void 0 || r === void 0) continue;
+				let i = t.get(e.node)?.data;
+				t.update(e.node, { data: {
+					...i,
+					path: n
+				} }), t.setPose(e.node, r);
+			}
+		},
+		release() {
+			if (c) {
+				c = !1;
+				for (let e of o) t.overrides.clear(e.node);
+			}
+		}
+	};
+}
+//#endregion
+export { i as bindSkins, r as dataRestPath };
+
+//# sourceMappingURL=skinBinding.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skinBinding.js","names":["dataRestPath","path","node","pathInWorld","bindSkins","skinned","joints","id","skin","skins","scene","rest","restPath","joint","installed","s","skinPath","motions","descriptor","boundsOfPath","pose","data"],"sources":["../../../src/animation/rig/skinBinding.ts"],"sourcesContent":["import { boundsOfPath, pathInWorld, type GlMat3, type Path, type PathInWorldPose } from '@weasel-js/geom';\nimport type { PoseDescriptor } from '../../core/geometry/poseDescriptor';\nimport type { NodeId, PoseOverride, PoseOverrides } from '../../core/scene/types';\nimport { skinPath, type Skin } from '@weasel-js/animator';\n\n/** The part of a scene a rig's skins read and write. */\nexport interface SkinScene<TPose> {\n  get(id: NodeId): { pose: TPose; data?: unknown } | undefined;\n  readonly overrides: PoseOverrides<TPose>;\n  setPose(id: NodeId, pose: TPose): void;\n  update(id: NodeId, patch: { data: never }): void;\n}\n\n/** Where a node's path is drawn, for a skin to bend: `null` for a node with none. */\nexport type RestPath<TPose> = (node: { pose: TPose; data?: unknown }) => Path | null;\n\n/** The path in a node's `data.path`, carried through its pose as `kit:path` paints it. */\nexport function dataRestPath<TPose>(node: { pose: TPose; data?: unknown }): Path | null {\n  const path = (node.data as { path?: Path } | null | undefined)?.path;\n  return path ? pathInWorld(path, node.pose as PathInWorldPose) : null;\n}\n\ninterface Skinned<TPose> {\n  node: NodeId;\n  skin: Skin;\n  rest: Path;\n  restPose: TPose;\n  entry: PoseOverride<TPose>;\n}\n\n/** A rig's skinned nodes, as `bindSkins` returns them. */\nexport interface SkinBinding {\n  /** Every joint a skin weighs. */\n  readonly joints: readonly string[];\n  /** Bend each skinned path by `motions`, which holds every one of `joints`, into its node's\n   *  pose override. The caller commits the overrides. */\n  show(motions: ReadonlyMap<string, GlMat3>): void;\n  /** Write each bent path and its bounds into the document. */\n  write(): void;\n  release(): void;\n}\n\n/** Read each skinned node's rest path and ready an override for it. */\nexport function bindSkins<TPose>(\n  scene: SkinScene<TPose>,\n  skins: Readonly<Record<NodeId, Skin>>,\n  restPath: RestPath<TPose>,\n  descriptor: PoseDescriptor<TPose>,\n): SkinBinding {\n  const skinned: Skinned<TPose>[] = [];\n  const joints = new Set<string>();\n  for (const [id, skin] of Object.entries(skins) as [NodeId, Skin][]) {\n    const node = scene.get(id);\n    if (!node) throw new Error(`bindRig: a skin names node \"${id}\", which the scene lacks.`);\n    const rest = restPath(node);\n    if (!rest) throw new Error(`bindRig: node \"${id}\" has no path to skin.`);\n    for (const joint in skin) joints.add(joint);\n    skinned.push({ node: id, skin, rest, restPose: node.pose, entry: {} });\n  }\n  let installed = false;\n  return {\n    joints: [...joints],\n    show(motions) {\n      for (const s of skinned) {\n        const path = skinPath(s.rest, s.skin, motions);\n        s.entry.path = path;\n        s.entry.pose = descriptor.fromBounds(boundsOfPath(path), s.restPose);\n        if (!installed) scene.overrides.set(s.node, s.entry);\n      }\n      installed = true;\n    },\n    write() {\n      for (const s of skinned) {\n        const { path, pose } = s.entry;\n        if (path === undefined || pose === undefined) continue;\n        const data = scene.get(s.node)?.data;\n        scene.update(s.node, { data: { ...(data as object), path } as never });\n        scene.setPose(s.node, pose);\n      }\n    },\n    release() {\n      if (!installed) return;\n      installed = false;\n      for (const s of skinned) scene.overrides.clear(s.node);\n    },\n  };\n}\n"],"mappings":";;;AAiBA,SAAgBA,EAAoB,GAAoD;CACtF,IAAMC,IAAQC,EAAK,MAA6C;CAChE,OAAOD,IAAOE,EAAYF,GAAMC,EAAK,IAAuB,IAAI;AAClE;AAuBA,SAAgBE,EACd,GACA,GACA,GACA,GACa;CACb,IAAMC,IAA4B,CAAC,GAC7BC,oBAAS,IAAI,IAAY;CAC/B,KAAK,IAAM,CAACC,GAAIC,MAAS,OAAO,QAAQC,CAAK,GAAuB;EAClE,IAAMP,IAAOQ,EAAM,IAAIH,CAAE;EACzB,IAAI,CAACL,GAAM,MAAU,MAAM,+BAA+BK,EAAG,0BAA0B;EACvF,IAAMI,IAAOC,EAASV,CAAI;EAC1B,IAAI,CAACS,GAAM,MAAU,MAAM,kBAAkBJ,EAAG,uBAAuB;EACvE,KAAK,IAAMM,KAASL,GAAM,EAAO,IAAIK,CAAK;EAC1C,EAAQ,KAAK;GAAE,MAAMN;GAAI;GAAM;GAAM,UAAUL,EAAK;GAAM,OAAO,CAAC;EAAE,CAAC;CACvE;CACA,IAAIY,IAAY;CAChB,OAAO;EACL,QAAQ,CAAC,GAAGR,CAAM;EAClB,KAAK,GAAS;GACZ,KAAK,IAAMS,KAAKV,GAAS;IACvB,IAAMJ,IAAOe,EAASD,EAAE,MAAMA,EAAE,MAAME,CAAO;IAG7C,AAFA,EAAE,MAAM,OAAOhB,GACf,EAAE,MAAM,OAAOiB,EAAW,WAAWC,EAAalB,CAAI,GAAGc,EAAE,QAAQ,GAC9DD,KAAWJ,EAAM,UAAU,IAAIK,EAAE,MAAMA,EAAE,KAAK;GACrD;GACA,IAAY;EACd;EACA,QAAQ;GACN,KAAK,IAAMA,KAAKV,GAAS;IACvB,IAAM,EAAE,SAAM,YAASU,EAAE;IACzB,IAAId,MAAS,KAAA,KAAamB,MAAS,KAAA,GAAW;IAC9C,IAAMC,IAAOX,EAAM,IAAIK,EAAE,IAAI,CAAC,EAAE;IAEhC,AADAL,EAAM,OAAOK,EAAE,MAAM,EAAE,MAAM;KAAE,GAAIM;KAAiB;IAAK,EAAW,CAAC,GACrEX,EAAM,QAAQK,EAAE,MAAMK,CAAI;GAC5B;EACF;EACA,UAAU;GACR,IAAKN,GACL;QAAY;IACZ,KAAK,IAAMC,KAAKV,GAAS,EAAM,UAAU,MAAMU,EAAE,IAAI;GADzC;EAEd;CACF;AACF"}

package/dist/animation/rig/useRig.js

@@ -1,23 +1,38 @@
-import { bindRig as e } from "./bindRig.js";
-import { useEffect as t, useMemo as n } from "react";
+import { createRigSeat as e, seatBinding as t } from "./rigSeat.js";
+import { bindRigOn as n } from "./bindRig.js";
+import { useEffect as r, useMemo as i } from "react";
 //#region src/animation/rig/useRig.ts
-function r(r) {
-	let { scene: i, skeleton: a, bindings: o, apply: s, descriptor: c } = r, l = n(() => e({
-		scene: i,
-		skeleton: a,
-		bindings: o,
-		apply: s,
-		descriptor: c
-	}), [
-		i,
-		a,
-		o,
+function a(e) {
+	return o(e, null);
+}
+function o(a, o) {
+	let { scene: s, skeleton: c, bindings: l, skins: u, restPath: d, apply: f, descriptor: p } = a, m = i(() => {
+		let t = o ?? e(c), r = n({
+			scene: s,
+			skeleton: c,
+			bindings: l,
+			skins: u,
+			restPath: d,
+			apply: f,
+			descriptor: p
+		}, t);
+		return t.binding ??= r.binding, {
+			seat: t,
+			...r
+		};
+	}, [
 		s,
-		c
+		c,
+		l,
+		u,
+		d,
+		f,
+		p,
+		o
 	]);
-	return t(() => () => l.release(), [l]), l;
+	return r(() => (t(m.seat, m.binding), () => m.binding.drop()), [m]), m.rig;
 }
 //#endregion
-export { r as useRig };
+export { a as useRig, o as useSeatedRig };
 
 //# sourceMappingURL=useRig.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"useRig.js","names":["useRig","options","rig","useMemo","bindRig","scene","skeleton","bindings","apply","descriptor","useEffect"],"sources":["../../../src/animation/rig/useRig.ts"],"sourcesContent":["import { useEffect, useMemo } from 'react';\nimport { bindRig, type BindRigOptions, type Rig } from './bindRig';\n\n/**\n * A {@link Rig} bound for the component's lifetime, its overrides dropped on\n * unmount. Rebinds — re-reading every node's rest pose — whenever an option's\n * identity changes, so hoist or memoize `skeleton` and `bindings`.\n */\nexport function useRig<TPose>(options: BindRigOptions<TPose>): Rig {\n  const { scene, skeleton, bindings, apply, descriptor } = options;\n  const rig = useMemo(\n    () => bindRig({ scene, skeleton, bindings, apply, descriptor }),\n    [scene, skeleton, bindings, apply, descriptor],\n  );\n  useEffect(() => () => rig.release(), [rig]);\n  return rig;\n}\n"],"mappings":";;;AAQA,SAAgBA,EAAc,GAAqC;CACjE,IAAM,EAAE,UAAO,aAAU,aAAU,UAAO,kBAAeC,GACnDC,IAAMC,QACJC,EAAQ;EAAE;EAAO;EAAU;EAAU;EAAO;CAAW,CAAC,GAC9D;EAACC;EAAOC;EAAUC;EAAUC;EAAOC;CAAU,CAC/C;CAEA,OADAC,cAAsBR,EAAI,QAAQ,GAAG,CAACA,CAAG,CAAC,GACnCA;AACT"}
+{"version":3,"file":"useRig.js","names":["useRig","useSeatedRig","options","made","useMemo","seat","kept","createRigSeat","skeleton","bound","bindRigOn","scene","bindings","skins","restPath","apply","descriptor","useEffect","seatBinding"],"sources":["../../../src/animation/rig/useRig.ts"],"sourcesContent":["import { useEffect, useMemo } from 'react';\nimport { bindRigOn, type BindRigOptions, type Rig } from './bindRig';\nimport { createRigSeat, seatBinding, type RigSeat } from './rigSeat';\n\n/**\n * A {@link Rig} bound for the component's lifetime, its overrides dropped on\n * unmount. Rebinds — re-reading every node's rest pose — whenever an option's\n * identity changes, so hoist or memoize `skeleton`, `bindings`, and `skins`.\n */\nexport function useRig<TPose>(options: BindRigOptions<TPose>): Rig {\n  return useSeatedRig(options, null);\n}\n\n/** {@link useRig} on a seat that outlives a rebind; `null` makes a seat for each binding. */\nexport function useSeatedRig<TPose>(options: BindRigOptions<TPose>, kept: RigSeat | null): Rig {\n  const { scene, skeleton, bindings, skins, restPath, apply, descriptor } = options;\n  const made = useMemo(() => {\n    const seat = kept ?? createRigSeat(skeleton);\n    const bound = bindRigOn({ scene, skeleton, bindings, skins, restPath, apply, descriptor }, seat);\n    seat.binding ??= bound.binding;\n    return { seat, ...bound };\n  }, [scene, skeleton, bindings, skins, restPath, apply, descriptor, kept]);\n  useEffect(() => {\n    seatBinding(made.seat, made.binding);\n    return () => made.binding.drop();\n  }, [made]);\n  return made.rig;\n}\n"],"mappings":";;;;AASA,SAAgBA,EAAc,GAAqC;CACjE,OAAOC,EAAaC,GAAS,IAAI;AACnC;AAGA,SAAgBD,EAAoB,GAAgC,GAA2B;CAC7F,IAAM,EAAE,UAAO,aAAU,aAAU,UAAO,aAAU,UAAO,kBAAeC,GACpEC,IAAOC,QAAc;EACzB,IAAMC,IAAOC,KAAQC,EAAcC,CAAQ,GACrCC,IAAQC,EAAU;GAAE;GAAO;GAAU;GAAU;GAAO;GAAU;GAAO;EAAW,GAAGL,CAAI;EAE/F,OADA,EAAK,YAAYI,EAAM,SAChB;GAAE;GAAM,GAAGA;EAAM;CAC1B,GAAG;EAACE;EAAOH;EAAUI;EAAUC;EAAOC;EAAUC;EAAOC;EAAYV;CAAI,CAAC;CAKxE,OAJAW,SACEC,EAAYf,EAAK,MAAMA,EAAK,OAAO,SACtBA,EAAK,QAAQ,KAAK,IAC9B,CAACA,CAAI,CAAC,GACFA,EAAK;AACd"}

package/dist/animation/wrappers/animateLifecycle.js

@@ -1,40 +1,48 @@
 import { tweenPose as e } from "../poseHelpers.js";
+import { setPoseInstant as t } from "./instantPose.js";
 //#region src/animation/wrappers/animateLifecycle.ts
-function t(t, n, r) {
-	let i = r.ms ?? 200;
+function n(n, r, i) {
+	let a = i.ms ?? 200, o = /* @__PURE__ */ new Set();
 	return {
-		...t,
-		insertNode(a, o) {
-			if (t.insertNode(a, o), !r.enterFrom) return;
-			let s = t.getPose(a.id), c = r.enterFrom(s);
-			t.setPose(a.id, c), e(n, t, {
-				id: a.id,
-				to: s,
-				ms: i,
-				easing: r.easing,
-				geometry: r.geometry,
+		...n,
+		insertNode(o, s) {
+			if (n.insertNode(o, s), !i.enterFrom) return;
+			let c = n.getPose(o.id), l = i.enterFrom(c);
+			n.poseTarget?.(o.id, i.geometry) || t(n, o.id, l), e(r, n, {
+				id: o.id,
+				from: l,
+				to: c,
+				ms: a,
+				easing: i.easing,
+				geometry: i.geometry,
 				recordOp: !1
 			});
 		},
-		removeNode(a) {
-			if (!r.exitTo) {
-				t.removeNode(a);
+		removeNode(t) {
+			if (!i.exitTo) {
+				n.removeNode(t);
 				return;
 			}
-			let o = t.getPose(a);
-			e(n, t, {
-				id: a,
-				to: r.exitTo(o),
-				ms: i,
-				easing: r.easing,
-				geometry: r.geometry,
+			if (o.has(t)) return;
+			o.add(t);
+			let s = () => {}, c = n.poseTarget?.(t, i.geometry), l = c?.committed(), u = () => {
+				o.delete(t) && (s(), c && c.commit(l), n.removeNode(t));
+			}, d = n.getPose(t), f = e(r, n, {
+				id: t,
+				to: i.exitTo(d),
+				ms: a,
+				easing: i.easing,
+				geometry: i.geometry,
 				recordOp: !1,
-				onDone: () => t.removeNode(a)
+				onDone: u
+			});
+			s = r.watch((e) => {
+				(e.type === "cancel" || e.type === "interrupt") && e.animation.id === f.id && u();
 			});
 		}
 	};
 }
 //#endregion
-export { t as animateLifecycle };
+export { n as animateLifecycle };
 
 //# sourceMappingURL=animateLifecycle.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"animateLifecycle.js","names":["animateLifecycle","ms","opts","adapter","object","index","final","start","tweenPose","animator","id","current"],"sources":["../../../src/animation/wrappers/animateLifecycle.ts"],"sourcesContent":["import { tweenPose } from '../poseHelpers';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport type { SceneAdapter } from 'core/adapters/types';\nimport type { Animator, EasingSpec } from '../types';\n\n/** How nodes enter and leave. `enterFrom` derives the pose a new node starts\n *  at, given where it belongs; `exitTo` derives the pose a departing node\n *  animates to before it is actually removed. Omit either to leave that\n *  transition instant. */\nexport interface LifecycleAnimation<TPose> {\n  /** Pose to animate the new object FROM at insert. */\n  enterFrom?: (final: TPose) => TPose;\n  /** Pose to animate the existing object TO at remove. */\n  exitTo?: (current: TPose) => TPose;\n  ms?: number;\n  easing?: EasingSpec;\n  geometry?: PoseDescriptor<TPose>;\n}\n\n/** Wrap an adapter so inserts and removals animate — the scene-graph\n *  equivalent of CSS enter/leave transitions. */\nexport function animateLifecycle<TNode extends { id: string; pose?: TPose }, TPose>(\n  adapter: SceneAdapter<TNode, TPose>,\n  animator: Animator,\n  opts: LifecycleAnimation<TPose>,\n): SceneAdapter<TNode, TPose> {\n  const ms = opts.ms ?? 200;\n\n  return {\n    ...adapter,\n    insertNode(object: TNode, index?: number): void {\n      adapter.insertNode(object, index);\n      if (!opts.enterFrom) return;\n      const final = adapter.getPose(object.id);\n      const start = opts.enterFrom(final);\n      adapter.setPose(object.id, start);\n      tweenPose(animator, adapter as never, {\n        id: object.id,\n        to: final,\n        ms,\n        easing: opts.easing,\n        geometry: opts.geometry,\n        recordOp: false,\n      });\n    },\n    removeNode(id: string): void {\n      if (!opts.exitTo) {\n        adapter.removeNode(id);\n        return;\n      }\n      const current = adapter.getPose(id);\n      tweenPose(animator, adapter as never, {\n        id,\n        to: opts.exitTo(current),\n        ms,\n        easing: opts.easing,\n        geometry: opts.geometry,\n        recordOp: false,\n        onDone: () => adapter.removeNode(id),\n      });\n    },\n  };\n}\n"],"mappings":";;AAqBA,SAAgBA,EACd,GACA,GACA,GAC4B;CAC5B,IAAMC,IAAKC,EAAK,MAAM;CAEtB,OAAO;EACL,GAAGC;EACH,WAAW,GAAe,GAAsB;GAE9C,IADAA,EAAQ,WAAWC,GAAQC,CAAK,GAC5B,CAACH,EAAK,WAAW;GACrB,IAAMI,IAAQH,EAAQ,QAAQC,EAAO,EAAE,GACjCG,IAAQL,EAAK,UAAUI,CAAK;GAElC,AADAH,EAAQ,QAAQC,EAAO,IAAIG,CAAK,GAChCC,EAAUC,GAAUN,GAAkB;IACpC,IAAIC,EAAO;IACX,IAAIE;IACJ;IACA,QAAQJ,EAAK;IACb,UAAUA,EAAK;IACf,UAAU;GACZ,CAAC;EACH;EACA,WAAW,GAAkB;GAC3B,IAAI,CAACA,EAAK,QAAQ;IAChB,EAAQ,WAAWQ,CAAE;IACrB;GACF;GACA,IAAMC,IAAUR,EAAQ,QAAQO,CAAE;GAClC,EAAUD,GAAUN,GAAkB;IACpC;IACA,IAAID,EAAK,OAAOS,CAAO;IACvB;IACA,QAAQT,EAAK;IACb,UAAUA,EAAK;IACf,UAAU;IACV,cAAcC,EAAQ,WAAWO,CAAE;GACrC,CAAC;EACH;CACF;AACF"}
+{"version":3,"file":"animateLifecycle.js","names":["animateLifecycle","ms","opts","leaving","adapter","object","index","final","start","setPoseInstant","tweenPose","animator","id","unwatch","target","home","remove","current","handle","event"],"sources":["../../../src/animation/wrappers/animateLifecycle.ts"],"sourcesContent":["import { tweenPose, type PoseAnimationAdapter } from '../poseHelpers';\nimport { setPoseInstant } from './instantPose';\nimport type { PoseDescriptor } from 'interactions/actions/resize/geometry';\nimport type { Animator, EasingSpec } from '@weasel-js/animator';\n\n/** How nodes enter and leave. `enterFrom` derives the pose a new node starts\n *  at, given where it belongs; `exitTo` derives the pose a departing node\n *  animates to before it is actually removed. Omit either to leave that\n *  transition instant. */\nexport interface LifecycleAnimation<TPose> {\n  /** Pose to animate the new object FROM at insert. */\n  enterFrom?: (final: TPose) => TPose;\n  /** Pose to animate the existing object TO at remove. */\n  exitTo?: (current: TPose) => TPose;\n  ms?: number;\n  easing?: EasingSpec;\n  geometry?: PoseDescriptor<TPose>;\n}\n\n/** The part of an adapter `animateLifecycle` reads and wraps. The adapter `sceneToAdapter` and\n *  `useSceneAdapter` build is one. */\nexport interface LifecycleAdapter<TNode extends { id: string }, TPose> extends PoseAnimationAdapter<TPose> {\n  insertNode(node: TNode, index?: number): void;\n  removeNode(id: string): void;\n}\n\n/** Wrap an adapter so inserts and removals animate — the scene-graph\n *  equivalent of CSS enter/leave transitions. The result is the adapter it\n *  was given, with `insertNode` and `removeNode` replaced. */\nexport function animateLifecycle<\n  TNode extends { id: string },\n  TPose,\n  A extends LifecycleAdapter<TNode, TPose> = LifecycleAdapter<TNode, TPose>,\n>(\n  adapter: A & LifecycleAdapter<TNode, TPose>,\n  animator: Animator,\n  opts: LifecycleAnimation<TPose>,\n): A {\n  const ms = opts.ms ?? 200;\n  const leaving = new Set<string>();\n\n  return {\n    ...adapter,\n    insertNode(object: TNode, index?: number): void {\n      adapter.insertNode(object, index);\n      if (!opts.enterFrom) return;\n      const final = adapter.getPose(object.id);\n      const start = opts.enterFrom(final);\n      // A pose target shows the start pose itself; without one it has to be written.\n      if (!adapter.poseTarget?.(object.id, opts.geometry)) setPoseInstant(adapter, object.id, start);\n      tweenPose(animator, adapter, {\n        id: object.id,\n        from: start,\n        to: final,\n        ms,\n        easing: opts.easing,\n        geometry: opts.geometry,\n        recordOp: false,\n      });\n    },\n    removeNode(id: string): void {\n      if (!opts.exitTo) {\n        adapter.removeNode(id);\n        return;\n      }\n      if (leaving.has(id)) return;\n      leaving.add(id);\n      let unwatch = (): void => {};\n      const target = adapter.poseTarget?.(id, opts.geometry);\n      const home = target?.committed();\n      const remove = (): void => {\n        if (!leaving.delete(id)) return;\n        unwatch();\n        // The exit pose was only for show: the node is removed as it stood, so undo restores that.\n        if (target) target.commit(home as TPose);\n        adapter.removeNode(id);\n      };\n      const current = adapter.getPose(id);\n      const handle = tweenPose(animator, adapter, {\n        id,\n        to: opts.exitTo(current),\n        ms,\n        easing: opts.easing,\n        geometry: opts.geometry,\n        recordOp: false,\n        onDone: remove,\n      });\n      // A canceled tween never calls onDone, and the node still has to go.\n      unwatch = animator.watch((event) => {\n        if ((event.type === 'cancel' || event.type === 'interrupt') && event.animation.id === handle.id) remove();\n      });\n    },\n  } as A;\n}\n"],"mappings":";;;AA6BA,SAAgBA,EAKd,GACA,GACA,GACG;CACH,IAAMC,IAAKC,EAAK,MAAM,KAChBC,oBAAU,IAAI,IAAY;CAEhC,OAAO;EACL,GAAGC;EACH,WAAW,GAAe,GAAsB;GAE9C,IADAA,EAAQ,WAAWC,GAAQC,CAAK,GAC5B,CAACJ,EAAK,WAAW;GACrB,IAAMK,IAAQH,EAAQ,QAAQC,EAAO,EAAE,GACjCG,IAAQN,EAAK,UAAUK,CAAK;GAGlC,AADKH,EAAQ,aAAaC,EAAO,IAAIH,EAAK,QAAQ,KAAGO,EAAeL,GAASC,EAAO,IAAIG,CAAK,GAC7FE,EAAUC,GAAUP,GAAS;IAC3B,IAAIC,EAAO;IACX,MAAMG;IACN,IAAID;IACJ;IACA,QAAQL,EAAK;IACb,UAAUA,EAAK;IACf,UAAU;GACZ,CAAC;EACH;EACA,WAAW,GAAkB;GAC3B,IAAI,CAACA,EAAK,QAAQ;IAChB,EAAQ,WAAWU,CAAE;IACrB;GACF;GACA,IAAIT,EAAQ,IAAIS,CAAE,GAAG;GACrB,EAAQ,IAAIA,CAAE;GACd,IAAIC,UAAsB,CAAC,GACrBC,IAASV,EAAQ,aAAaQ,GAAIV,EAAK,QAAQ,GAC/Ca,IAAOD,GAAQ,UAAU,GACzBE,UAAqB;IACzB,AAAKb,EAAQ,OAAOS,CAAE,MACtBC,EAAQ,GAEJC,KAAQA,EAAO,OAAOC,CAAa,GACvCX,EAAQ,WAAWQ,CAAE;GACvB,GACMK,IAAUb,EAAQ,QAAQQ,CAAE,GAC5BM,IAASR,EAAUC,GAAUP,GAAS;IAC1C;IACA,IAAIF,EAAK,OAAOe,CAAO;IACvB;IACA,QAAQf,EAAK;IACb,UAAUA,EAAK;IACf,UAAU;IACV,QAAQc;GACV,CAAC;GAED,IAAUL,EAAS,OAAO,MAAU;IAClC,CAAKQ,EAAM,SAAS,YAAYA,EAAM,SAAS,gBAAgBA,EAAM,UAAU,OAAOD,EAAO,MAAIF,EAAO;GAC1G,CAAC;EACH;CACF;AACF"}