cozyclay 3.0.2 → 3.1.0

package/src/motion3/qa/object-checks.js

@@ -1,6 +1,8 @@
 // QA of scene objects the spec carries (C3 and 7.1), as plain issues { kind, msg, frame, value,
 // limit } (frame indexes out.frames):
 //   GRAB     "<id>: hand 12.0 cm from it at grab", frame = grab, limit = checks.limits.grab
+//   CATCH    "<id> missed by 4.2 cm": a carry that takes it out of the air (a fall with v before the grab) is more than
+//            CATCH_GAP m from it at the grab (#816, catchObject)
 //            (default 0.03 m); the distance runs from the prop origin to the part boxes' surface
 //            at their scene pose (where the hand finds them). An object its visible channel shows
 //            only from grab on appears in the hand (a cigarette out of a pocket), and one grabbed
@@ -23,7 +25,7 @@ import { isCarried, propOrigin } from "../carried.js";
 import { objectBoxesAt, partsOf, spanOf, restingAt } from "../object-pose.js";
 import { add, sub, apply, dot, cross, len, dist, scale, norm } from "../compiler/math.js";
 
-const NEAR_SUPPORT = 3;
+const NEAR_SUPPORT = 3, CATCH_GAP = 0.03;
 
 const centre = b => add(b.pos, apply(b.R, [0, b.half[1], 0]));
 const col = (R, i) => [R[0][i], R[1][i], R[2][i]];
@@ -100,7 +102,10 @@ export function objectChecks(sk, out, spec) {
 		const [grab, release] = spanOf(out, o), k = spec.props?.[o.prop]?.hand, excused = new Set([`hand_${k}`, `farm_${k}`]);
 		if (o.grab !== undefined && grab > 0 && out.frames[grab - f0] && shownAt(out, o, grab - 1)) {
 			const gap = grabGap(out, id, grab);
-			if (gap > L.grab) push("GRAB", `${id}: hand ${(gap * 100).toFixed(1)} cm from it at grab`, grab - f0, gap, L.grab);
+			// a carry that takes a thing out of the air (a fall with v before its grab: catchObject) misses it: CATCH
+			const flying = [o.fall ?? []].flat().some(fl => Array.isArray(fl.v) && fl.at < grab);
+			if (flying && gap > CATCH_GAP) push("CATCH", `${id} missed by ${(gap * 100).toFixed(1)} cm`, grab - f0, gap, CATCH_GAP);
+			else if (!flying && gap > L.grab) push("GRAB", `${id}: hand ${(gap * 100).toFixed(1)} cm from it at grab`, grab - f0, gap, L.grab);
 		}
 		const support = o.grab !== undefined ? supportOf(out, id, grab) : null;
 		const nearSupport = f => Math.abs(f - grab) <= NEAR_SUPPORT || (o.release !== undefined && Math.abs(f - release) <= NEAR_SUPPORT);

package/src/motion3/qa/patch.js

@@ -6,6 +6,7 @@
 //   { path: "/fix/retime", value: true }                      set a spec path
 //   { path: "/anchors/cupHandle/p", delta: [dx, dy, dz] }     move a spec value by delta
 //   { channel: "root", f, delta, hold: true }                  move the body that stands at f
+//   { ops: userSpec => [{ op, path, value }] }                 the operations for the agent's spec (a second hand: load.js)
 // Each becomes g.patch = [{ op, path, value }] against opts.userSpec (the spec as the agent sent
 // it, use[] not expanded): a user key that sets the channel within f +-2 -> replace
 // /keys/<i>/set/<ch>; a standIdle stance moved sideways -> /use/<i>/args/at; otherwise add
@@ -131,7 +132,7 @@ function pathPatch(userSpec, fix) {
 
 /** The patch for one fix, or null when it does not apply mechanically or changes nothing. */
 function patchOf(fix, X, userSpec) {
-	const patch = fix.channel !== undefined ? channelPatch(X, userSpec, fix) : fix.path !== undefined ? pathPatch(userSpec, fix) : null;
+	const patch = fix.ops ? fix.ops(userSpec) : (fix.channel !== undefined ? channelPatch(X, userSpec, fix) : fix.path !== undefined ? pathPatch(userSpec, fix) : null);
 	if (!patch) return null;
 	try {
 		return JSON.stringify(applyPatch(userSpec, patch)) === JSON.stringify(userSpec) ? null : patch;

package/src/motion3/qa/spec-checks.js

@@ -11,6 +11,9 @@ import { sub, dot, norm, len } from "../compiler/math.js";
 import { carried } from "../compiler/limbs.js";
 import { resolveAnchor } from "../compiler/anchors.js";
 import { CAPSULES, segPoints, sdBox } from "./geometry.js";
+import { refDistance } from "../refs.js";
+import { seatsInHand } from "../seat.js";
+import { handOf } from "../object-pose.js";
 
 export function pointOf(out, f, ref) {
 	const { s, diag, c } = out.frames[f], [kind, rest] = ref.split(/:(.*)/s);
@@ -20,6 +23,19 @@ export function pointOf(out, f, ref) {
 	throw new Error(`MOTION_SPEC_INVALID: check point "${ref}"`);
 }
 
+/** The part a contact target "anchor:<name>" holds by when that anchor takes a grasp (its socket's owner, else its object), else null. */
+/** The carry on the grasp path (seat.js) the hand of prop point `ref` holds at absolute frame f, or null (#816). */
+function seatedIn(out, ref, f) {
+	const prop = /^prop:([^.]+)\./.exec(ref)?.[1], k = out.ctx.spec.props?.[prop]?.hand, { spec, scene } = out.ctx;
+	return k ? Object.keys(spec.objects ?? {}).find(id => seatsInHand(spec, spec.objects[id], scene, id) && handOf(out, id, f) === k) ?? null : null;
+}
+
+function graspPart(out, ref) {
+	const [kind, name] = ref.split(/:(.*)/s), a = kind === "anchor" ? out.ctx.spec.anchors?.[name] : null;
+	if (a?.kind !== "object" || !a.grasp) return null;
+	return out.ctx.sockets?.get(name)?.owner ?? a.object;
+}
+
 const active = (out, f, when) => (Array.isArray(when) ? f + (out.f0 ?? 0) >= when[0] && f + (out.f0 ?? 0) <= when[1] : when ? (out.frames[f].c[when] ?? 0) > 0.99 : true);
 
 function alongDir(out, f, along) {
@@ -35,7 +51,11 @@ export function specChecks(out, checks = {}) {
 		for (const k of checks.contacts ?? []) if (active(out, f, k.when)) {
 			const a = pointOf(out, f, k.point), b = pointOf(out, f, k.target);
 			if (!a || !b) continue;
-			const e = len(sub(a, b));
+			// on a grasp's anchor the fingers close on the held part wherever the grasp turned them round it: they are on it
+			// when they are on its surface (as goals' near on an object), not on one point of it (session 7f15b4ae: 0.4 cm
+			// on the cup, read as 5.3 cm from the anchor)
+			// and a hand that holds a thing resting in its palm (seat.js) has its fingers on that thing's surface
+			const held = graspPart(out, k.target) ?? seatedIn(out, k.point, f + (out.f0 ?? 0)), e = held ? refDistance(out, f, k.point, `object:${held}`) ?? len(sub(a, b)) : len(sub(a, b));
 			if (e > (k.tol ?? 0.01)) push("CONTACT", `${k.name}: ${(e * 100).toFixed(1)} cm apart`, f, e, k.tol ?? 0.01);
 		}
 		for (const k of checks.orient ?? []) if (active(out, f, k.when)) {

package/src/motion3/schema/fields.js

@@ -15,10 +15,10 @@ export const ANCHOR_FIELDS = { world: ["p"], body: ["p"], bone: ["bone", "offset
 export const PROP_FIELDS = ["hand", "origin", "points"];
 export const FIT_FIELDS = ["side", "anchor", "effector", "offset", "orient"];
 /** spec.objects[id]: a hinge or a carry (a body or a group id), see C3; carry keys: C14; a switch (any record, C15) moves nothing; a follow (any record, C16) rides a point of the body; a free entry (C17) moves by keys and falls. */
-export const OBJECT_FIELDS = { hinge: ["pivot", "axis", "channel"], carry: ["prop", "at", "along", "visible", "level", "grab", "release", "keys", "fall"], switch: ["visible", "level"],
+export const OBJECT_FIELDS = { hinge: ["pivot", "axis", "channel"], carry: ["prop", "at", "along", "visible", "level", "grab", "release", "keys", "fall", "grasp", "mass"], switch: ["visible", "level"],
 	follow: ["follow", "offset", "aim", "visible", "level"], free: ["keys", "fall", "visible", "level"] };
-/** One spec.objects[id].fall entry (C17): the frame it starts to fall, what it lands on, how much it bounces, whether it rolls to rest. */
-export const FALL_FIELDS = ["at", "onto", "bounce", "tumble"];
+/** One spec.objects[id].fall entry (C17): the frame it starts to fall, what it lands on, how much it bounces, whether it rolls to rest, the velocity it leaves with. */
+export const FALL_FIELDS = ["at", "onto", "bounce", "tumble", "v"];
 /** One spec.objects[id].keys entry (C14): the held object's world pose at frame f; aim (+ roll) in place of rot (C16). */
 export const OBJECT_KEY_FIELDS = ["f", "pos", "rot", "aim", "roll", "lean"];
 export const WALK_FIELDS = ["type", "f0", "steps", "step", "period", "swing", "halfWidth", "lift", "heading", "turnDistance", "pelvisHigh", "pelvisLow", "firstStep", "armSwing", "vary"];

package/src/motion3/schema/topics.js

@@ -48,7 +48,7 @@ export const EXAMPLES = {
 };
 
 const UNITS = `World metres, +Y up; ${CONVENTIONS.yaw}; the character's left is +X at yaw 0. Angles in degrees.`;
-const NO_JUMP = "Without at/along it keeps its grab-frame palm offset: no jump.";
+const NO_JUMP = "No at/along: it rests in the palm, fingers closed on it. Throw/catch: throwObject, catchObject.";
 /** The objects example's carry: a grip prop and the object it holds. */
 const CARRY = { props: EXAMPLES.objects.props, objects: { cup: EXAMPLES.objects.objects.cup } };
 
@@ -65,24 +65,25 @@ export const NOTES = {
 	anchors: ["An anchor is a named point a hand can go to: key w_<anchor>_l / w_<anchor>_r from 0 to 1 with armw_<side> 1 (the IK arm).",
 		"An anchor name may not end in _l or _r.", "object anchors (a body or a group; local in its own axes) follow the object where it is (hinges, carries): put the other hand on a carried object with one; the carrying hand's own anchor stays where it took it. prop anchors are a point of a prop the other hand holds.",
 		"segment with reach slides from t toward tMin until the arm reaches it.",
-		"An object anchor with grasp (power, pinch, hook, palm) takes the hand by a socket of its object and the compiler turns the hand: power and hook put the knuckle line along the socket's axis with the palm on it, pinch holds at the fingertips, palm presses flat on the nearest face. socket names one (object.grasp sockets the user or you stored, or a thin part by its id: a bar, a grip, a magazine); without it the socket nearest local, or the shoulder. Two hands on one carried object: each hand an object anchor with grasp on its part (a rifle's grip and magazine). reachGrip on such an anchor closes the fingers to the grasp. Never key the wrist for it; a wrist you key (wtwist/wflex) wins.",
+		"An object anchor with grasp (power, pinch, hook, palm) takes the hand by a socket of its object and the compiler turns the hand: power and hook put the knuckle line along the socket's axis with the palm on it, pinch holds at the fingertips, palm presses flat on the nearest face. socket names one (object.grasp sockets the user or you stored, or a thin part by its id: a bar, a grip, a magazine; a disc, a steering wheel, is its rim, held where nearest the shoulder, and the hand stays there as it moves); without it the socket nearest local, or the shoulder. Two hands on one carried object: each hand an object anchor with grasp on its part (a rifle's grip and magazine). reachGrip on such an anchor closes the fingers to the grasp. Never key the wrist for it; a wrist you key (wtwist/wflex) wins.",
 		"person { person: <character id>, bone, offset? } is another character's joint where its installed take has it that frame (a hand on a shoulder, a push on the chest): install that character's take first; reachGrip on it allows the hand to touch that person."],
 	props: ["A prop is a set of points fixed to one hand, [d, l, n] along the palm axes; prop:<prop>.origin is the mean of its origin bones.",
 		"fits: the hand target moves so the effector (a prop point or the mean of joints), not the wrist, lands on the anchor.",
 		"A fit on a scene body also turns the hand about the forearm into a grip: a thin body (a can, a bar, a handle, a neck) across the palm, else thumb up; never past a comfortable forearm turn. A wrist you turn (wtwist/wflex) wins; fit.orient: false (reachGrip args.orient: false) turns it off.",
-		"reachGrip adds props.<anchor>Grip and its fit. Carry a scene object with objects.<id>.prop (topic objects)."],
+		"reachGrip adds props.<anchor>Grip and its fit. Carry a scene object with objects.<id>.prop (topic objects).",
+		"Do not pin a carried thing on a knuckle point: without at/along it rests in the palm and the fingers close on it (fix.grasp). objects.<id>.grasp names how: power, pinch, hook, palm, spherical (a ball). objects.<id>.mass (kg) weighs on the arm; past one hand QA says LOAD and patches in the other hand."],
 	objects: ["A hinge turns the object (a body or a group) about pivot/axis by the angle channel your keys set (degrees).",
 		"A carry follows the prop's hand: before grab the scene pose, grab..release in the hand, after release where it was let go, riding a body under it that keys or a hinge move.",
-		`No grab: in hand from frame 0; no release: to the end. ${NO_JUMP}`,
+		"No grab: in hand from frame 0; no release: to the end. No at/along: it rests in the palm, fingers closed on it.",
 		"A group (Empty) id moves all its parts; at/along pin a group's root to the palm too (an object.createKit kit). A carried object is an obstacle for the body and the scene.",
 		"A switch { visible?, level? } (no prop, no hinge field) moves nothing: it shows or hides any record (a part, a light, an effect) and sets its level, 0..4 light, glow and effect strength "
 			+ "(an unkeyed level reads 1). Hiding a group hides its parts. A carry takes level too.",
-		"keys pose a carried object in the world while it is in hand (grab <= f <= release): pos is its base (a group: its root), rot a quaternion [x, y, z, w], "
-			+ "or aim [x, y, z] the direction its +Y points (a bat's barrel), turned from how the hand holds it there, plus roll degrees about aim; no roll: the roll the arm holds most easily. "
-			+ `The object leads and the whole arm follows (the elbow swings, the forearm turns, the wrist adds the rest within ${Object.entries(WRIST_LIMITS).map(([k, [lo, hi]]) => `${k} ${lo}..${hi}`).join(", ")} deg; dev + toward the thumb); `
+		"keys pose a carried object in the world while in hand: pos its base (a group: its root), rot a quaternion [x, y, z, w], "
+			+ "or aim [x, y, z] where its +Y points (a bat's barrel) plus roll degrees about it (none: the roll the arm holds most easily). "
+			+ `The object leads and the arm follows (elbow, forearm, then the wrist within ${Object.entries(WRIST_LIMITS).map(([k, [lo, hi]]) => `${k} ${lo}..${hi}`).join(", ")} deg; dev + toward the thumb); `
 			+ "a left hand on a prop anchor of it turns with it; "
-			+ `the hand eases in and out over ${KEY_BLEND} frames. A REACH group "<id>: n cm off its keys" is what the hand could not reach; `
-			+ "output.observations.held measures every key as drawn (deg off the asked +Y, cm off pos, the drawn +Y, the rot an aim key used).",
+			+ `the hand eases in and out over ${KEY_BLEND} frames. REACH "<id>: n cm off its keys" is what the hand could not reach; `
+			+ "observations.held measures each key as drawn.",
 		"free { keys?, fall? } moves what nobody holds: keys at any frame; fall drops it at frame at onto the still top below (onto: that one; else the floor) "
 			+ "to rest on a stable face, one small bounce (0: none). A carry falls before grab or after release.",
 		"A follow { follow: <ref>, offset?, aim?, visible?, level? } puts any record (an effect, a light, a part) on a body point every frame: "
@@ -109,6 +110,6 @@ export const NOTES = {
 		"object:<id> takes a body or a group (the box around its parts); in a distance a bare object:<id> means its surface.",
 		"Goals and probes take every kind; spec.checks keep joint:, prop: and anchor:."],
 	fix: [`spec.fix keys: ${FIX_KEYS.join(", ")}; false turns all off. output.fixed reports what each one changed.`,
-		"reach, slide and self are on by default; penetration and retime are opt-in.",
+		"reach, slide, self and stance are on by default; penetration and retime are opt-in.",
 		"self keeps the arms out of the body on its fitted skin (QA BODY measures the same skin): wrist targets inside it go onto it, elbows turn about the shoulder-wrist line, a hand a little inside is pushed out. A fit's target (the mouth) is never moved; what is left is BODY, with checks.allow { part, object: <body part>, depth } for a contact meant to touch (a hand on a knee)."],
 };

package/src/motion3/schema/types.js

@@ -86,7 +86,8 @@ export const FIT_TYPES = {
 const OBJECT_KEY_TYPES = { f: int(), pos: ref("vec3"), rot: { type: "array", items: { type: "number" }, minItems: 4, maxItems: 4, description: "quat x, y, z, w" },
 	aim: ref("vec3", "or rot: +Y dir"), roll: num("deg about aim"), lean: num("aim tilt", { minimum: 0, maximum: 45 }) };
 
-const FALL = { type: "object", properties: { at: int(), onto: str(), bounce: num(null, { default: 0.25, minimum: 0, maximum: 0.6 }), tumble: { type: "boolean" } }, required: ["at"], additionalProperties: false };
+const FALL = { type: "object", properties: { at: int(), onto: str(), bounce: num(null, { default: 0.25, minimum: 0, maximum: 0.6 }), tumble: { type: "boolean" },
+	v: { oneOf: [{ $ref: "#/$defs/vec3" }, { const: "hand" }], description: "m/s" } }, required: ["at"], additionalProperties: false };
 /** A free entry's keys and fall (C17) are a carry's, at any frame: said once, not twice. */
 const AS_CARRY = { description: "as carry; keys at any frame" };
 export const FREE_TYPES = { keys: AS_CARRY, fall: AS_CARRY };
@@ -98,6 +99,7 @@ export const OBJECT_TYPES = {
 	keys: { type: "array", items: { type: "object", properties: Object.fromEntries(OBJECT_KEY_FIELDS.map(f => [f, OBJECT_KEY_TYPES[f]])), required: ["f", "pos"], additionalProperties: false },
 		description: "world pose at f; hand follows" },
 	fall: { ...FALL, description: "or a list; topic objects" },
+	grasp: { enum: GRASPS }, mass: num("kg", { minimum: 0.01, maximum: 60 }),
 	follow: ref("ref"), offset: ref("vec3"), aim: { oneOf: [{ enum: ["face", "up"] }, { $ref: "#/$defs/vec3" }, { $ref: "#/$defs/ref" }], default: "up" },
 };
 
@@ -140,6 +142,8 @@ export const FIX_TYPES = {
 	penetration: { oneOf: [{ type: "boolean" }, { type: "number", minimum: 0, maximum: 0.05 }], default: 0, description: "push hands out of boxes up to this depth, m (true = 0.02)" },
 	self: bool("arms kept out of the body's skin (wrists, elbows)", { default: true }),
 	retime: bool("speed spikes borrow frames from the neighbouring keys", { default: false }),
+	stance: bool("a standIdle stance in a scene body slides out of it (observations.placed)", { default: true }),
+	grasp: bool("fingers close on what the hand holds; it rests in the hand", { default: true }),
 };
 
 export const REF_DOCS = {

package/src/motion3/seat.js

@@ -0,0 +1,84 @@
+// A carried object rests in the hand that holds it (#816). Without at/along it kept the transform it had against the
+// prop origin, the finger middles, at the grab frame: session 7f15b4ae's ball rode 2.4 cm off them, the index and middle
+// 3 cm inside it, and closing the fingers would move that origin with them. On the grasp path (a carry with no at/along,
+// or naming a carry grasp) with fix.grasp on:
+//   frame  the palm frame stands on the Hand bone: the prop origin where the bind pose has it against the hand, so
+//          closing fingers move nothing they hold (carried.js carriedPose `fixed`)
+//   seat   the grab-frame offset slides along the palm normal until the palm and the knuckles just touch the object
+//          (their skin TOUCH m off it): found once per offset by bisection on the bind hand, no frame is solved for it
+//   settle over SETTLE frames from the grab the object eases from where it rests into its seat (smoothstep)
+import { add, sub, scale, apply, T } from "./compiler/math.js";
+import { restState } from "./compiler/skeleton.js";
+import { SIDES } from "./compiler/pose.js";
+import { carriedPose, compose, relative } from "./carried.js";
+import { capsuleDepth, shapeOf } from "./shapes.js";
+
+const TOUCH = 0.002, PALM = 0.022, KNUCKLE = 0.012, NEAR = 0.04, FAR = 0.15, STEPS = 12;
+export const SETTLE = 4;
+
+/**
+ * True when carry entry o of body or group `id` rests in its hand: grasp physics on, and a carry grasp named, or no pinned
+ * at/along on one round body (a ball, a can: shapes.js). A box or a kit carried without a grasp keeps its grab-frame offset
+ * (a lantern hangs from its handle; sliding it onto the palm would push it off the fingers).
+ */
+export const seatsInHand = (spec, o, scene, id) => spec?.fix !== false && spec?.fix?.grasp !== false && !!o?.prop
+	&& (o.grasp !== undefined || (o.at === undefined && o.along === undefined && roundBody(scene, id)));
+function roundBody(scene, id) {
+	const parts = Object.entries(scene?.objects ?? {}).filter(([k, e]) => k === id || e.ancestors?.includes(id));
+	return parts.length === 1 && shapeOf(parts[0][1]).kind !== "box";
+}
+
+const seats = new WeakMap();
+
+/**
+ * The offset (in the palm frame of carry o's prop) that seats body or group `id` against the palm: `offset` moved along
+ * the palm normal until the palm (Hand to Middle1) and the knuckles (Index1 to Pinky1) touch it from outside.
+ */
+export function seatOffset(sk, spec, scene, id, o, offset) {
+	if (!seats.has(scene)) seats.set(scene, new Map());
+	const cache = seats.get(scene), key = `${id}|${o.prop}|${offset.pos.map(v => v.toFixed(6)).join(",")}`;
+	if (cache.has(key)) return cache.get(key);
+	const prop = spec.props[o.prop], side = SIDES[prop.hand], s0 = restState(sk), frame = carriedPose(sk, spec, s0, { prop: o.prop }, true);
+	const local = p => apply(T(frame.R), sub(p, frame.pos)), J = n => local(s0.P[sk.index[`${side}${n}`]]);
+	const hand = [[J("Hand"), J("HandMiddle1"), PALM], [J("HandIndex1"), J("HandPinky1"), KNUCKLE]];
+	const root = restOf(scene, id), parts = Object.entries(scene.objects).filter(([k, e]) => k === id || e.ancestors?.includes(id));
+	// slide along the palm normal (the frame's y column): out of the hand when the object is in it, in toward it when it
+	// floats off it, whichever way the depth falls; stop where the skin is TOUCH off it
+	const y = [0, 1, 0], depthAt = u => {
+		const at = { pos: add(offset.pos, scale(y, u)), R: offset.R };
+		let d = -Infinity;
+		for (const [, e] of parts) {
+			const entry = { ...e, ...compose(at, relative(root, e)) };
+			for (const [a, b, r] of hand) d = Math.max(d, capsuleDepth(entry, a, b, r));
+		}
+		return d;
+	};
+	// out of the hand is the palm's side: -n on the right hand, +n on the left (limbs.js palmAxes), the frame's y column n
+	const d0 = depthAt(0), outward = prop.hand === "l" ? 1 : -1, inside = d0 > -TOUCH;
+	// inside: the answer lies outward within FAR; floating: inward within NEAR (never past the touch)
+	let lo = 0, hi = inside ? FAR : NEAR;
+	const sign = inside ? outward : -outward;
+	if (inside || depthAt(sign * hi) > -TOUCH) {
+		for (let i = 0; i < STEPS; i++) { const mid = (lo + hi) / 2; if ((depthAt(sign * mid) > -TOUCH) === inside) lo = mid; else hi = mid; }
+	} else lo = 0;
+	const seated = { pos: add(offset.pos, scale(y, sign * (inside ? hi : lo))), R: offset.R };
+	cache.set(key, seated);
+	return seated;
+}
+
+/** The rest pose { pos, R } of a body or a group root (a group: its parts' ancestor pose). */
+export function restOf(scene, id) {
+	const e = scene.objects[id];
+	if (e) return { pos: e.pos, R: e.R };
+	const g = Object.values(scene.objects).find(x => x.ancestors?.[0] === id);
+	return g?.ancestorPoses?.[0] ?? { pos: [0, 0, 0], R: [[1, 0, 0], [0, 1, 0], [0, 0, 1]] };
+}
+
+/** How far into its seat a carried object is at absolute frame f (0 at the grab, 1 from SETTLE frames on). */
+export function settleAt(grab, f) {
+	const t = Math.min(1, Math.max(0, (f - grab) / SETTLE));
+	return t * t * (3 - 2 * t);
+}
+
+/** The world pose between `from` and `to` (same turn: the seat only slides), t of the way. */
+export const between = (from, to, t) => ({ pos: add(from.pos, scale(sub(to.pos, from.pos), t)), R: to.R });

package/src/motion3/settle.js

@@ -10,6 +10,7 @@
 // pivot on the support, paced by gravity: closed form and deterministic.
 import { add, sub, scale, dot, cross, len, norm, mul, apply, axisRot, clamp } from "./compiler/math.js";
 import { G } from "./free-motion.js";
+import { flightTime } from "./flight.js";
 
 /** The share of the drop height a landing spends tipping the object over an edge. */
 export const TIP = 0.3;
@@ -54,17 +55,21 @@ export function spinOf(Ra, Rb, fps) {
 	return len(axis) > 0 ? scale(axis, rate) : [0, 0, 0];
 }
 
-/** The fall through the air from `start` onto the support top: { tl (s), at(t) } with the centre on a parabola, turning at `spin`. */
-export function airPath(s, start, spin, top, fps) {
-	const rate = len(spin), com0 = world(start, s.com);
+/**
+ * The fall through the air from `start` onto the support top: { tl (s), at(t) } with the centre on a parabola, turning at
+ * `spin`, leaving at v0 m/s (a throw, flight.js; zero: straight down, as before).
+ */
+export function airPath(s, start, spin, top, fps, v0 = [0, 0, 0]) {
+	const rate = len(spin), com0 = world(start, s.com), still = !v0.some(v => v !== 0);
 	const at = t => {
 		const R = rate > 0 ? mul(axisRot(spin, deg(rate * t)), start.R) : start.R;
-		return { pos: sub(add(com0, [0, -0.5 * G * t * t, 0]), apply(R, s.com)), R };
+		const fall = still ? [0, -0.5 * G * t * t, 0] : [v0[0] * t, v0[1] * t - 0.5 * G * t * t, v0[2] * t];
+		return { pos: sub(add(com0, fall), apply(R, s.com)), R };
 	};
 	const h = Math.max(0, lowest(s, start) - top);
-	if (rate === 0) return { tl: Math.sqrt((2 * h) / G), at };
+	if (rate === 0) return { tl: still ? Math.sqrt((2 * h) / G) : flightTime(h, v0[1], G), at };
 	// spinning: the first sub-frame step whose lowest corner reaches the top, then halved down to the touch
-	const dt = 1 / (fps * 8), cap = Math.sqrt((2 * (h + len(sub(s.hi, s.lo)))) / G) + dt;
+	const dt = 1 / (fps * 8), cap = (still ? Math.sqrt((2 * (h + len(sub(s.hi, s.lo)))) / G) : flightTime(h + len(sub(s.hi, s.lo)), v0[1], G)) + dt;
 	let a = 0, b = dt;
 	while (b < cap && lowest(s, at(b)) > top) { a = b; b += dt; }
 	for (let i = 0; i < 24 && b - a > 1e-7; i++) { const m = (a + b) / 2; if (lowest(s, at(m)) > top) a = m; else b = m; }

package/src/motion3/shapes.js

@@ -0,0 +1,70 @@
+// The shape of a motion-scene entry to a hand (#816): a sphere and a cylinder are round, not the box they sit in. A
+// 7.4 cm ball in its box is off by up to 30% of its radius at the corners, so fingers closing on the box would stop in
+// the air. The shape is derived from what every entry already carries (renderer, half: scene.js), so no field is added
+// to an entry and a saved take source, which keeps whole entries, reads the same shapes. DOM-free: the compile worker
+// runs it. Everything else (GRAB, COLLIDE, landing) keeps the oriented box.
+//   sphere    renderer "sphere" whose three halves agree within EVEN: r = their mean (an uneven one is an ellipsoid:
+//             its box)
+//   cylinder  renderer "cylinder": its axis along the entry's local +Y, r the smaller cross half, h = 2 half[1]
+//   box       anything else: the oriented box on the base pivot (qa/geometry.js sdBox)
+// An entry's pos is its base pivot (the bottom centre); its centre is pos + R [0, half[1], 0].
+import { add, sub, scale, len, apply, T } from "./compiler/math.js";
+import { sdBox, boxNormal, segPoints } from "./qa/geometry.js";
+
+const EVEN = 0.05;
+
+/** { kind: "sphere", r } | { kind: "cylinder", r, h } | { kind: "box" } of a motion-scene entry. */
+export function shapeOf(entry) {
+	const h = entry?.half;
+	if (!h) return { kind: "box" };
+	if (entry.renderer === "sphere") {
+		const r = (h[0] + h[1] + h[2]) / 3;
+		return Math.max(...h) - Math.min(...h) <= EVEN * r ? { kind: "sphere", r } : { kind: "box" };
+	}
+	if (entry.renderer === "cylinder") return { kind: "cylinder", r: Math.min(h[0], h[2]), h: 2 * h[1] };
+	return { kind: "box" };
+}
+
+const local = (entry, p) => { const q = apply(T(entry.R), sub(p, entry.pos)); q[1] -= entry.half[1]; return q; };
+const centre = entry => add(entry.pos, apply(entry.R, [0, entry.half[1], 0]));
+
+/** Signed distance (m) from p to the entry's shape: negative inside. */
+export function signedDistance(entry, p) {
+	const s = shapeOf(entry);
+	if (s.kind === "sphere") return len(sub(p, centre(entry))) - s.r;
+	if (s.kind === "cylinder") {
+		const q = local(entry, p), radial = Math.hypot(q[0], q[2]) - s.r, axial = Math.abs(q[1]) - s.h / 2;
+		return Math.hypot(Math.max(radial, 0), Math.max(axial, 0)) + Math.min(Math.max(radial, axial), 0);
+	}
+	return sdBox(p, entry);
+}
+
+/** Outward unit normal of the entry's shape at p (the nearest surface's from inside). */
+export function normalAt(entry, p) {
+	const s = shapeOf(entry);
+	if (s.kind === "sphere") { const d = sub(p, centre(entry)), l = len(d); return l > 1e-12 ? scale(d, 1 / l) : apply(entry.R, [0, 1, 0]); }
+	if (s.kind === "cylinder") {
+		const q = local(entry, p), rq = Math.hypot(q[0], q[2]), radial = rq - s.r, axial = Math.abs(q[1]) - s.h / 2;
+		const out = rq > 1e-12 ? [q[0] / rq, 0, q[2] / rq] : [1, 0, 0], cap = [0, Math.sign(q[1]) || 1, 0];
+		let n;
+		if (radial <= 0 && axial <= 0) n = radial > axial ? out : cap;
+		else n = add(scale(out, Math.max(radial, 0)), scale(cap, Math.max(axial, 0)));
+		const l = len(n);
+		return apply(entry.R, l > 1e-12 ? scale(n, 1 / l) : out);
+	}
+	return boxNormal(p, entry);
+}
+
+export function closestPoint(entry, p) {
+	return sub(p, scale(normalAt(entry, p), signedDistance(entry, p)));
+}
+
+/**
+ * How far a capsule (segment a-b, `radius` m) goes into the entry's shape, m: positive is the depth of its skin inside,
+ * negative the gap between its skin and the surface. Sampled on the segment as the QA capsules are (segPoints).
+ */
+export function capsuleDepth(entry, a, b, radius) {
+	let depth = -Infinity;
+	for (const p of segPoints(a, b)) depth = Math.max(depth, radius - signedDistance(entry, p));
+	return depth;
+}

package/src/motion3/skills/basic.js

@@ -5,22 +5,36 @@ import { walk } from "../compiler/walk.js";
 import { keyBook, skillError } from "./book.js";
 import { walkEnd } from "./info.js";
 import { GRASP_FINGERS, GRASP_POINTS } from "../compiler/vocab.js";
+import { clearStance, reachStance } from "./stance.js";
+import { CLOSE, GAZE, gazeAt, headKeyed, earlyTransport, holdsOpen, transportKeys } from "./reach-human.js";
 
 /** The fingers' point a reachGrip fits onto its anchor: the finger middles, or where a grasp holds the thing (the palm is -n on the right hand). */
 const graspPoint = (grasp, k) => (GRASP_POINTS[grasp] ? GRASP_POINTS[grasp].map((v, i) => (i === 2 && k === "r" ? -v : v)) : [0, 0, 0]);
 
-/** standIdle({ at: [x, z], heading = 0, until }): a neutral standing pose, arms down (FK). */
+/**
+ * standIdle({ at: [x, z], heading = 0, until }): a neutral standing pose, arms down (FK). Without `at` (and no root
+ * keyed) before a reachGrip it stands within that hand's reach of the anchor, facing it; a stance in a scene body
+ * slides out of it (stance.js). Either says so in `placed`.
+ */
 export function standIdle(ctx) {
 	const { sk, args, state } = ctx, I = sk.index, P = sk.restWorldPos, ank = P[I.LeftFoot][1];
-	const h = args.heading ?? state.yaw ?? 0, base = args.at ?? (state.root ? [state.root[0], state.root[2]] : null);
-	if (!base) skillError(ctx.tag, "needs args.at: [x, z] (no root is keyed before f0)");
+	let h = args.heading ?? state.yaw ?? 0, base = args.at ?? (state.root ? [state.root[0], state.root[2]] : null), placed = null;
+	if (!base) {
+		const auto = reachStance(ctx);
+		if (!auto) skillError(ctx.tag, "needs args.at: [x, z] (no root is keyed before f0), or a reachGrip after it to stand within reach of");
+		({ at: base, heading: h } = auto);
+		placed = { at: base, heading: h, why: `within reach of anchor ${auto.anchor}` };
+	} else if (args.at && ctx.place !== false) {
+		const out = clearStance(sk, ctx.scene, [base[0], base[base.length - 1]], h);
+		if (out) { base = out.at; placed = { at: base, heading: h, why: `moved ${out.moved} m out of a scene body` }; }
+	}
 	const c = [base[0], 0, base[base.length - 1]], R = ry(h), foot = v => { const p = add(c, apply(R, v)); p[1] = ank; return p; };
 	const set = { root: [c[0], P[I.Hips][1] - 0.01, c[2]], yaw: h, pitch: 0, roll: 0, spine_yaw: 0, spine_pitch: 0, spine_roll: 0, head_yaw: 0, head_pitch: 0,
 		foot_l: foot([0.09, 0, -0.03]), foot_r: foot([-0.09, 0, 0.03]), fyaw_l: h, fyaw_r: h, fpitch_l: 0, fpitch_r: 0, knee_l: [0.05, 0, 1], knee_r: [-0.05, 0, 1],
 		armw_l: 0, armw_r: 0, aswing_l: 0, aswing_r: 0, abend_l: 0, abend_r: 0, arm_hang: 1 };
 	const keys = [{ f: ctx.f0, set }];
 	if (args.until !== undefined) keys.push({ f: args.until, set: structuredClone(set) });
-	return { keys, end: args.until ?? ctx.f0 };
+	return { keys, end: args.until ?? ctx.f0, ...(placed ? { placed } : {}) };
 }
 
 /**
@@ -52,6 +66,23 @@ export function walkTo(ctx) {
 	return { keys, end };
 }
 
+/** base when `props` has no other prop of that name (the same one again is fine), else base_<side>, base_<side>2, ... */
+function freeName(props = {}, base, k, mine) {
+	const taken = n => props[n] && JSON.stringify(props[n]) !== JSON.stringify(mine);
+	if (!taken(base)) return base;
+	let name = `${base}_${k}`;
+	for (let i = 2; taken(name); i++) name = `${base}_${k}${i}`;
+	return name;
+}
+
+/** What a hand on `obj` may touch: the object, or for a group (an Empty, no body of its own) every part under it. */
+const touchable = (scene, obj) => {
+	const objects = scene?.objects ?? {};
+	if (!obj || objects[obj] || obj.startsWith("person:")) return obj ? [obj] : [];
+	const parts = Object.keys(objects).filter(k => objects[k].ancestors?.includes(obj));
+	return parts.length ? parts : [obj];
+};
+
 /**
  * reachGrip({ anchor, side, reach = 20, hold = 22, release = 12, elbow, fingers = "grip",
  * define, orient = true }): the hand goes to the anchor (defined elsewhere, or by `define`) over
@@ -67,23 +98,40 @@ export function reachGrip(ctx) {
 	// an anchor that takes a grasp closes the hand to that grasp's fingers (../sockets.js)
 	const grasp = (args.define ?? ctx.anchors?.[name])?.grasp, preset = args.fingers ?? GRASP_FINGERS[grasp] ?? "grip";
 	const w = `w_${name}_${k}`, fg = `fingers_${k}`, armw = `armw_${k}`, el = `elbow_${k}`, wasFk = !(state[armw] > 0.5);
-	// a take that ends after the hold but before the hand lets go cuts the release: the grip holds to the last frame
-	const last = ctx.frames - 1, cut = ctx.f0 + reach + hold <= last && ctx.f0 + reach + hold + release > last;
+	// a take that ends before the hand lets go cuts the hold or the release: the grip holds to the last frame (a hold
+	// asked past the end was refused, session 7f15b4ae: "needs 92 frames from f10 (to f102), past the last frame f85")
+	const last = ctx.frames - 1, cut = ctx.f0 + reach <= last && ctx.f0 + reach + hold + release > last;
+	const held = Math.min(reach + hold, last - ctx.f0);
 	for (const [c, v] of [[w, 0], [fg, { [preset]: 0 }], [armw, 0]]) if (state[c] === undefined) state[c] = v;
+	// the head looks at what the hand goes for unless the keys already move it (reach-human.js); read before the keys move state
+	// the reach's own view: a thing that spec.objects moves before the hand gets there is not at rest (reach-human.js)
+	const end = reach + hold + release, rc = { ...ctx, until: ctx.f0 + reach };
+	const look = !headKeyed(ctx.keys ?? [], ctx.f0, ctx.f0 + end) && gazeAt(rc, args.define ?? ctx.anchors?.[name], state);
+	const head = look ? { head_yaw: state.head_yaw ?? 0, head_pitch: state.head_pitch ?? 0 } : null;
 	const b = keyBook(state, ctx.f0);
-	b.hold(0, w, fg, armw, el);
+	b.hold(0, w, fg, armw, el, ...(look ? ["head_yaw", "head_pitch"] : []));
+	// the transport's early-peaked bell; on a thing the open hand clears, the fingers stay open to CLOSE of the reach, then close
+	// (a reach for a moving point, or below the knees, keeps the plain ease: reach-human.js earlyTransport)
+	const target = args.define ?? ctx.anchors?.[name], w0 = state[w], a0 = state[armw], lerp = (a, z, t) => a + (z - a) * t;
+	if (earlyTransport(rc, target)) for (const [f, t, ta] of transportKeys(reach)) b.at(f, { [w]: lerp(w0, 1, t), [armw]: lerp(a0, 1, ta) });
+	const close = Math.round(CLOSE * reach);
+	if (close > 0 && close < reach && holdsOpen(rc, target, state)) b.hold(close, fg);
+	if (look) b.at(Math.max(1, Math.round(GAZE * reach)), look);
 	b.at(reach, { [w]: 1, [fg]: { ...state[fg], [preset]: 1 }, [armw]: 1, ...(args.elbow ? { [el]: args.elbow } : {}) });
-	b.hold(reach + hold, w, fg, armw, el);
-	if (!cut) b.at(reach + hold + release, { [w]: 0, [fg]: { ...state[fg], [preset]: 0 }, ...(wasFk ? { [armw]: 0 } : {}) });
-	const S = k === "l" ? "Left" : "Right", prop = `${name}Grip`;
+	b.hold(held, w, fg, armw, el, ...(look ? ["head_yaw", "head_pitch"] : []));
+	if (!cut) b.at(end, { [w]: 0, [fg]: { ...state[fg], [preset]: 0 }, ...(wasFk ? { [armw]: 0 } : {}), ...(head ?? {}) });
+	// the fingers' prop is <anchor>Grip, unless the spec (or another skill) has a prop of that name of its own: its points
+	// would replace these (session 7f15b4ae: props.ballGrip for a carry broke reachGrip on anchor "ball")
+	const S = k === "l" ? "Left" : "Right", fingersProp = { hand: k, origin: [`${S}HandIndex2`, `${S}HandMiddle2`], points: { fingers: graspPoint(grasp, k) } };
+	const prop = freeName(ctx.props, `${name}Grip`, k, fingersProp);
 	const def = args.define ? { [name]: args.define } : {};
 	// the hand may touch what it grips: an object, or the other person (people.js) whose joint the anchor is on
 	const a = args.define ?? ctx.anchors?.[name], obj = a?.kind === "object" ? a.object : a?.kind === "person" ? `person:${a.person}` : null;
 	return {
-		keys: b.keys, end: cut ? last : ctx.f0 + reach + hold + release, ...(cut ? { cut: `release cut at f${last} (hold to the end)` } : {}), anchors: def,
-		props: { [prop]: { hand: k, origin: [`${S}HandIndex2`, `${S}HandMiddle2`], points: { fingers: graspPoint(grasp, k) } } },
+		keys: b.keys, end: cut ? last : ctx.f0 + reach + hold + release, ...(cut ? { cut: `${held < reach + hold ? "hold" : "release"} cut at f${last} (hold to the end)` } : {}), anchors: def,
+		props: { [prop]: fingersProp },
 		fits: [{ side: k, anchor: name, effector: { prop, point: "fingers" }, ...(args.orient === false ? { orient: false } : {}) }],
 		checks: { contacts: [{ name: `fingers on ${name}`, point: `prop:${prop}.fingers`, target: `anchor:${name}`, tol: 0.04, when: w }],
-			allow: obj ? [{ part: "hand", object: obj, depth: 0.04 }] : [] },
+			allow: touchable(ctx.scene, obj).map(object => ({ part: "hand", object, depth: 0.04 })) },
 	};
 }

package/src/motion3/skills/catch.js

@@ -0,0 +1,71 @@
+// catchObject: a hand meets a flying thing where it can reach and gives with it (#816). The thing flies as a free entry
+// does, objects.<id>.fall { at, v } from its pose at `at` (flight.js); the skill samples that flight and picks the first
+// frame its point is in front of the chest (FRONT m ahead, between the hips and the head) and SHELL m from the catching
+// shoulder, no earlier than the hand can get there from f0 (REACH frames). The open hand arrives ARRIVE frames before it,
+// the finger middles on the point (a fit on a world anchor there); the fingers close and the carry takes it at
+// that frame (fills: prop, grab, grasp), so it rests in the hand (seat.js) and the fingers close on it (finger-close.js).
+// Then the hand gives with it: along the incoming velocity by clamp(0.08 + 0.02 x mass x speed, 0.08, 0.15) m over ABSORB
+// frames, slowing to a stop, and eases back. side "both", or a thing over HEAVY kg, adds the left hand on its left side
+// along the same path (world anchors: the right hand holds the carry, the left meets it). A flight that never comes within
+// reach is refused, naming its nearest frame and point; a hand that comes too late (f0 past the reach) misses: QA CATCH.
+import { add, sub, scale, apply, ry, len, norm, dot } from "../compiler/math.js";
+import { freePoseAt } from "../free-motion.js";
+import { massOf } from "../mass.js";
+import { skillError } from "./book.js";
+import { transportKeys } from "./reach-human.js";
+
+const SHELL = [0.35, 0.65], FRONT = 0.15, REACH = 10, LONG = 20, ARRIVE = 2, ABSORB = 6, BACK = 8, HEAVY = 1;
+const r3 = v => v.map(x => Math.round(x * 1000) / 1000);
+const clamp = (x, a, b) => Math.min(b, Math.max(a, x));
+
+/** The shoulder of side S and the body's forward on the keyed root and yaw of state. */
+function bodyAt(sk, state, S) {
+	const P = sk.restWorldPos, hips = state.root ?? P[sk.index.Hips], R = ry(state.yaw ?? 0);
+	return { hips, shoulder: add(hips, apply(R, sub(P[sk.index[`${S}Arm`]], P[sk.index.Hips]))), head: add(hips, apply(R, sub(P[sk.index.Head], P[sk.index.Hips]))), fwd: apply(R, [0, 0, 1]) };
+}
+
+export function catchObject(ctx) {
+	const { args, state, sk, scene, tag } = ctx, id = args.object, side = args.side ?? "r", o = ctx.objects?.[id], fps = ctx.fps ?? 24;
+	if (side !== "r" && side !== "both") skillError(tag, `args.side must be "r" or "both", got ${JSON.stringify(side)}`);
+	const fall = Array.isArray(o?.fall) ? o.fall[0] : o?.fall;
+	if (!Array.isArray(fall?.v)) skillError(tag, `args.object "${id}" must fly: objects.${id}.fall { at, v: [vx, vy, vz] }`);
+	const body = bodyAt(sk, state, "Right"), flight = { spec: { objects: { [id]: { fall: o.fall } }, fps }, scene, timeMap: null };
+	const at = f => freePoseAt(flight, id, f)?.pos;
+	// the first frame of the flight in front of the chest within the shell around the shoulder; else the nearest one
+	let pick = null, near = null;
+	for (let f = fall.at + 1; f < ctx.frames; f++) {
+		const p = at(f), d = len(sub(p, body.shoulder)), ahead = dot(sub(p, body.hips), body.fwd), off = Math.max(0, SHELL[0] - d, d - SHELL[1], FRONT - ahead, body.hips[1] - 0.1 - p[1], p[1] - body.head[1]);
+		if (!near || off < near.off) near = { f, p, off };
+		if (off === 0) { pick = { f, p }; break; }
+	}
+	if (!pick) skillError(tag, `${id} never comes within reach of the right hand (in front of the chest, ${SHELL[0]}-${SHELL[1]} m from the shoulder): nearest at f${near.f}, [${r3(near.p).join(", ")}], ${near.off.toFixed(2)} m out; move the body (standIdle at) or the throw`);
+	// the hand needs REACH frames from f0: a later pick it would get to in time; else it comes late to where the thing was
+	const contact = Math.max(pick.f, ctx.f0 + REACH + ARRIVE), p = pick.p;
+	const incoming = scale(sub(at(pick.f), at(pick.f - 1)), fps), speed = len(incoming), mass = massOf({ objects: ctx.objects }, scene, id);
+	const give = clamp(0.08 + 0.02 * mass * speed, 0.08, 0.15), u = norm(incoming), ease = t => 1 - (1 - t) ** 3;
+	const path = [p, ...Array.from({ length: ABSORB }, (_, i) => add(p, scale(u, give * ease((i + 1) / ABSORB)))), add(p, scale(u, give * 0.4))];
+	const start = Math.max(ctx.f0, contact - ARRIVE - LONG), both = side === "both" || mass > HEAVY;
+	// the left hand (both hands, or a heavy thing) on its left side, its finger middles across the thing from the right's
+	const radius = Math.max(0, ...Object.values(scene.objects).filter(e => e === scene.objects[id] || e.ancestors?.includes(id)).map(e => Math.max(...e.half)));
+	const left = apply(ry(state.yaw ?? 0), [1, 0, 0]), part = { keys: [], end: contact + ABSORB + BACK, props: {}, anchors: {}, fits: [], channels: [],
+		fills: { [id]: { prop: `${id}Catch`, grab: contact, grasp: "spherical" } }, catch: { contact, point: r3(p), speed: Math.round(speed * 100) / 100, give: Math.round(give * 1000) / 1000, hands: both ? 2 : 1 } };
+	for (const k of both ? ["r", "l"] : ["r"]) {
+		const S = k === "l" ? "Left" : "Right", prop = k === "r" ? `${id}Catch` : `${id}CatchL`, off = k === "r" ? [0, 0, 0] : scale(left, 2 * radius + 0.04);
+		const armw = `armw_${k}`, fg = `fingers_${k}`, open = { ...state[fg], spherical: 0 }, shut = { ...state[fg], spherical: 1 };
+		// the finger middles (the prop's origin) on the point at the catch, then on each point of the give: world anchors
+		// with a fit each, the weight handed from one to the next frame by frame (the fits solve the hand onto them exactly)
+		const names = path.map((_, i) => `${prop}${i}`), w = i => `w_${names[i]}_${k}`;
+		part.keys.push(
+			// the elbow down and out (body axes), so it swings out round the side, not in across the body
+			{ f: start, set: { [armw]: state[armw] ?? 0, [w(0)]: 0, [fg]: open, [`elbow_${k}`]: k === "r" ? [-1, -0.5, -0.5] : [1, -0.5, -0.5] } },
+			// the reach's early-peaked transport, the arm's weight ahead of the aim's (reach-human.js; as reachGrip)
+			...transportKeys(contact - ARRIVE - start).map(([f, t, ta]) => ({ f: start + f, set: { [w(0)]: t, [armw]: (state[armw] ?? 0) + (1 - (state[armw] ?? 0)) * ta } })),
+			{ f: contact - ARRIVE, set: { [armw]: 1, [w(0)]: 1, [fg]: open } },
+			{ f: contact, set: { [w(0)]: 1, [fg]: shut } },
+			...path.slice(1).flatMap((_, j) => { const i = j + 1, f = i <= ABSORB ? contact + i : contact + ABSORB + BACK; return [{ f: i <= ABSORB ? f - 1 : contact + ABSORB, set: { [w(i - 1)]: 1, [w(i)]: 0 } }, { f, set: { [w(i - 1)]: 0, [w(i)]: 1 } }]; }),
+		);
+		part.props[prop] = { hand: k, origin: [`${S}HandIndex2`, `${S}HandMiddle2`], points: { fingers: [0, 0, 0] } };
+		names.forEach((n, i) => { part.anchors[n] = { kind: "world", p: r3(add(path[i], off)) }; part.fits.push({ side: k, anchor: n, effector: { prop, point: "fingers" } }); part.channels.push(w(i)); });
+	}
+	return part;
+}