cozyclay 3.0.1 → 3.0.3

package/src/motion3/compiler/validate-parts.js

@@ -1,7 +1,7 @@
 // Validation of the spec parts other than keys: anchors, props, fits, generators, checks and
 // fix; objects (validate-objects.js) and goals (validate-goals.js) run from here too. Unknown
 // fields go through opts.unknown, which ignores them on a lenient reload. See validate.js.
-import { didYouMean, suggestField, CONVENTIONS, isVec3, fmt } from "./vocab.js";
+import { didYouMean, suggestField, CONVENTIONS, isVec3, fmt, GRASPS } from "./vocab.js";
 import { FIX_KEYS } from "../fix/index.js";
 import { QA_LIMITS } from "../qa/checks.js";
 import { ANCHOR_FIELDS, PROP_FIELDS, FIT_FIELDS, WALK_FIELDS, CHECK_FIELDS, CHECK_ENTRY_FIELDS } from "../schema/fields.js";
@@ -9,6 +9,7 @@ import { boneOk, objectOk, refOk } from "./validate-common.js";
 import { validateObjects } from "./validate-objects.js";
 import { validateGoals } from "./validate-goals.js";
 import { personJoint, peopleList } from "../people.js";
+import { socketsOf, socketNamed } from "../sockets.js";
 
 const SIDE = new Set(["l", "r"]);
 const isObject = v => Boolean(v) && typeof v === "object" && !Array.isArray(v);
@@ -29,7 +30,11 @@ function validateAnchors(spec, err, { sk, scene, unknown = err }) {
 		if ((a.kind === "world" || a.kind === "body") && a.p === undefined) err(`${at} (${a.kind}) needs p: [x, y, z]${a.kind === "body" ? `, ${CONVENTIONS.pole}` : ""}`);
 		if (a.kind === "bone") boneOk(err, sk, at, a.bone);
 		if (a.kind === "segment") { boneOk(err, sk, `${at}.from`, a.from); boneOk(err, sk, `${at}.to`, a.to); if (a.reach !== undefined && !SIDE.has(a.reach)) err(`${at}.reach must be "l" or "r"`); }
-		if (a.kind === "object") objectOk(err, scene, at, a.object, { groups: true });
+		if (a.kind === "object" && objectOk(err, scene, at, a.object, { groups: true })) {
+			if (a.grasp !== undefined && !GRASPS.includes(a.grasp)) err(`${at}.grasp must be one of ${GRASPS.join(", ")}, got ${fmt(a.grasp)}`);
+			if (a.socket !== undefined && scene?.objects && !socketNamed(scene, a.object, a.socket)) err(`${at}.socket: "${a.object}" has no socket ${fmt(a.socket)} (sockets: ${socketsOf(scene, a.object).map(k => k.name).join(", ") || "none"})`);
+			if (a.socket !== undefined && a.grasp === undefined) err(`${at}.socket needs grasp (${GRASPS.join(", ")}): the socket says how the hand takes it`);
+		}
 		if (a.kind === "person" && !personJoint(scene, a.person, a.bone ?? "", 0)) err(`${at} (person) needs person: the id of another character with an installed take (people: ${peopleList(scene)}) and bone: one of its joints, got ${fmt(a.person)} ${fmt(a.bone)}`);
 		if (a.kind === "landmark" && a.name !== "mouth") err(`${at}: the only landmark is "mouth", got ${fmt(a.name)}`);
 		if (a.kind === "prop" && !spec.props?.[a.prop]?.points?.[a.point] && a.point !== "origin") err(`${at} needs prop point ${a.prop}.${a.point}, which spec.props does not define`);

package/src/motion3/compiler/vocab.js

@@ -11,6 +11,12 @@ export const MAP_CHANNELS = new Set(sided(["fingers"]));
 // Channels the skills key (standIdle, walks): valid in a spec, left out of motion.describe so a first spec need not read them.
 export const SKILL_CHANNELS = new Set(["arm_hang"]);
 export const FINGER_PRESETS = ["relaxed", "fist", "grip", "cigarette", "point"];
+/** The grasps an object anchor takes a hand by (../sockets.js), and the finger preset each closes the hand to by default. */
+export const GRASPS = ["power", "pinch", "hook", "palm"];
+export const GRASP_FINGERS = { power: "grip", pinch: "cigarette", hook: "grip", palm: "relaxed" };
+/** Where the held thing sits in the hand, [d, l, n] on the palm axes from the finger middles (n toward the palm; m): a bar in a
+ * power grip or a hook lies across the palm under the finger middles, a pinch is held at the fingertips, a flat palm presses with its centre. */
+export const GRASP_POINTS = { power: [0, 0, 0.02], hook: [0, 0, 0.02], pinch: [0.025, 0, 0.01], palm: [-0.045, 0, 0.015] };
 
 // [min, max, convention] for numeric channels whose values have a hard range.
 const RANGES = [

package/src/motion3/docs.js

@@ -22,6 +22,6 @@ export const MOTION_ACTION_HELP = {
 		+ "A carried object takes pos [x, y, z] and rot [x, y, z, w], or aim [x, y, z] (its +Y) and roll?: its base's world pose (a group: its root), grab..release only (objects.<id>.keys); the hand follows. "
 		+ "A hinge takes angle (degrees) or rot (its turn about the axis). remove: true deletes the key at frame. Refused where the take neither holds nor hinges it (drag it then). "
 		+ "Answers keyed and the motion.compile output; REACH \"<id>: n cm off its keys\": what the hand missed.",
-	report: "Page through the parts of a motion.compile or motion.qa answer that did not fit (output.more): part is groups (the default), timeline or probes, from the item index to start at; "
+	report: "Page through the parts of a motion.compile or motion.qa answer that did not fit (output.more): specId names the answer (or characterId: its installed take's); part is groups (the default), timeline or probes, from the item index to start at; "
 		+ "answers { specId, part, from, items, next } (next = the index to ask for next, null at the end). Changes nothing.",
 };

package/src/motion3/fix/index.js

@@ -14,6 +14,8 @@
 //   self         arms out of the rest of the body on its fitted skin: the elbow turns about the
 //                shoulder-wrist line, the hand is pushed out along the skin (self.js)
 //   retime       speed spikes get more frames, borrowed from the neighbouring keys
+//   stance       a standIdle stance whose legs, feet or hips are in a scene body slides out of it, the least
+//                distance (skills/stance.js; applied when the skills expand, reported in observations.placed)
 import { lowerHips, armReach } from "./reach.js";
 import { lockFeet } from "./slide.js";
 import { holdTurns } from "./turn.js";
@@ -22,14 +24,14 @@ import { pushOut } from "./push.js";
 import { retime } from "./retime.js";
 import { selfClear } from "./self.js";
 
-const FIX_KEYS = ["reach", "slide", "penetration", "self", "retime"];
+const FIX_KEYS = ["reach", "slide", "penetration", "self", "retime", "stance"];
 export { FIX_KEYS };
 
 export function fixOptions(fix) {
-	if (fix === false) return { reach: false, slide: false, penetration: 0, self: false, retime: false };
+	if (fix === false) return { reach: false, slide: false, penetration: 0, self: false, retime: false, stance: false };
 	const f = fix ?? {};
 	const pen = f.penetration === true ? 0.02 : Math.min(0.05, Math.max(0, Number(f.penetration) || 0));
-	return { reach: f.reach !== false, slide: f.slide !== false, penetration: pen, self: f.self !== false, retime: f.retime === true };
+	return { reach: f.reach !== false, slide: f.slide !== false, penetration: pen, self: f.self !== false, retime: f.retime === true, stance: f.stance !== false };
 }
 
 /** The slide report with the flat feet whose turn waited (turn.js): turns { frames, max deg }. */

package/src/motion3/free-motion.js

@@ -29,7 +29,9 @@ import { shapeOf, airPath, settlePath, settledAt, spinOf, spinEnergy, TIP } from
 export const G = 9.8;
 /** The highest a bounce goes, metres. */
 export const BOUNCE_MAX = 0.03;
-const BOUNCE = 0.25, TOUCH = 0.005;
+const BOUNCE = 0.25;
+/** A support's top may sit this far above the lowest point of what rests on it (m). */
+export const TOUCH = 0.005;
 const HELD_OR_HINGED = ["prop", "follow", "pivot", "axis", "channel"];
 
 /** A free entry (C17): no prop, follow or hinge field, and keys or fall. */
@@ -41,14 +43,14 @@ const restOf = (scene, id) => scene?.objects?.[id] ?? groupsOf(scene)[id] ?? nul
 const partsIn = (scene, id) => Object.keys(scene?.objects ?? {}).filter(k => k === id || scene.objects[k].ancestors?.includes(id));
 
 /** The 8 corners of a base-pivot box { pos, R, half }. */
-function corners(box) {
+export function corners(box) {
 	const out = [];
 	for (const x of [-1, 1]) for (const y of [0, 2]) for (const z of [-1, 1]) out.push(add(box.pos, apply(box.R, [x * box.half[0], y * box.half[1], z * box.half[2]])));
 	return out;
 }
-const topOf = box => Math.max(...corners(box).map(p => p[1]));
+export const topOf = box => Math.max(...corners(box).map(p => p[1]));
 /** True when the vertical through x/z point p crosses the footprint of box. */
-const under = (box, p) => { const q = apply(T(box.R), sub([p[0], box.pos[1] + box.half[1], p[2]], box.pos)); return Math.abs(q[0]) <= box.half[0] && Math.abs(q[2]) <= box.half[2]; };
+export const under = (box, p) => { const q = apply(T(box.R), sub([p[0], box.pos[1] + box.half[1], p[2]], box.pos)); return Math.abs(q[0]) <= box.half[0] && Math.abs(q[2]) <= box.half[2]; };
 
 /** Bodies a spec.objects entry moves (itself or a group above it): they hold nothing up. */
 function moversIn(spec, scene) {
@@ -195,6 +197,12 @@ export function afterRelease(ctx, id, o, f, release, releasePose, beforePose = n
 	return events.length ? walk(events, f, releasePose, plan, false) : null;
 }
 
+/** True when carry entry o falls at or after its release (absolute frame; afterRelease then moves it). */
+export function fallsAfter(ctx, o, release) {
+	const map = ctx.timeMap ?? (f => f);
+	return fallsOf(o).some(fl => map(fl.at) >= release);
+}
+
 /** The falls of entry `id` as planned under the current time map, for readers (timeline, tests): [{ t0, land, end, h, support, top }]. */
 export function fallPlans(ctx, id) {
 	const o = ctx.spec.objects?.[id];

package/src/motion3/object-keys.js

@@ -4,7 +4,8 @@
 //   between keys    a cubic Hermite on pos and the same in rotation-vector space on rot (squad
 //                   like), Catmull-Rom tangents through inner keys, zero at the first and last key
 //   around the span the hand blends from the plain carry into the keyed span over KEY_BLEND frames
-//                   (inside grab..release; smoothstep), so nothing jumps
+//                   (inside grab..release; smoothstep), so nothing jumps; keys that start within KEY_BLEND frames
+//                   of the grab with a grip off where the hand is turn the hand onto it before (holdHook approach)
 //   the object leads the hand: compile.js asks holdHook for the palm frame the keys put the grip
 //                   at, palm = key o attach^-1, and pose.js solves the hand to it (compiler/hold.js)
 // The object itself is still drawn in the hand (object-pose.js): the residual is what the arm
@@ -20,11 +21,14 @@ import { polePlan, smoothPath, smoothed } from "./hold-plan.js";
 import { secondGrip, secondHold, gripGate } from "./second-hand.js";
 import { SIDES } from "./compiler/pose.js";
 import { chooseGrip, between, thinBody } from "./grip-choice.js";
+import { graspedBy } from "./compiler/socket-grip.js";
 
 /** Frames over which the hand blends into and out of the keyed span. */
 export const KEY_BLEND = 8;
 // the frames a hand takes to turn into a chosen grip before its grab and out of it after its release (grip-choice.js)
 const GRAB_EASE = 12;
+// how far (m, deg) the grip keys put the hand on at the grab may be from where the reach brought it before the hand turns onto it first
+const OFF_GRIP = { m: 0.01, deg: 5 };
 
 const smooth = x => x * x * (3 - 2 * x);
 /** [grab, release] in absolute frames of `out` (object-pose.js spanOf, kept here to stay out of its import cycle). */
@@ -108,8 +112,8 @@ export function holdHook(ctx, out, solvePlain, solveLed) {
 	if (!held.length) return null;
 	const palmOf = (o, s) => carriedPose(sk, spec, s, { prop: o.prop }), attached = new WeakMap(), attaching = new Set();
 	const restAt = (id, f) => ctx.restingAt?.(id, f) ?? scene?.objects?.[id] ?? groupsOf(scene)[id];
-	// a keyed carry of a thin body (a cup, a can, a bar) whose grip is free (no at/along, no orient: false, no keyed wrist at
-	// the grab) keeps the grip its keyed path holds most comfortably (grip-choice.js), solved on the plain frames with the
+	// a keyed carry of a thin body (a cup, a can, a bar) whose grip is free (no at/along, no orient: false, no grasp fit, no keyed
+	// wrist at the grab) keeps the grip its keyed path holds most comfortably (grip-choice.js), solved on the plain frames with the
 	// body read at rest; a box keeps the grip grip.js gives it at the grab
 	const choices = new WeakMap(), mapped = f => (out.timeMap ? Math.round(out.timeMap(f)) : f);
 	// chosen once per compile (the first bake): the fixes' rebakes move the body a little, the carry's keys not at all
@@ -118,7 +122,7 @@ export function holdHook(ctx, out, solvePlain, solveLed) {
 		const cache = choices.get(out), o = spec.objects[id], k = spec.props?.[o.prop]?.hand, grab = spanIn(out, o)[0], b = out.baked ?? {};
 		if (cache.has(id)) return cache.get(id);
 		cache.set(id, null);
-		const free = k && o.at === undefined && o.along === undefined && (o.grab !== undefined || !scene?.objects?.[id]) && thinBody(scene, id) && !(spec.fits ?? []).some(fit => fit.side === k && fit.orient === false)
+		const free = k && o.at === undefined && o.along === undefined && (o.grab !== undefined || !scene?.objects?.[id]) && thinBody(scene, id) && !(spec.fits ?? []).some(fit => fit.side === k && fit.orient === false) && !graspedBy(spec, scene, id, k)
 			&& !["wtwist", "wflex"].some(ch => Math.abs(b[`${ch}_${k}`]?.[grab] ?? 0) > 1e-3)
 			// keys that start after the grab: the body rides the hand from where it rests, which only today's grip meets exactly
 			&& mapped(Math.min(...o.keys.map(key => key.f))) <= grab;
@@ -203,6 +207,33 @@ export function holdHook(ctx, out, solvePlain, solveLed) {
 		const h = heldAt(id, o, f);
 		return { w: 1, palm: h ? { pos: add(scale(grip.pos, 1 - h.w), scale(h.palm.pos, h.w)), R: between(grip.R, h.palm.R, h.w) } : grip, measure, pole };
 	};
+	// keys that lead from the grab frame, or from fewer than KEY_BLEND frames after it, put the hand on their grip at once (or
+	// within those frames: palm = first key o attach^-1). Where that grip is not where the hand would be at the first key (an
+	// at/along offset of the agent's choosing: bench session cb2503b5's cup, 13.6 cm in the grab frame; keys two frames after
+	// the grab: 7146050f's box), the hand turns onto it over the GRAB_EASE frames up to the first key instead, as onto a chosen
+	// grip (gripAround): before the grab with the object at rest, after it carrying the object there. A grip within OFF_GRIP
+	// of where the hand would be changes nothing.
+	const offGrips = new WeakMap();
+	const offGrip = (id, o, grip) => {
+		if (!offGrips.has(out.baked)) offGrips.set(out.baked, new Map());
+		const cache = offGrips.get(out.baked), had = cache.get(id);
+		if (had && had.map === out.timeMap) return had.off;
+		attaching.add(id);
+		let palm;
+		try { palm = palmOf(o, solvePlain(Math.max(spanIn(out, o)[0], Math.round(curveIn(out, id).t[0]))).s); } finally { attaching.delete(id); }
+		const turn = relative(palm, grip).R, deg = Math.acos(Math.min(1, Math.max(-1, (turn[0][0] + turn[1][1] + turn[2][2] - 1) / 2))) * 180 / Math.PI;
+		const off = Math.hypot(...sub(grip.pos, palm.pos)) > OFF_GRIP.m || deg > OFF_GRIP.deg;
+		cache.set(id, { map: out.timeMap, off });
+		return off;
+	};
+	const approach = (id, o, f) => {
+		const curve = curveIn(out, id), [grab, release] = spanIn(out, o), t0 = Math.max(grab, Math.round(curve.t[0]));
+		if (!(f < t0 && f >= t0 - GRAB_EASE) || t0 - grab >= KEY_BLEND || t0 > release) return null;
+		const grip = compose(keyedPose(curve, t0), invert(attach(id)));
+		if (!offGrip(id, o, grip)) return null;
+		const w = smooth(1 - (t0 - f) / GRAB_EASE);
+		return w > 1e-3 ? { w, palm: grip, measure: s => palmOf(o, s), pole: planOf(id, o).get(t0) } : null;
+	};
 	// a release within KEY_BLEND frames of the last key: the hands finish easing out of the keys after it (weight from the last
 	// key), the holding hand from the palm they gave it at the release (the object stays where it was let go), each hand with
 	// the elbow pole (and the second hand the roll) planned for the release frame
@@ -217,7 +248,7 @@ export function holdHook(ctx, out, solvePlain, solveLed) {
 	// the hand that holds a keyed carry follows its keys
 	const lead = (k, f, s, c) => {
 		for (const [id, o] of held) {
-			const pre = spec.props?.[o.prop]?.hand === k ? gripAround(id, o, f) ?? easeOut(id, o, f) : null;
+			const pre = spec.props?.[o.prop]?.hand === k ? gripAround(id, o, f) ?? approach(id, o, f) ?? easeOut(id, o, f) : null;
 			if (pre) return pre;
 			const h = spec.props?.[o.prop]?.hand === k ? heldAt(id, o, f) : null;
 			if (h) return { ...h, pole: planOf(id, o).get(f) };

package/src/motion3/object-pose.js

@@ -14,7 +14,9 @@
 //   f < grab              the scene pose
 //   grab <= f <= release  follows the prop's hand; without at/along it keeps the transform it had
 //                         against the palm axes at grab (no jump); at/along pin an offset (a group: its root, C15)
-//   f > release           frozen at the release pose
+//   f > release           frozen at the release pose; let go over a body that moves on its own (a seat of a truck the spec
+//                         drives with keys, a hinged lid), it rides that body's mover from the release on, keeping its world
+//                         pose at the release (riderOf): a lighter put down in the cab leaves with the truck
 //   no grab: in hand from frame 0; no release: in hand to the end (PR #14 behaviour)
 //   keys (C14, object-keys.js): the object leads and the hand follows; the object is still drawn
 //                         in the hand, so what the hand cannot reach shows as a residual (QA)
@@ -29,7 +31,8 @@ import { groupsOf } from "./scene.js";
 import { solveFrame } from "./compiler/compile.js";
 import { channelsAt } from "./compiler/channels.js";
 import { resolveBone } from "./bones.js";
-import { isFree, freePoseAt, beforeGrab, afterRelease } from "./free-motion.js";
+import { isFree, freePoseAt, beforeGrab, afterRelease, fallsAfter, corners, topOf, under, TOUCH } from "./free-motion.js";
+import { add } from "./compiler/math.js";
 
 /**
  * Body ids that make up `id` in a motionScene: [id] for a body (plus any bodies parented under
@@ -68,7 +71,7 @@ export function spanOf(out, o) {
 /** Without at/along a grabbed body, and a group, keeps its grab-frame palm offset; at/along pin one (a kit root, C15). */
 const keepsOffset = (scene, id, o) => o.at === undefined && o.along === undefined && ((!scene?.objects?.[id] && !!groupsOf(scene)[id]) || o.grab !== undefined);
 
-const solved = new WeakMap(), poses = new WeakMap();
+const solved = new WeakMap(), poses = new WeakMap(), riders = new WeakMap();
 
 /** What free-motion.js reads of a compile result: the spec, the scene and the time map. */
 const freeCtx = out => ({ spec: out.ctx.spec, scene: out.ctx.scene, timeMap: out.timeMap });
@@ -84,8 +87,36 @@ export function restingAt(out, id, f) {
 	return root && (mover === id ? root : compose(root, relative(restPose(scene, mover), restPose(scene, id))));
 }
 
-/** The solved frame at absolute f: out.frames, or solved once on demand outside a window. */
-function frameAt(out, f) {
+/**
+ * The spec.objects key a carry `id` (entry o) rides after its release: the key that moves the highest body under the
+ * record's centre at the release frame, when that key moves on its own (keys, a fall or a hinge; never a hand or a follow)
+ * and is not the record itself. null when the carry falls after its release, is never let go, or nothing under it moves.
+ */
+export function riderOf(out, id) {
+	if (!riders.has(out)) riders.set(out, new Map());
+	const cache = riders.get(out);
+	if (cache.has(id)) return cache.get(id);
+	const { spec, scene } = out.ctx, o = spec.objects?.[id], rest = restPose(scene, id), parts = partsOf(scene, id);
+	let best = null;
+	if (isCarried(o) && o.release !== undefined && rest && parts.length) {
+		const release = spanOf(out, o)[1];
+		if (release < out.frameCount - 1 && !fallsAfter(freeCtx(out), o, release)) {
+			const at = carriedAt(out, id, o, release), pts = parts.flatMap(p => corners({ ...compose(at, relative(rest, scene.objects[p])), half: scene.objects[p].half }));
+			const low = Math.min(...pts.map(p => p[1])), c = pts.reduce((a, p) => add(a, p), [0, 0, 0]).map(v => v / pts.length);
+			for (const [k, body] of Object.entries(scene.objects)) {
+				const mover = parts.includes(k) ? null : moverOf(spec, scene, k), entry = spec.objects?.[mover];
+				if (!mover || mover === id || isCarried(entry) || isFollow(entry)) continue;
+				const box = { ...objectPoseAt(out, k, release), half: body.half }, top = topOf(box);
+				if (under(box, c) && top <= low + TOUCH && (!best || top > best.top)) best = { mover, top };
+			}
+		}
+	}
+	cache.set(id, best?.mover ?? null);
+	return best?.mover ?? null;
+}
+
+/** The solved frame at absolute f: out.frames, or solved once on demand outside a window (or ahead of the frame being solved). */
+export function frameAt(out, f) {
 	const own = out.frames[f - (out.f0 ?? 0)];
 	if (own) return own;
 	if (!solved.has(out)) solved.set(out, new Map());
@@ -129,6 +160,8 @@ export function rootPoseAt(out, id, f, now = null) {
 		if (f < grab && rest) return restingAt(out, id, f);
 		const after = f > release ? afterRelease(freeCtx(out), id, o, f, release, carriedAt(out, id, o, release), release > 0 ? carriedAt(out, id, o, release - 1) : null) : null;
 		if (after) return after;
+		const by = f > release ? riderOf(out, id) : null;
+		if (by) { const at = carriedAt(out, id, o, release); return compose(rootPoseAt(out, by, f), relative(rootPoseAt(out, by, release), at)); }
 		return now && g === f ? carriedOn(out, id, o, f, now.s) : carriedAt(out, id, o, g);
 	}
 	if (!rest) return null;

package/src/motion3/pipeline.js

@@ -95,6 +95,8 @@ export function compileSpec(sent, { sk, scene }, opts = {}) {
 	if (paced.length) observations.paced = paced;
 	const cut = used.filter(u => u.cut).map(u => `${u.skill}: ${u.cut}`);
 	if (cut.length) observations.cut = cut;
+	const placed = used.filter(u => u.placed).map(u => `${u.skill} f${u.f0}: ${u.placed.why}: at [${u.placed.at.join(", ")}], heading ${u.placed.heading}`);
+	if (placed.length) observations.placed = placed;
 	if (plans.length) observations.planned = plans.map(p => p.note);
 	const timeline = timelineOf(out, { used, spec: expanded }), probes = asked && runProbes(out, asked, { spec: expanded, sk, scene, notes });
 	return { out, qa, observations, spec: resolved, expanded, used, fixed: out.fixed, search, timeline, ...(probes ? { probes } : {}), ...(notes.length ? { notes } : {}),

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

@@ -11,6 +11,7 @@ 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";
 
 export function pointOf(out, f, ref) {
 	const { s, diag, c } = out.frames[f], [kind, rest] = ref.split(/:(.*)/s);
@@ -20,6 +21,13 @@ 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. */
+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 +43,10 @@ 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)
+			const held = graspPart(out, k.target), 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/scene.js

@@ -7,7 +7,8 @@
 // and scene.others (take-source.js), so the groups are rebuilt from the entries: groupsOf.
 // `others` lists the records with no box (an Empty, a light, an effect, a plane) by id with their
 // renderer and ancestors: a switch entry (C15) may name them, and a skill finds a kit's lit parts
-// there. A body that glows (record.glow) says so (`glow: true`).
+// there. A body that glows (record.glow) says so (`glow: true`); a record's grasp sockets (record.grasp,
+// ../object-grasp.js) ride along for the hand (sockets.js).
 import { objectSize } from "../object-size.js";
 import { mul, rx, ry, rz } from "./compiler/math.js";
 
@@ -50,11 +51,11 @@ export function motionScene(objects = []) {
 		if (!o || o.hidden) continue;
 		const size = objectSize(o), up = ancestorsOf(o, byId);
 		if (NO_BODY.has(o.renderer) || !(size.width > 0 && size.height > 0 && size.depth > 0)) {
-			others[o.id] = { renderer: o.renderer, ancestors: up.map(p => p.id) };
+			others[o.id] = { renderer: o.renderer, ancestors: up.map(p => p.id), ...(o.grasp ? { grasp: o.grasp } : {}) };
 			continue;
 		}
 		out[o.id] = { name: o.name, renderer: o.renderer, ...poseOf(o), half: [size.width / 2, size.height / 2, size.depth / 2],
-			ancestors: up.map(p => p.id), ...(up.length ? { ancestorPoses: up.map(poseOf) } : {}), ...(o.glow ? { glow: true } : {}) };
+			ancestors: up.map(p => p.id), ...(up.length ? { ancestorPoses: up.map(poseOf) } : {}), ...(o.glow ? { glow: true } : {}), ...(o.grasp ? { grasp: o.grasp } : {}) };
 	}
 	return { objects: out, groups: groupsOf({ objects: out }), others };
 }

package/src/motion3/schema/fields.js

@@ -11,7 +11,7 @@ export const KEY_FIELDS = ["f", "set", "step", "src"];
 export const USE_FIELDS = ["skill", "args", "f0"];
 /** Anchor fields by anchor kind (besides `kind`). */
 export const ANCHOR_FIELDS = { world: ["p"], body: ["p"], bone: ["bone", "offset"], segment: ["from", "to", "t", "tMin", "offset", "reach"],
-	object: ["object", "local"], landmark: ["name"], prop: ["prop", "point", "offset"], person: ["person", "bone", "offset"] };
+	object: ["object", "local", "socket", "grasp"], landmark: ["name"], prop: ["prop", "point", "offset"], person: ["person", "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. */

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 offset to the palm: no jump.";
+const NO_JUMP = "Without at/along it keeps its grab-frame palm offset: no jump.";
 /** 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,13 +65,14 @@ 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; 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)."],
 	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 frozen where it was let go.",
+		"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}`,
 		"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 "
@@ -108,6 +109,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

@@ -3,7 +3,7 @@
 // looks each field up here, and throws when one is missing, so a new field needs a type here.
 // Shared shapes are $refs into DEFS (describe.js adds the ones an answer uses).
 import { REF_KINDS, OBJECT_KEY_FIELDS } from "./fields.js";
-import { CONVENTIONS } from "../compiler/vocab.js";
+import { CONVENTIONS, GRASPS } from "../compiler/vocab.js";
 import { QA_LIMITS } from "../qa/checks.js";
 import { CAPSULES } from "../qa/geometry.js";
 
@@ -64,7 +64,7 @@ export const ANCHOR_TYPES = {
 	from: str("bone"), to: str("bone"), t: num("0 = from .. 1 = to", { default: 0.5 }), tMin: num("with reach: the lowest t to slide back to", { default: 0.15 }),
 	reach: side("slide toward `from` until this arm reaches"), object: str("scene object id"), local: ref("vec3", "point in the object's frame, m"),
 	name: { const: "mouth" }, prop: str("a prop held by the other hand"), point: str("a point of that prop, or origin"),
-	person: str("a character id"),
+	person: str("a character id"), socket: str("a socket of the object"), grasp: { enum: GRASPS, description: "the hand takes it by a socket" },
 };
 
 const palm = d => ref("vec3", `${d} [d, l, n] on the palm axes (d to the middle finger, l to the thumb side, n = d x l), m`);
@@ -140,6 +140,7 @@ 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 }),
 };
 
 export const REF_DOCS = {

package/src/motion3/skills/basic.js

@@ -4,19 +4,37 @@ import { add, apply, ry } from "../compiler/math.js";
 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";
 
-/** standIdle({ at: [x, z], heading = 0, until }): a neutral standing pose, arms down (FK). */
+/** 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). 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 } : {}) };
 }
 
 /**
@@ -48,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
@@ -59,25 +94,44 @@ export function reachGrip(ctx) {
 	const { args, state } = ctx, k = args.side, name = args.anchor;
 	if (k !== "l" && k !== "r") skillError(ctx.tag, `args.side must be "l" or "r", got ${JSON.stringify(k)}`);
 	if (typeof name !== "string" || /_[lr]$/.test(name)) skillError(ctx.tag, "args.anchor must name an anchor (not ending in _l/_r)");
-	const reach = args.reach ?? 20, hold = args.hold ?? 22, release = args.release ?? 12, preset = args.fingers ?? "grip";
+	const reach = args.reach ?? 20, hold = args.hold ?? 22, release = args.release ?? 12;
+	// 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: [0, 0, 0] } } },
+		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/index.js

@@ -7,6 +7,7 @@ import { stateAt } from "../compiler/walk.js";
 import { didYouMean, suggestField } from "../compiler/vocab.js";
 import { USE_FIELDS } from "../schema/fields.js";
 import { SKILL_INFO } from "./info.js";
+import { fixOptions } from "../fix/index.js";
 import { standIdle, walkTo, reachGrip } from "./basic.js";
 import { sitInSeat, exitCar } from "./car.js";
 import { smokeCigarette } from "./smoke.js";
@@ -60,7 +61,8 @@ export function expandUse(spec, { sk, scene, lenient = false, auto = false }) {
 		argsOk(u, i, lenient);
 		if (!Number.isInteger(u.f0) || u.f0 < 0 || u.f0 > spec.frames - 1) bad(`use[${i}].f0 must be an integer frame within 0..${spec.frames - 1}, got ${JSON.stringify(u.f0)}`);
 		const keys = [...skillKeys, ...own];
-		const ctx = { sk, scene, frames: spec.frames, auto, self: spec.fix !== false && spec.fix?.self !== false, f0: u.f0, args: structuredClone(u.args ?? {}), tag, keys, state: structuredClone(stateAt(keys, u.f0)), anchors: { ...merged.anchors, ...spec.anchors } };
+		const ctx = { sk, scene, frames: spec.frames, auto, props: { ...merged.props, ...spec.props }, self: spec.fix !== false && spec.fix?.self !== false, f0: u.f0, args: structuredClone(u.args ?? {}), tag, keys,
+			use: spec.use, index: i, place: fixOptions(spec.fix).stance, state: structuredClone(stateAt(keys, u.f0)), anchors: { ...merged.anchors, ...spec.anchors }, objects: { ...merged.objects, ...spec.objects } };
 		const part = SKILLS[u.skill](ctx), last = Math.max(part.end ?? u.f0, ...part.keys.map(k => k.f));
 		if (last > spec.frames - 1) bad(`${tag} needs ${last - u.f0} frames from f${u.f0} (to f${last}), past the last frame f${spec.frames - 1}; set frames >= ${last + 1} or frames: "auto"`);
 		skillKeys.push(...part.keys.map(k => ({ ...k, src: k.src ?? tag })));
@@ -70,7 +72,7 @@ export function expandUse(spec, { sk, scene, lenient = false, auto = false }) {
 		for (const fit of part.fits ?? []) if (!merged.fits.some(x => same(x, fit))) merged.fits.push(fit);
 		for (const ch of part.channels ?? []) if (!merged.channels.includes(ch)) merged.channels.push(ch);
 		mergeChecks(merged.checks, part.checks);
-		used.push({ skill: u.skill, f0: u.f0, end: part.end, ...(part.paced ? { paced: part.paced } : {}), ...(part.cut ? { cut: part.cut } : {}) });
+		used.push({ skill: u.skill, f0: u.f0, end: part.end, ...(part.paced ? { paced: part.paced } : {}), ...(part.cut ? { cut: part.cut } : {}), ...(part.placed ? { placed: part.placed } : {}) });
 	});
 	const out = { ...spec, keys: [...skillKeys, ...own], anchors: { ...merged.anchors, ...spec.anchors }, props: { ...merged.props, ...spec.props },
 		objects: { ...merged.objects, ...spec.objects } };

package/src/motion3/skills/info.js

@@ -19,7 +19,7 @@ const walkArgs = Object.fromEntries(WALK_FIELDS.filter(f => f !== "type" && f !=
 
 export const SKILL_INFO = {
 	standIdle: {
-		args: { at: xz("[x, z] world m; default the root keyed before f0"), heading: num("degrees (yaw); default the keyed yaw"), until: int("hold the pose to this frame") },
+		args: { at: xz("[x, z] world m; default the root keyed before f0, else within reach of the next reachGrip's anchor (output.observations.placed); a stance in a body slides out of it"), heading: num("degrees (yaw); default the keyed yaw"), until: int("hold the pose to this frame") },
 		needs: "args.at, or a root keyed before f0", frames: "1 (to args.until when given)",
 		adds: ["keys: a standing pose, FK arms down"], example: { f0: 0, args: { at: [0, 0], heading: 0 } },
 		place: { at: 0.03 },
@@ -34,10 +34,10 @@ export const SKILL_INFO = {
 	},
 	reachGrip: {
 		args: { anchor: str("not ending in _l/_r"), side: side("the hand"), reach: int("frames to reach", { default: 20 }), hold: int("frames held", { default: 22 }),
-			release: int("frames to let go", { default: 12 }), elbow: ref("vec3", "elbow pole"), fingers: { enum: FINGER_PRESETS, default: "grip" },
-			define: { type: "object", description: "an anchor (topic anchors) named args.anchor" }, orient: { type: "boolean", description: "false: no grip turn" } },
-		required: ["anchor", "side"], needs: "args.anchor in spec.anchors or args.define", frames: "reach + hold + release (54 by default)",
-		adds: ["props.<anchor>Grip (fingers point)", "fits: fingers onto the anchor", "checks.contacts \"fingers on <anchor>\"", "checks.allow hand on the anchor's object",
+			release: int("frames to let go", { default: 12 }), elbow: ref("vec3", "pole"), fingers: { enum: FINGER_PRESETS, default: "grip" },
+			define: { type: "object", description: "defines anchor args.anchor" }, orient: { type: "boolean", description: "false: no grip turn" } },
+		required: ["anchor", "side"], needs: "args.anchor in anchors or define", frames: "reach + hold + release (54)",
+		adds: ["props.<anchor>Grip (fingers point)", "fits: fingers on the anchor", "checks.contacts \"fingers on <anchor>\"", "checks.allow hand on its object",
 			"keys: w_<anchor>_<side>, fingers_<side>, armw_<side>"],
 		example: { f0: 10, args: { anchor: "bar", side: "r", define: { kind: "world", p: [-0.2, 1.2, 0.33] } } },
 		tune: { reach: 2, release: 2 },