cozyclay 3.1.0 → 3.1.2

package/src/motion3/compiler/overlap.js

@@ -0,0 +1,180 @@
+// Overlap (spec.flow.overlap, on by default): a body does not start or stop all at once. A change breaks
+// along the chains one link after another: the lower spine, then the chest, then the head; the upper arm,
+// then the forearm, then the hand; each link starts later and settles later than the one it hangs from.
+// The agent keys five channels on one frame and both arms on the same frames (the user's tutorial take:
+// 7 of 7 parts within +-1 frame, observations.life sync 0.81), and a constant trail per family moves the
+// whole curve of a family at once, so every link of it still starts on one frame. Here each link takes its
+// own delay at each of its keys (LINK frames at 24 fps, less for a short move: LINK * h / FULL for a move
+// of h frames, so a quick flick is not smeared and a key pose is reached long before the next key), one
+// side of the body trails the other by SIDE frames chosen per key frame (a hash of the spec's label and the
+// key frame, so the same spec bakes the same take and both arms keyed on one frame part on different ones),
+// and the arm's swing and bend, the distal swing, overshoot a little where they stop and settle back
+// (SETTLE: a bounded hump, then exactly the keyed value, so a hold stays flat after it). Only the body's
+// own swing moves: the channels that place it (feet, root, yaw, hand targets and weights, poles, fingers,
+// objects) are untouched, so every contact lands as keyed; an arm on its IK loses it with the rest of
+// flow (channels.js), and a skill that times its own motion (a walk's rhythm, a flip, a hit) keeps its keys
+// on time: the delay is for the agent's keys (and standIdle's pose), easing in and out around the rest.
+// frames for a FULL-frame move; the arm's swing and bend also trail the body by flow.lag.arms (3), the wrist (no flow of
+// its own) here: after the forearm
+// its own) here: after the forearm. A free IK hand (hand target, IK weight and pole together: hand) takes no delay of its
+// own, only its side's trail, so both hands keyed on one frame part
+const LINK = { spine: 1, chest: 2.5, head: 3.5, aswing: 3, abend: 5, wrist: 9.5, hand: 0 };
+/** A hand keeps its keyed time within CONTACT frames of a contact: an anchor or fit weight on, a carry, a hand goal (handBusy). */
+const CONTACT = 6, SNAP = 6;
+const FULL = 24, SIDE = [1.5, 3];
+/** How fast a delay may change, frames a frame: under 1 time still runs forward; it also runs out this fast before an arm's IK. */
+export const OVERLAP_SLOPE = 0.5;
+const MOVE_SLOPE = 0.2, TRAIL_SLOPE = 0.15;
+const SETTLE = { frames: 8, min: 6, frac: 0.08, max: 3 };
+const SETTLES = /^(aswing|abend|wflex)_[lr]$/;
+// a skill times its own motion (a flip, a hit, a walk: walk.js tags its steps); standIdle only sets the pose the agent's keys start from
+const OWN_TIMING = /^use\[\d+\] (?!standIdle$)|\bwalk(To)? (start|step \d+|end)$/;
+
+const ownTiming = p => OWN_TIMING.test(p?.src ?? "");
+
+/** The chain link a channel moves, or null (a placement channel, or one overlap leaves alone). */
+function linkOf(ch) {
+	const m = /^(spine|chest|head)_(yaw|pitch|roll)$|^(aswing|abend|wflex|wtwist)_[lr]$|^(hand|armw|elbow)_[lr]$/.exec(ch);
+	if (!m) return null;
+	return m[1] ?? (m[4] ? "hand" : m[3] === "wflex" || m[3] === "wtwist" ? "wrist" : m[3]);
+}
+
+/** text -> a number in [-1, 1) (FNV-1a hash, then one mulberry32 step; gait-rhythm.js noiseOf). */
+function unit(text) {
+	let h = 2166136261;
+	for (let i = 0; i < text.length; i++) h = Math.imul(h ^ text.charCodeAt(i), 16777619);
+	let t = Math.imul((h >>> 0) ^ ((h >>> 0) >>> 15), (h >>> 0) | 1);
+	t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+	return (((t ^ (t >>> 14)) >>> 0) / 4294967296) * 2 - 1;
+}
+
+/** A delay a key at a time, eased between keys: { max, at(q) }, or null when it is 0 throughout. */
+function delayCurve(x, lam, slope) {
+	const n = x.length;
+	for (let i = 1; i < n; i++) lam[i] = Math.min(lam[i], lam[i - 1] + slope(i - 1));
+	for (let i = n - 2; i >= 0; i--) lam[i] = Math.min(lam[i], lam[i + 1] + slope(i));
+	if (!lam.some(v => v > 0)) return null;
+	return {
+		max: Math.max(...lam),
+		at(q) {
+			if (q <= x[0]) return lam[0];
+			if (q >= x[n - 1]) return lam[n - 1];
+			let i = 0;
+			while (q > x[i + 1]) i++;
+			return lam[i] + ((lam[i + 1] - lam[i]) * (q - x[i])) / (x[i + 1] - x[i]);
+		},
+	};
+}
+
+/**
+ * The delay (frames) of a link, on top of its side's trail (sideTrail), at each frame, or null. pts: the channel's
+ * keys ({ f, value, src }); scale: flow.overlap (1 the default). A delay is set at each key (the move that leaves it:
+ * LINK for a FULL-frame move, less for a shorter one), 0 at (and into) a skill's own keys and at keys next to an arm's
+ * IK (gap: frames to the nearest IK frame per frame, ikGap), and eased between keys no steeper than OVERLAP_SLOPE
+ * frames a frame on a hold and MOVE_SLOPE across a move, so time still runs forward and a hold keeps its length.
+ */
+export function overlapDelay(ch, pts, scale, seed, gap = null) {
+	const link = linkOf(ch);
+	if (!link || !LINK[link] || !(scale > 0) || pts.length < 2) return null;
+	const x = pts.map(p => p.f), n = x.length;
+	const lam = x.map((f, i) => {
+		// a move on, into or out of an arm's IK keeps its keyed time (gap: frames to its IK, ikGap); the delay comes and goes on the holds around it
+		if (ownTiming(pts[i]) || ownTiming(pts[i + 1]) || (gap && [x[i - 1], f, x[i + 1]].some(g => g !== undefined && gap[g] < 2))) return 0;
+		return LINK[link] * Math.min(1, (i < n - 1 ? x[i + 1] - f : FULL) / FULL) * scale;
+	});
+	// a delay changes on a hold, where nothing shows it; across a move only by MOVE_SLOPE (its speed within about 20%)
+	return delayCurve(x, lam, i => (pts[i].value === pts[i + 1].value ? OVERLAP_SLOPE : MOVE_SLOPE) * (x[i + 1] - x[i]));
+}
+
+/**
+ * One side's trail: the whole arm of that side (its swing, bend and wrist, and as a free IK hand its target, IK weight
+ * and pole) runs this many frames late, so both arms keyed on one frame part, and the arm's FK and IK stay in step
+ * while it blends between them. keys: the keys of that arm's channels ({ f, src }). At each key frame the side
+ * that trails (a hash of seed and frame: both sides agree) takes SIDE[0]..SIDE[1] frames, no more than a third of the
+ * moves either side of the key; none at a snap (moves under SNAP frames: a trail changing across one bends it), at a
+ * skill's own keys, or within CONTACT frames of the hand's contacts (gap: contactGap). channels: each of the arm's
+ * channels' keys ({ f, value, src }), the IK weight's list marked weight: true.
+ */
+export function sideTrail(channels, side, scale, seed, gap = null) {
+	// one point a frame, a skill's own if any key on it is; the spans where some channel of the arm moves
+	const byFrame = new Map(), moves = [], same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+	for (const list of channels) {
+		for (const p of list) if (!byFrame.has(p.f) || ownTiming(p)) byFrame.set(p.f, p);
+		for (let i = 1; i < list.length; i++) if (!same(list[i - 1].value, list[i].value)) moves.push([list[i - 1].f, list[i].f, list.weight]);
+	}
+	const keyFrames = [...byFrame.values()].sort((a, b) => a.f - b.f);
+	if (!(scale > 0) || keyFrames.length < 2) return null;
+	const x = keyFrames.map(p => p.f), n = x.length;
+	const lam = x.map((f, i) => {
+		// the take starts on its keys
+		if (f === 0 || ownTiming(keyFrames[i]) || ownTiming(keyFrames[i + 1]) || (gap && [x[i - 1], f, x[i + 1]].some(g => g !== undefined && gap[g] < 2))) return 0;
+		const u = unit(`${seed}|${f}`), short = Math.min(i < n - 1 ? x[i + 1] - f : FULL, i > 0 ? f - x[i - 1] : FULL);
+		if ((u < 0 ? "l" : "r") !== side || short < SNAP) return 0;
+		return Math.min(SIDE[0] + (SIDE[1] - SIDE[0]) * Math.abs(u), short / 3) * Math.min(1, scale);
+	});
+	// the trail changes freely while the whole arm holds; across a move by TRAIL_SLOPE (its speed within about 15%), and
+	// never across a change of the IK weight: the blend of FK and IK there turns a changing trail into a pop of the hand
+	const across = i => moves.filter(([a, b]) => a < x[i + 1] && b > x[i]), h = i => x[i + 1] - x[i];
+	return delayCurve(x, lam, i => (!across(i).length ? OVERLAP_SLOPE : across(i).some(m => m[2]) ? 0 : TRAIL_SLOPE) * h(i));
+}
+
+const hump = u => (u <= 0 || u >= 1 ? 0 : 64 * (u * (1 - u)) ** 3);
+
+/**
+ * The distal swing's follow-through (the arm's swing and bend, the wrist's flex): a bump (degrees, by curve time) added where a move stops (a key whose
+ * next key holds its value, or the last key): it peaks SETTLE.frac of the move (SETTLE.max deg at most) past
+ * the key a quarter of the way in and is gone SETTLE.frames later (less, and smaller, for a short move or hold;
+ * none under SETTLE.min frames), with no
+ * step in speed or acceleration at either end, and never past the take's end frame. abend never goes past
+ * straight; a skill's own stop has none; clear(a, b) false leaves a bump over frames a..b out (an arm going onto its IK). null when there is none.
+ */
+export function settleBump(ch, pts, y, scale, end, clear = () => true) {
+	if (!SETTLES.test(ch) || !(scale > 0)) return null;
+	const bumps = [], x = pts.map(p => p.f);
+	for (let i = 1; i < x.length; i++) {
+		const d = y[i] - y[i - 1], next = x[i + 1];
+		if (Math.abs(d) < 1 || ownTiming(pts[i]) || ownTiming(pts[i - 1]) || (next !== undefined && y[i + 1] !== y[i])) continue;
+		const S = Math.min(SETTLE.frames, 0.5 * (x[i] - x[i - 1]), next === undefined ? Infinity : 0.5 * (next - x[i]));
+		// a shorter settle is a smaller one: its acceleration goes as A / S^2
+		let A = Math.sign(d) * Math.min(SETTLE.max * (S / SETTLE.frames) ** 2, SETTLE.frac * Math.abs(d)) * Math.min(1, scale);
+		if (/^abend/.test(ch) && y[i] + A < 0) A = Math.min(0, -y[i]);
+		// the take ends on its last value: a bump that would run past the end is left out
+		if (S >= SETTLE.min && Math.abs(A) > 1e-3 && x[i] + 0.75 * S <= end && clear(x[i] - S / 4, x[i] + 0.75 * S)) bumps.push([x[i] - S / 4, S, A]);
+	}
+	if (!bumps.length) return null;
+	return t => { let v = 0; for (const [a, S, A] of bumps) v += A * hump((t - a) / S); return v; };
+}
+
+/** Per frame, how many frames away the nearest frame is on which any of these IK weights is on (Infinity: none). */
+export function ikGap(weights, frameCount) {
+	const gap = new Array(frameCount).fill(Infinity);
+	for (let f = 0, last = -Infinity; f < frameCount; f++) { if (weights.some(w => w[f] > 1e-3)) last = f; gap[f] = f - last; }
+	for (let f = frameCount - 1, next = Infinity; f >= 0; f--) { if (weights.some(w => w[f] > 1e-3)) next = f; gap[f] = Math.min(gap[f], next - f); }
+	return gap;
+}
+
+/**
+ * Per side, the frames its hand works on something (a carry from its grab to its release, a near, above or still goal
+ * that names a hand over its frames), from the spec; channels.js adds the frames an anchor or fit weight of that hand is on. { l, r }: [[a, b]].
+ */
+export function handBusy(spec) {
+	const out = { l: [], r: [] }, end = Math.round(spec?.frames ?? 0);
+	for (const o of Object.values(spec?.objects ?? {})) {
+		const k = spec.props?.[o?.prop]?.hand;
+		if (Number.isFinite(o?.grab) && out[k]) out[k].push([o.grab, Number.isFinite(o.release) ? o.release : end]);
+	}
+	for (const g of spec?.goals ?? []) {
+		const at = Array.isArray(g?.at) ? g.at : null;
+		// a goal that puts a hand somewhere (near, above, still), not one that only measures it (speed, moved)
+		if (at?.length && ["near", "above", "still"].some(k => g[k] !== undefined) && /hand/i.test(JSON.stringify(g))) for (const k of ["l", "r"]) out[k].push([at[0], at[at.length - 1]]);
+	}
+	return out;
+}
+
+/** Per frame, how far a hand is from its contacts (handBusy spans and its own anchor weights), less margin (CONTACT): under 2 holds the keyed time. */
+export function contactGap(spans, weights, frameCount, margin = CONTACT) {
+	const busy = new Uint8Array(frameCount);
+	for (const [a, b] of spans) for (let f = Math.max(0, Math.floor(a)); f <= Math.min(frameCount - 1, Math.ceil(b)); f++) busy[f] = 1;
+	for (const w of weights) for (let f = 0; f < frameCount; f++) if (w[f] > 1e-3) busy[f] = 1;
+	return ikGap([busy], frameCount).map(g => Math.max(0, g - margin));
+}

package/src/motion3/compiler/pose.js

@@ -19,9 +19,8 @@ const KNEE_REST = [0, 0, 1], LEG = ["UpLeg", "Leg", "Foot"];
 const v3 = (x, d = [0, 0, 0]) => (Array.isArray(x) || ArrayBuffer.isView(x) ? [x[0], x[1], x[2]] : d);
 const num = (x, d = 0) => (typeof x === "number" && Number.isFinite(x) ? x : d);
 
-/** Split a body-frame rotation over a chain of bones, each turning about its own joint. */
-function spread(sk, s, bones, yaw, pitch, roll) {
-	const k = bones.length;
+/** Split a body-frame rotation over a chain of bones (k shares), each turning about its own joint. */
+function spread(sk, s, bones, yaw, pitch, roll, k = bones.length) {
 	for (const name of bones) {
 		const b = sk.index[name];
 		rotateSubtree(sk, s, b, s.P[b].slice(), mul(ry(yaw / k), mul(rx(pitch / k), rz(roll / k))));
@@ -117,7 +116,10 @@ export function pose(sk, c, hooks = {}) {
 		if (sw) rotateSubtree(sk, s, a, s.P[a].slice(), rx(-sw));
 	}
 	spread(sk, s, ["Neck", "Head"], num(c.head_yaw), num(c.head_pitch), num(c.head_roll));
-	spread(sk, s, ["Spine", "Spine1", "Spine2"], num(c.spine_yaw), num(c.spine_pitch), num(c.spine_roll));
+	// the top spine bone turns its share of chest_* when flow bakes one (channels.js overlap: it breaks after the two below)
+	const sy = num(c.spine_yaw), sp = num(c.spine_pitch), sr = num(c.spine_roll);
+	spread(sk, s, ["Spine", "Spine1"], sy, sp, sr, 3);
+	spread(sk, s, ["Spine2"], num(c.chest_yaw, sy), num(c.chest_pitch, sp), num(c.chest_roll, sr), 3);
 	// Root: turn about the hips joint, then put the hips at `root`.
 	const hips = sk.index.Hips, yaw = num(c.yaw);
 	rotateSubtree(sk, s, hips, s.P[hips].slice(), mul(ry(yaw), mul(rx(num(c.pitch)), rz(num(c.roll)))));

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

@@ -19,6 +19,7 @@ export function objectOk(err, scene, at, id, { groups = false } = {}) {
 	const parts = partsOf(scene, id);
 	if (parts.length && groups) return true;
 	if (parts.length) err(`${at} names "${id}", a group (Empty) with no body of its own; its parts are ${parts.join(", ")}. Name one part`);
+	else if (scene?.others?.[id]) err(`${at} names "${id}", a ${scene.others[id].renderer ?? "record"} with no body (no size to stand on, hold or hit); name a scene body${didYouMean(String(id), ids)}`);
 	else err(`${at} names object "${id}", which is not in the scene${didYouMean(String(id), [...new Set([...ids, ...ids.flatMap(k => scene.objects[k].ancestors ?? []), ...Object.keys(scene.others ?? {})])])}`);
 	return false;
 }

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

@@ -56,7 +56,11 @@ function validateProps(spec, err, { sk, unknown = err }) {
 		if (!SIDE.has(fit?.side)) err(`${at}.side must be "l" or "r", got ${fmt(fit?.side)}`);
 		if (!spec.anchors?.[fit?.anchor]) err(`${at}.anchor "${fit?.anchor}" is not in spec.anchors${didYouMean(String(fit?.anchor), Object.keys(spec.anchors ?? {}))}`);
 		const e = fit?.effector;
-		if (e?.prop !== undefined) { if (!spec.props?.[e.prop]?.points?.[e.point]) err(`${at}.effector ${e.prop}.${e.point} is not a point of spec.props`); }
+		if (e?.prop !== undefined) {
+			const p = spec.props?.[e.prop];
+			if (!p) err(`${at}.effector.prop "${e.prop}" is not in spec.props${didYouMean(String(e.prop), Object.keys(spec.props ?? {}))}`);
+			else if (e.point !== "origin" && !p.points?.[e.point]) err(`${at}.effector ${e.prop}.${e.point} is not a point of spec.props.${e.prop} (points: ${[...Object.keys(p.points ?? {}), "origin"].join(", ")})`);
+		}
 		else if (Array.isArray(e?.joints)) e.joints.forEach(j => boneOk(err, sk, `${at}.effector`, j));
 		else err(`${at}.effector must be { prop, point } or { joints: [bone, ...] }`);
 		if (fit?.offset !== undefined && !isVec3(fit.offset)) err(`${at}.offset must be [x, y, z]`);

package/src/motion3/compiler/validate.js

@@ -1,14 +1,29 @@
 // Strict motion spec validation with exact messages, run before every compile through the
 // pipeline (after skills expand, with open parameters at a trial value). Every problem found is
-// listed at once, one per line, so the agent fixes them in one edit.
+// listed at once, one per line (problems that differ only in their first index share a line), so the
+// agent fixes them in one edit.
 import { VEC_CHANNELS, POLE_CHANNELS, NUM_CHANNELS, MAP_CHANNELS, FINGER_PRESETS, rangeOf, CONVENTIONS, didYouMean, suggestField, isVec3, fmt } from "./vocab.js";
 import { validateParts } from "./validate-parts.js";
 import { SPEC_FIELDS, KEY_FIELDS } from "../schema/fields.js";
-const MAX_ERRORS = 12;
+const MAX_ERRORS = 12, MAX_FOUND = 60;
+
+/**
+ * Problems that differ only in their first index (and its key frame) said once: "objects.box.keys[0].rot must be
+ * ..." and keys[3] with the same words become "objects.box.keys[0,3].rot must be ...", so every problem fits one answer.
+ */
+function mergeProblems(lines) {
+	const groups = new Map();
+	for (const line of lines) {
+		const m = /\[(\d+)\]( \(f(\d+)\))?/.exec(line), key = m ? `${line.slice(0, m.index)}[#]${m[2] ? " (f#)" : ""}${line.slice(m.index + m[0].length)}` : line;
+		if (!groups.has(key)) groups.set(key, { line, idx: [], fs: [] });
+		if (m) { groups.get(key).idx.push(m[1]); if (m[3]) groups.get(key).fs.push(`f${m[3]}`); }
+	}
+	return [...groups.entries()].map(([key, g]) => (g.idx.length > 1 ? key.replace("[#]", `[${g.idx.join(",")}]`).replace(" (f#)", ` (${g.fs.join(", ")})`) : g.line));
+}
 
 
 /** Channels other than the body's own: hinge channels, visible and level channels (C15), channels a check names, *_vis switches, spec.channels. */
-function customChannels(spec) {
+export function customChannels(spec) {
 	const out = new Set(spec.channels ?? []);
 	for (const o of Object.values(spec.objects ?? {})) for (const ch of [o?.channel, o?.visible, o?.level]) if (typeof ch === "string" && ch) out.add(ch);
 	const c = spec.checks ?? {};
@@ -88,15 +103,18 @@ function validateKeys(spec, err, frames, unknown, past = "") {
 }
 
 /**
- * Throws MOTION_SPEC_INVALID listing every problem; scene objects are checked when given.
+ * Throws MOTION_SPEC_INVALID listing every problem (problems: ones found before, listed first); scene objects are
+ * checked when given.
  * lenient (a saved take compiled again, take-source.js) ignores unknown fields.
  */
-/** spec.flow: false, or { smooth?: boolean, lag?: false | 0..6 frames | { spine?, head?, arms? } } (channels.js). */
+/** spec.flow: false, or { smooth?: boolean, lag?: false | 0..6 frames | { spine?, head?, arms? }, overlap?: boolean | 0..2 } (channels.js, overlap.js). */
 function validateFlow(flow, err, unknown) {
 	if (flow === undefined || flow === false) return;
-	if (!flow || typeof flow !== "object" || Array.isArray(flow)) return err(`spec.flow must be false or { smooth?, lag? }, got ${fmt(flow)}`);
-	for (const k of Object.keys(flow)) if (k !== "smooth" && k !== "lag") unknown(`spec.flow has unknown field "${k}" (fields: smooth, lag)`);
+	if (!flow || typeof flow !== "object" || Array.isArray(flow)) return err(`spec.flow must be false or { smooth?, lag?, overlap? }, got ${fmt(flow)}`);
+	for (const k of Object.keys(flow)) if (!["smooth", "lag", "overlap"].includes(k)) unknown(`spec.flow has unknown field "${k}" (fields: smooth, lag, overlap)`);
 	if (flow.smooth !== undefined && typeof flow.smooth !== "boolean") err(`spec.flow.smooth must be true or false, got ${fmt(flow.smooth)}`);
+	const o = flow.overlap;
+	if (o !== undefined && typeof o !== "boolean" && !(Number.isFinite(o) && o >= 0 && o <= 2)) err(`spec.flow.overlap must be true, false or a scale 0..2, got ${fmt(o)}`);
 	const frames = v => Number.isFinite(v) && v >= 0 && v <= 6, lag = flow.lag, LAG = "false, 0..6 frames or { spine?, head?, arms? }";
 	if (lag === undefined || lag === false || frames(lag)) return;
 	if (!lag || typeof lag !== "object" || Array.isArray(lag)) return err(`spec.flow.lag must be ${LAG}, got ${fmt(lag)}`);
@@ -106,8 +124,8 @@ function validateFlow(flow, err, unknown) {
 	}
 }
 
-export function validateSpec(spec, { sk, scene, lenient = false } = {}) {
-	const errors = [], err = m => { if (errors.length < MAX_ERRORS) errors.push(m); }, unknown = lenient ? () => {} : err;
+export function validateSpec(spec, { sk, scene, lenient = false, problems = [] } = {}) {
+	const errors = [...problems], err = m => { if (errors.length < MAX_FOUND) errors.push(m); }, unknown = lenient ? () => {} : err;
 	if (!spec || typeof spec !== "object") throw new Error("MOTION_SPEC_INVALID: spec must be an object");
 	if (spec.schema !== "cozyclay.motion-spec.v1") err(`spec.schema must be "cozyclay.motion-spec.v1", got ${fmt(spec.schema)}`);
 	for (const k of Object.keys(spec)) if (!SPEC_FIELDS.includes(k)) unknown(`spec.${k} is not a spec field${didYouMean(k, SPEC_FIELDS)} (fields: ${SPEC_FIELDS.join(", ")})`);
@@ -118,5 +136,7 @@ export function validateSpec(spec, { sk, scene, lenient = false } = {}) {
 	const past = Number.isInteger(frames) ? pastEndAdvice(spec, frames) : "";
 	validateKeys(spec, err, Number.isInteger(frames) ? frames : 20000, unknown, past);
 	validateParts(spec, err, { sk, scene, frames: Number.isInteger(frames) ? frames : 20000, lenient, unknown, past });
-	if (errors.length) throw new Error(`MOTION_SPEC_INVALID: ${errors.join("\n")}${errors.length >= MAX_ERRORS ? "\n(more problems not listed)" : ""}`);
+	if (!errors.length) return;
+	const lines = mergeProblems(errors), more = lines.length > MAX_ERRORS || errors.length >= MAX_FOUND;
+	throw new Error(`MOTION_SPEC_INVALID: ${lines.slice(0, MAX_ERRORS).join("\n")}${more ? `\n(${lines.length > MAX_ERRORS ? `${lines.length - MAX_ERRORS}` : "more"}${errors.length >= MAX_FOUND ? "+" : ""} more problems not listed)` : ""}`);
 }

package/src/motion3/correct.js

@@ -0,0 +1,236 @@
+// C21. Corrections: slips in a sent spec that have one reading, fixed before the spec is stored, each named
+// in output.adjusted ("corrected: ...") so the compile goes on instead of being refused. A name is corrected
+// only when exactly one known name matches it once case, "_", "-" and spaces are ignored (spinePitch ->
+// spine_pitch, walk_to -> walkTo), when it is a plural or a singular of one (goal -> goals), or by the short
+// alias lists below (arm_swing_l -> aswing_l, pos -> p on a world anchor), and the right name is not there
+// already. Anything with two readings stays for the validator to refuse with every problem listed.
+//   spec fields, use[i] skill names and fields, use[i].args names (an arg of the skill written beside args
+//   moves into it, args.f0 moves out), key channels and finger presets, object key and fall fields, goal,
+//   fit and check entry fields, anchor fields
+//   generators[i] with to, arrive, a single heading or type "walkTo" -> a walkTo use entry (the walk that
+//   heads for a point), placed in f0 order among the use entries
+//   objects.<id> written as { free: {...} } (or carry, hinge, follow) -> the record itself
+//   fitWalks: a walkTo with to and steps gets the stride, or the step count and cadence, that ends the steps at
+//   to in a natural gait (skills/basic.js fitTo), stored with the spec; one it cannot fit is refused with what the
+//   walk would do and needs
+import { SPEC_FIELDS, USE_FIELDS, OBJECT_KEY_FIELDS, FALL_FIELDS, GOAL_FIELDS, FIT_FIELDS, ANCHOR_FIELDS, CHECK_ENTRY_FIELDS, OBJECT_FIELDS } from "./schema/fields.js";
+import { VEC_CHANNELS, NUM_CHANNELS, MAP_CHANNELS, FINGER_PRESETS } from "./compiler/vocab.js";
+import { SKILL_INFO } from "./skills/info.js";
+import { SKILL_NAMES, expandUse } from "./skills/index.js";
+import { customChannels } from "./compiler/validate.js";
+
+const plain = v => Boolean(v) && typeof v === "object" && !Array.isArray(v);
+const squash = s => String(s).toLowerCase().replace(/[\s_-]/g, "");
+/** Sided names: left / right / L / R at the end read as _l / _r. */
+const sided = s => String(s).replace(/[_-]?(left|Left|LEFT)$/, "_l").replace(/[_-]?(right|Right|RIGHT)$/, "_r").replace(/[_-]?L$/, "_l").replace(/[_-]?R$/, "_r");
+const CHANNEL_ALIASES = { arm_swing: "aswing", armswing: "aswing", elbow_bend: "abend", arm_bend: "abend", wrist_twist: "wtwist", wrist_flex: "wflex",
+	foot_yaw: "fyaw", foot_pitch: "fpitch", arm_weight: "armw", ik_weight: "armw", hips: "root", pelvis: "root", finger: "fingers", hand_pole: "elbow", knee_pole: "knee" };
+const FIELD_ALIASES = {
+	objectKey: { position: "pos", rotation: "rot", quat: "rot", quaternion: "rot", frame: "f" },
+	anchor: { pos: "p", position: "p", point: "p", id: "object", joint: "bone" },
+	use: { frame: "f0", f: "f0" },
+};
+
+/** The one name of `names` that `name` stands for, or null: alias, case and separators, plural or singular. */
+function nameFor(name, names, aliases = {}) {
+	if (names.includes(name)) return name;
+	const alias = aliases[name] ?? aliases[squash(name)];
+	if (alias && names.includes(alias)) return alias;
+	const hits = new Set(names.filter(n => squash(n) === squash(name) || n === `${name}s` || `${n}s` === name));
+	return hits.size === 1 ? [...hits][0] : null;
+}
+
+/** obj with each unknown field that stands for exactly one free known field renamed; one note per rename. */
+function renameFields(obj, fields, at, notes, aliases) {
+	if (!plain(obj)) return obj;
+	let out = obj;
+	for (const f of Object.keys(obj)) {
+		const to = fields.includes(f) ? null : nameFor(f, fields, aliases);
+		if (!to || to in out) continue;
+		out = Object.fromEntries(Object.entries(out).map(([k, v]) => (k === f ? [to, v] : [k, v])));
+		notes.push(`corrected: ${at}.${f} -> ${at}.${to}`);
+	}
+	return out;
+}
+
+const mapList = (list, fn) => (Array.isArray(list) ? list.map(fn) : list);
+
+/** A generator that is a walkTo: it heads for a point, plans to arrive, turns to one heading, or says so. */
+const isWalkTo = g => plain(g) && (g.to !== undefined || g.arrive !== undefined || typeof g.heading === "number" || nameFor(String(g.type), ["walkTo"]) === "walkTo");
+
+function moveGenerators(spec, notes) {
+	if (!Array.isArray(spec.generators) || !spec.generators.some(isWalkTo)) return spec;
+	const use = Array.isArray(spec.use) ? [...spec.use] : [], kept = [];
+	spec.generators.forEach((g, i) => {
+		if (!isWalkTo(g)) return kept.push(g);
+		const { type, f0, ...args } = g, at = use.findIndex(u => plain(u) && Number.isFinite(u.f0) && u.f0 > f0);
+		const j = at < 0 ? use.length : at;
+		use.splice(j, 0, { skill: "walkTo", f0, args });
+		const why = g.to !== undefined ? "to" : g.arrive !== undefined ? "arrive" : typeof g.heading === "number" ? "a single heading" : `type "${type}"`;
+		notes.push(`corrected: generators[${i}] (a walk with ${why}) -> use[${j}] walkTo { ${Object.keys(args).join(", ")} }: a generator walks by steps and [h0, h1]; walkTo is the walk that heads for a point`);
+	});
+	const { generators, ...rest } = spec;
+	return { ...rest, ...(kept.length ? { generators: kept } : {}), use };
+}
+
+function fixUse(u, i, notes) {
+	if (!plain(u)) return u;
+	let out = u;
+	const skill = SKILL_NAMES.includes(u.skill) ? u.skill : nameFor(String(u.skill), SKILL_NAMES);
+	if (skill && skill !== u.skill) { out = { ...out, skill }; notes.push(`corrected: use[${i}].skill "${u.skill}" -> "${skill}"`); }
+	const info = SKILL_INFO[out.skill];
+	if (!info) return out;
+	const known = Object.keys(info.args);
+	if (plain(out.args) || out.args === undefined) {
+		const given = out.args ?? {};
+		let args = renameFields(given, known, `use[${i}].args`, notes);
+		// an enum arg written another way: "left" -> "l", "Back" -> "back"
+		for (const [a, v] of Object.entries(args)) {
+			const choices = info.args[a]?.enum, to = choices && typeof v === "string" && !choices.includes(v) ? nameFor(v, choices, { left: "l", right: "r" }) : null;
+			if (to) { args = { ...args, [a]: to }; notes.push(`corrected: use[${i}].args.${a} "${v}" -> "${to}"`); }
+		}
+		if (args.f0 !== undefined && !known.includes("f0") && out.f0 === undefined) {
+			const { f0, ...rest } = args;
+			args = rest; out = { ...out, f0 };
+			notes.push(`corrected: use[${i}].args.f0 -> use[${i}].f0`);
+		}
+		// an arg of the skill written beside args goes into args
+		for (const f of Object.keys(out)) {
+			const a = USE_FIELDS.includes(f) ? null : nameFor(f, known);
+			if (!a || a in args) continue;
+			args = { ...args, [a]: out[f] };
+			out = Object.fromEntries(Object.entries(out).filter(([k]) => k !== f));
+			notes.push(`corrected: use[${i}].${f} -> use[${i}].args.${a}`);
+		}
+		// an anchor a skill defines (reachGrip define) is an anchor like any other
+		if (plain(args.define) && ANCHOR_FIELDS[args.define.kind]) {
+			const define = renameFields(args.define, ["kind", ...ANCHOR_FIELDS[args.define.kind]], `use[${i}].args.define`, notes, FIELD_ALIASES.anchor);
+			if (define !== args.define) args = { ...args, define };
+		}
+		if (args !== given) out = { ...out, args };
+	}
+	return renameFields(out, USE_FIELDS, `use[${i}]`, notes, FIELD_ALIASES.use);
+}
+
+/** The body's channels and the spec's own (spec.channels, object and check channels, validate.js). */
+const knownChannels = spec => [...VEC_CHANNELS, ...NUM_CHANNELS, ...MAP_CHANNELS, ...customChannels(spec)];
+
+function channelFor(ch, known) {
+	const s = sided(ch), side = /_[lr]$/.exec(s)?.[0] ?? "", family = side ? s.slice(0, -2) : s;
+	const alias = CHANNEL_ALIASES[family] ?? CHANNEL_ALIASES[squash(family)];
+	if (alias && known.includes(alias + side)) return alias + side;
+	return nameFor(s, known);
+}
+
+function fixKey(key, i, known, notes) {
+	if (!plain(key) || !plain(key.set)) return key;
+	let set = key.set, step = key.step;
+	for (const ch of Object.keys(key.set)) {
+		if (known.includes(ch) || ch.endsWith("_vis") || ch.startsWith("w_")) continue;
+		const to = channelFor(ch, known);
+		if (!to || to in set) continue;
+		set = Object.fromEntries(Object.entries(set).map(([k, v]) => (k === ch ? [to, v] : [k, v])));
+		if (Array.isArray(step)) step = step.map(s => (s === ch ? to : s));
+		notes.push(`corrected: keys[${i}] (f${key.f}) channel "${ch}" -> "${to}"`);
+	}
+	for (const side of ["l", "r"]) {
+		const map = set[`fingers_${side}`];
+		if (!plain(map)) continue;
+		const fixed = renameFields(map, FINGER_PRESETS, `keys[${i}] (f${key.f}) fingers_${side}`, notes);
+		if (fixed !== map) set = { ...set, [`fingers_${side}`]: fixed };
+	}
+	return set === key.set ? key : { ...key, set, ...(step ? { step } : {}) };
+}
+
+/** objects.<id>: { free: { keys } } -> { keys }: a kind name used as a wrapper around the record's own fields. */
+function unwrapObject(id, o, notes) {
+	if (!plain(o)) return o;
+	const wrap = Object.keys(o).filter(k => ["free", "carry", "hinge", "follow", "switch"].includes(k) && plain(o[k]));
+	if (wrap.length !== 1) return o;
+	const { [wrap[0]]: inner, ...rest } = o;
+	if (Object.keys(inner).some(k => k in rest)) return o;
+	notes.push(`corrected: objects.${id}.${wrap[0]} { ${Object.keys(inner).join(", ")} } -> objects.${id} { ${Object.keys(inner).join(", ")} }: an entry's kind is read from its fields, not named`);
+	return { ...rest, ...inner };
+}
+
+function fixObject(id, o, notes) {
+	const at = `objects.${id}`, rec = unwrapObject(id, o, notes);
+	if (!plain(rec)) return rec;
+	const all = [...new Set(Object.values(OBJECT_FIELDS).flat())];
+	let out = renameFields(rec, all, at, notes);
+	if (Array.isArray(out.keys)) out = { ...out, keys: out.keys.map((k, j) => renameFields(k, OBJECT_KEY_FIELDS, `${at}.keys[${j}]`, notes, FIELD_ALIASES.objectKey)) };
+	if (plain(out.fall)) out = { ...out, fall: renameFields(out.fall, FALL_FIELDS, `${at}.fall`, notes) };
+	else if (Array.isArray(out.fall)) out = { ...out, fall: out.fall.map((fl, j) => renameFields(fl, FALL_FIELDS, `${at}.fall[${j}]`, notes)) };
+	return out;
+}
+
+const fixGoal = (g, i, notes) => renameFields(g, GOAL_FIELDS, `goals[${i}]`, notes);
+
+function fixAnchors(anchors, notes) {
+	if (!plain(anchors)) return anchors;
+	return Object.fromEntries(Object.entries(anchors).map(([name, a]) => [name, plain(a) && ANCHOR_FIELDS[a.kind]
+		? renameFields(a, ["kind", ...ANCHOR_FIELDS[a.kind]], `anchors.${name}`, notes, FIELD_ALIASES.anchor) : a]));
+}
+
+function fixChecks(checks, notes) {
+	if (!plain(checks)) return checks;
+	return Object.fromEntries(Object.entries(checks).map(([name, list]) => [name, CHECK_ENTRY_FIELDS[name] ? mapList(list, (k, j) => renameFields(k, CHECK_ENTRY_FIELDS[name], `checks.${name}[${j}]`, notes)) : list]));
+}
+
+/**
+ * correctSpec(spec, notes) -> the spec with every correction above (a new object when one applied,
+ * else spec itself); notes gets one "corrected: ..." line per correction. Run before the spec is stored (pipeline.js).
+ */
+function correctSpec(spec, notes = []) {
+	if (!plain(spec)) return spec;
+	const before = notes.length;
+	let s = renameFields(spec, [...SPEC_FIELDS, "probes"], "spec", notes);
+	s = moveGenerators(s, notes);
+	if (Array.isArray(s.use)) s = { ...s, use: s.use.map((u, i) => fixUse(u, i, notes)) };
+	if (s.anchors) s = { ...s, anchors: fixAnchors(s.anchors, notes) };
+	if (Array.isArray(s.keys)) { const known = knownChannels(s); s = { ...s, keys: s.keys.map((k, i) => fixKey(k, i, known, notes)) }; }
+	if (plain(s.objects)) s = { ...s, objects: Object.fromEntries(Object.entries(s.objects).map(([id, o]) => [id, fixObject(id, o, notes)])) };
+	if (Array.isArray(s.goals)) s = { ...s, goals: s.goals.map((g, i) => fixGoal(g, i, notes)) };
+	if (Array.isArray(s.fits)) s = { ...s, fits: s.fits.map((f, i) => renameFields(f, FIT_FIELDS, `fits[${i}]`, notes)) };
+	if (s.checks) s = { ...s, checks: fixChecks(s.checks, notes) };
+	return notes.length > before ? s : spec;
+}
+
+/**
+ * fitWalks(spec, { sk, scene }, notes, refusals) -> spec with each walkTo's fitted args (skills/basic.js fitTo) written
+ * into its use entry, so the stored spec walks where it says and compiles the same again; refusals gets one line per
+ * walk it cannot fit (the validator lists them with its own, pipeline.js). A spec that does not expand is left as it is.
+ */
+function fitWalks(spec, { sk, scene } = {}, notes = [], refusals = []) {
+	if (!plain(spec) || !Array.isArray(spec.use) || !spec.use.some(u => u?.skill === "walkTo" && plain(u.args) && u.args.to !== undefined)) return spec;
+	// a walk may end later freely only in a frames "auto" spec with nothing after it, else into frames nothing uses
+	// (skills/basic.js fitTo, roomAfter): busy lists the frames of the object keys, grabs and releases, last the take's last frame
+	const busy = Object.values(plain(spec.objects) ? spec.objects : {}).flatMap(o => (plain(o) ? [o.grab, o.release, ...(Array.isArray(o.keys) ? o.keys.map(k => k?.f) : [])] : [])).filter(Number.isFinite);
+	const expand = noStop => {
+		const fit = { refusals: [], stretch: spec.frames === "auto", busy, last: Number.isFinite(spec.frames) ? spec.frames - 1 : Infinity, noStop, stopped: new Set() };
+		try { return { used: expandUse({ ...spec, frames: 20000 }, { sk, scene, fit, auto: true }).used, fit }; } catch { return null; }
+	};
+	// a walk stopped before a body (walk-fit.js) moves where the next one starts: a stop is kept only while the spec has no
+	// more refusals than with every walk on its to (bench replay: 3 of 692 specs refused a later walk), the earliest first
+	let run = expand(new Set());
+	if (!run) return spec;
+	if (run.fit.stopped.size) {
+		const off = new Set(run.fit.stopped), onTo = expand(off);
+		if (onTo && onTo.fit.refusals.length < run.fit.refusals.length) {
+			for (const i of [...run.fit.stopped].sort((a, b) => a - b)) {
+				off.delete(i);
+				const t = expand(off);
+				if (!t || t.fit.refusals.length > onTo.fit.refusals.length) off.add(i);
+			}
+			run = expand(off) ?? onTo;
+		}
+	}
+	const { used, fit } = run;
+	refusals.push(...fit.refusals);
+	if (!used.some(u => u.adjust)) return spec;
+	for (const u of used) if (u.adjust) notes.push(`corrected: ${u.adjust.note}`);
+	return { ...spec, use: spec.use.map((u, i) => (used[i]?.adjust ? { ...u, args: { ...u.args, ...used[i].adjust.args } } : u)) };
+}
+
+/** prepareSpec(spec, { sk, scene }, notes, refusals): correctSpec, then fitWalks: the spec as it is stored and compiled. */
+export const prepareSpec = (spec, ctx, notes, refusals) => fitWalks(correctSpec(spec, notes), ctx, notes, refusals);

package/src/motion3/docs.js

@@ -2,14 +2,16 @@
 // Lane P owns the wording; the code only reads these constants. The procedure lives in the Studio
 // system prompt and the field tables in motion.describe, so these strings say only what each action takes and answers.
 export const MOTION_ACTION_HELP = {
-	compile: "Bake a spec on the character's rig and run QA. install: true installs (default), false or \"never\" changes nothing, \"ifClean\" only if the final qa.ok; output.installed tells. "
+	compile: "Bake a spec on the character's rig and run QA. install: true installs (default), false or \"never\" changes nothing, \"ifClean\" only if the final qa.ok. "
 		+ "Send spec, or base (an answered specId) + optional patch (JSON Patch); base alone or patch: [] re-measures (new probes). "
-		+ "spec = { schema: \"cozyclay.motion-spec.v1\", fps: 24, frames (number or \"auto\"), ... } (parts: motion.describe); any number may be { range: [lo, hi] } (searched). "
-		+ "probes (at most 16, request level; spec.probes: measured, not stored): { name, distance: [ref, ref] | position: ref, frames, every? }. "
-		+ "Refs need a prefix (joint: prop: anchor: landmark: object: person:; goals[].moved: a bare id too) and take loose bone names (any case); spec.checks need exact ones. "
+		+ "Address array items by field, not index: /keys/@f=120/set/hand_l (add creates the key at f120), remove /keys/@f=120, { op: \"move\", from: \"/keys/@f=120\", path: \"/keys/@f=132\" }, "
+		+ "/use/@skill=reach&f0=40, /goals/@name=<name>, /objects/<id>/keys/@f=40. "
+		+ "spec = { schema: \"cozyclay.motion-spec.v1\", fps: 24, frames (number or \"auto\"), ... }; any number may be { range: [lo, hi] } (searched). "
+		+ "probes (at most 16; spec.probes too, never stored): { name, distance: [ref, ref] | position: ref, frames, every? }. "
+		+ "Refs need a prefix (joint: prop: anchor: landmark: object: person:; goals[].moved: a bare id too) and take loose bone names; spec.checks need exact ones. "
 		+ "repair: { rounds } (1-8, default 4) applies group patches while severity drops. "
-		+ "qa judges only what is broken; speed, acceleration, balance, knee bend are observations unless checks.limits names them. "
-		+ "Answers frames, installed, specId, qa { ok, total, goals, groups (GOAL first, then severity; cause, hint, patch?) }, observations, delta (with base), repair, probes, timeline, fixed, search, skills. output.more: motion.report pages the rest.",
+		+ "qa judges only what is broken; speed, balance and bends are observations unless checks.limits names them. "
+		+ "Answers brief (qa, misses, top groups: a script returns it as is), frames, installed, stuck (when to stop), specId, qa { ok, total, goals, groups (GOAL first, then severity; cause, hint, repair patch?) }, observations (asked: skill ends, contacts, goal points), delta (with base), repair, probes, timeline, fixed, search, skills. more: motion.report pages the rest.",
 	qa: "Measure the character's installed take again against the scene as it is now (objects may have moved). Optional checks replace the spec's checks and its skills' checks. "
 		+ "Answers specId and qa as motion.compile does (goals, ranked groups with cause, hint and patch); output.more pages with motion.report. Changes nothing.",
 	sample: "World positions (metres) of named bones of the installed take at up to 64 frames. Bone names may be loose (any case, a mixamorig: prefix, aliases such as hips or hand_l); an unknown one answers a did-you-mean. "

package/src/motion3/face-lean.js

@@ -0,0 +1,31 @@
+// A held object brought to the face leans by default (lane arm). An aim key at the lips without lean or roll (a cup
+// tipped to the mouth) is held as the aim asks only with the elbow out to the side and over the shoulder: the grip the
+// reach took on the table turns the hand with the cup, and the wrist cannot take the rest (the agents' first compiles of
+// bench S6 and S8: the upper arm past 110 deg from hanging on 31 of 56, the elbow over the head on 17). Leaning the aim
+// toward the hand's side lets the elbow stay down (key-aim.js lean); the agent wrote lean on few of those keys and
+// re-keyed the elbows after QA had passed. So such a key leans FACE_LEAN deg (the most lean takes) unless it gives lean
+// or roll: its top (the rim) within FACE_NEAR m of the mouth at its frame, on the pose without the keys, on a body at
+// most SIP m tall (a cup, a can, a bottle: a bat's knob at the shoulder in a batting stance is not a sip, and a group's
+// height is unknown here); the rim stays where aim put it (leanPos). On the 84 first compiles of bench S6, S8 and S10 the agents wrote, the frames of BODY went
+// from 7231 to 5526, of FACE from 1102 to 839 and of WRIST from 1212 to 1007, and the takes with an elbow over the
+// shoulder (qa/arm-checks.js) from 39 to 31; the mouth goals missed on 694 frames instead of 623 (lean 35 within 0.2 m
+// saved fewer BODY and FACE frames and lost 46 mouth frames).
+import { add, scale, norm, dist } from "./compiler/math.js";
+
+export const FACE_LEAN = 45;
+const FACE_NEAR = 0.25, SIP = 0.3;
+/**
+ * Entry o of a body `top` m tall (0: a group) with FACE_LEAN on its aim keys (no lean, no roll) whose top (`top` m up
+ * the aim from pos) is within FACE_NEAR of the mouth at their frame; mouthAt(f) the mouth on the pose without the
+ * keys. o itself when none is, or the body is no sip (SIP).
+ */
+export function faceLeaned(o, top, mouthAt) {
+	if (!(top > 0 && top <= SIP)) return o;
+	let any = false;
+	const keys = o.keys.map(k => {
+		if (!k.aim || k.lean !== undefined || k.roll !== undefined || !(dist(add(k.pos, scale(norm(k.aim), top)), mouthAt(k.f)) < FACE_NEAR)) return k;
+		any = true;
+		return { ...k, lean: FACE_LEAN, leaned: true };
+	});
+	return any ? { ...o, keys } : o;
+}

package/src/motion3/fix/index.js

@@ -4,7 +4,9 @@
 //
 // spec.fix = { reach: true, slide: true, penetration: 0.02, self: true, retime: false } (false = all off)
 //   reach        wrist targets past the arm's reach go onto it through a soft knee (no snap);
-//                ankle targets past the leg's reach lower the hips just enough, eased in and out
+//                ankle targets past the leg's reach lower the hips just enough, eased in and out; a hand
+//                on a pinned target (a world or a scene object's anchor) that the straight arm misses brings
+//                the body to it: lean, hip shift, lower hips, the feet kept (reach-body.js, fixed.reachBody)
 //   slide        a sole under the floor lifts its ankle onto it (ground.js); a planted heel or ball
 //                that drifts less than 1 cm stays put, and a foot turning on its planted ball (heel
 //                up) or heel pivots about it whatever the drift; a flat planted foot (heel and ball
@@ -19,6 +21,7 @@
 //   grasp        a holding hand's fingers close on what it holds and the object rests in the hand (#816);
 //                false keeps the preset grip and the grab-frame offset
 import { lowerHips, armReach } from "./reach.js";
+import { reachBody } from "./reach-body.js";
 import { lockFeet } from "./slide.js";
 import { holdTurns } from "./turn.js";
 import { liftSoles } from "./ground.js";
@@ -46,6 +49,7 @@ export function applyFixes(out, fix, engine, { whole = true } = {}) {
 	if (fix.retime && whole) put("retime", retime(out, engine));
 	if (fix.slide) put("ground", liftSoles(out, engine));
 	if (fix.reach) put("reachLegs", lowerHips(out, engine));
+	if (fix.reach) put("reachBody", reachBody(out, engine));
 	if (fix.slide) put("slide", withTurns(holdTurns(out, engine), lockFeet(out, engine)));
 	// a pivot can hold a foot past the leg's reach: the hips go down for those frames too
 	if (fix.reach && fixed.slide?.pivots) put("reachLegs", mergeReach(fixed.reachLegs, lowerHips(out, engine)));