@rig-c/pose 0.8.1 → 0.9.0

package/README.md

@@ -31,7 +31,7 @@ Nothing is written until every check passes:
 | Check | Fails with |
 | --- | --- |
 | rig-c's gate is green with the rig as it is, and again with the animation in (`rigc build`) | `RIG_GATE_BASE`, `RIG_GATE`, then rigc's own `FAIL` lines |
-| every mapped bone **lands** on the angle the pose asks for, on every frame — the gated build is posed by rig-c's poser and measured (0.01° / 0.01 units) | `POSE_LANDS`: the bone, the worst error, the frame |
+| every mapped bone **lands** on the angle the pose asks for, on every frame — the gated build is posed by rig-c's poser and measured (0.01° / 0.01 units); with `--leg-scale`, every scaled bone's x axis on its asked scale (0.0001 of its setup length), and with either leg flag each ankle where the keys put it (0.01 units + 0.0001 × its setup distance from the hip) | `POSE_LANDS`: the bone, the worst error, the frame |
 | elbows and knees bend only the way they can: at every joint inside a chain, the inner angle stays on the side of the rest pose's | `POSE_BEND_ONE_WAY`: the chain, the joint, the frame, the angle |
 | every point the map needs is good on at least one frame | `POSE_POINT_NEVER_GOOD` |
 | the map resolves against the rig: bones exist, chains descend, aims descend | `MAP_*`, naming both sides |
@@ -50,9 +50,13 @@ and what the run cannot decide for you it lists:
 - `UNCOVERED` — with `alternates` in the map: every fold on a frame where no switch took the folding mesh off screen. This is the list of poses still to paint.
 - `RANGE` — a chain's `range` ([below](#a-joints-range-range)): a bone whose rotate key the pose asks past its range, outside every span of a set depicting its chain, is clamped at the limit; one line per run, with the frames, the seconds and the largest overflow. The demand for an alternate.
 - `ART-RANGE` — inside a set's span: a bone with a `drawn` angle in the set, turned from it past its limits — the set's `turn` for that bone (held at the limit) or, without one, its chain's `range` (the bone follows the pose). Listed as the pose asked it either way: the demand for another drawing of that set.
+- `LEG-SCALE` — with `--leg-scale` ([below](#the-legs-foreshortening-and-planted-feet)): per leg segment, its straight length, the spread of its picture length over it, and the frames clamped at each limit.
+- `PIVOT` — when the map translates a bone and has both legs: the translated bone's origin against its thigh roots' midpoint at setup, in units and hip widths — the pivot every hip turn swings the legs about.
+- `FEET` — when the map has both legs: the supports and jumps read off the reference ankles (planted or not), and on the posed build, outside the jumps, the lowest ankle's vertical range and each support span's worst vertical range and horizontal drift of the supporting ankle, in leg lengths.
+- `SHEAR` — with `--leg-scale`: every scaled bone and every bone under one, how far its art is sheared and how long its world axes are against setup. A reading.
 - `TURN` — a line across the body (hips, shoulders, eyes) shorter in the picture than 0.5 of its median length, or reversed, for at least 0.15 s: the body or the head turned. A reading of the pose, made whether or not the map uses the line; it changes no key. The demand for a turned-body drawing, as `END-ON` is for a foreshortened limb.
 
-`--report <file>` writes all of it as JSON (`rig-pose-report/1`): `options` (every figure the run used, `switchTolerance`, `switchMin` and `switchAt` included), `scale`, `holds`, `short`, `endOn`, `bends`, `flips`, `gate`, `landings`, `posture`, `folds`, and the demand lists:
+`--report <file>` writes all of it as JSON (`rig-pose-report/1`): `options` (every figure the run used, `switchTolerance`, `switchMin`, `switchAt`, `legScale` and `plantFeet` included), `scale`, `holds`, `short`, `endOn`, `bends`, `flips`, `gate`, `landings`, `posture`, `folds`, `legScale`, `pivot`, `feet` (`planted`, `legLength`, `floor`, `supports`, `jumps`, `changes`, and the posed `reading`), `shear`, and the demand lists:
 
 - `switches: [{ set, chains, slots, hides, offsets, from, to, frames: [first, last], distance: { max, median }, artTurn: { <bone>: { max, median } }, moved: { on, off } }]` — one per span shown; `from` is the first frame's time, `to` the time the base art comes back (the animation's end when the span runs to it), `distance` in degrees over the frames shown, `artTurn` |wrap(target − drawn)| in degrees per bone the set has a `drawn` angle for. `moved.on` is the boundary the span starts on (null from the first frame), `moved.off` the one the base art or the next set comes back on (null to the end), each `{ frame: [selected, keyed], frames, seconds, window: [first, last], speed: { old, new } }`: signed frames and seconds, the frames it could move to, and the speed in degrees per frame on the old and the new frame. A boundary between two sets is the same entry in both.
 - `uncovered: [{ slot, attachment, chains, times }]` — every entry of `folds` on the times its slot still shows that mesh, with the map's chains that move it (the deepest: the arm, not the trunk it hangs from). `rigc render --folds` reads only what the pose shows, so a mesh swapped out or hidden by a switch is not read on those frames at all; `uncovered` is the fold times less the switched ones.
@@ -65,7 +69,9 @@ Runs in `turns`, `range` and `artRange` merge across a gap of one frame, as `end
 
 `--smooth <n>` smooths each joint's positions, after its holds, with a Savitzky–Golay filter: at every frame, the least-squares cubic over the *n* frames around it (clipped at the ends), read at that frame. It is centred, so it moves no motion in time, and a cubic keeps the peaks a moving average flattens. `1` (the default) is none; otherwise *n* is odd and at least 5, since a cubic through 3 points passes through all three.
 
-**Use `--smooth 7` at 24 fps.** It was measured on a 13 s dance on a @rig-c/parts rig, read back from the gated build: the motion's timing did not move (speed cross-correlation lag 0 on the wrists, ankles and hip), the frame-to-frame second difference dropped 2.5× on the wrists, 1.7–2.1× on the ankles and 1.5× on the hip, and the hip's 95th-percentile speed fell to 0.85×. The criterion set beforehand, a 2× drop on every point, was not met on the hip. That criterion was flawed: the hip's second difference is mostly real motion, while the filter cuts white noise 4.6×. A measure that isolates noise is a later card, and the default stays off until it passes.
+**`--smooth 7` flattens the pelvis's rebound.** Measured on HQ's dancer with `--leg-scale 0.8,1.05 --plant-feet` ([#47](https://github.com/rig-c/pose/issues/47)): the rebound — the hip's peak upward acceleration at the bottom of each bounce, rig ÷ reference, median over a window, bar ≥ 0.7 — reads 0.40–0.52 with `--smooth 7` in every configuration measured (0.461 and 0.501 in the two windows, where `--smooth 1` reads 0.648 and 0.942). So the pelvis is read at `--smooth 1`, and `--smooth 7` is not advised for it. What follows is the earlier advice, for the limbs.
+
+**`--smooth 7` at 24 fps, for the limbs.** It was measured on a 13 s dance on a @rig-c/parts rig, read back from the gated build: the motion's timing did not move (speed cross-correlation lag 0 on the wrists, ankles and hip), the frame-to-frame second difference dropped 2.5× on the wrists, 1.7–2.1× on the ankles and 1.5× on the hip, and the hip's 95th-percentile speed fell to 0.85×. The criterion set beforehand, a 2× drop on every point, was not met on the hip. That criterion was flawed: the hip's second difference is mostly real motion, while the filter cuts white noise 4.6×. A measure that isolates noise is a later card, and the default stays off until it passes.
 
 **The flip guard.** A pose model can put a fast sweep of a limb into one frame — under motion blur it takes the elbow or the wrist for another point — and the rig then whips the limb round between two keys. Position smoothing cannot remove a step like that. So after holds and smoothing, and before the hinge check, every segment the map aims (not a `reach`, which is aimed later from posed positions) is read frame to frame: a turn greater than `--flip <deg>` from frame k−1 to frame k is spread. For the smallest h ≥ 1 that keeps every one-frame turn at or under the threshold, frames k−h … k+h−1 are replaced by the straight line from frame k−h−1 to frame k+h, the turn's own way round. It is centred, so the step happens when the pose put it, over 2h frames, and both ends keep the pose's angles. A window that would cross the first or last frame stops there and the line says so; two windows that overlap become one. `--flip off` keeps every turn. The report lists each spread under `flips`.
 
@@ -84,6 +90,25 @@ Both have a meaningless direction; only the first is a pose the rig cannot draw.
 
 Re-checked on the exam01 test rig with `--short 0.35 --flip 90 --bends clamp`. On the second sequence the three spreads the flip guard made out of end-on segments are SHORT holds now, not FLIPs: right upper arm 399–400, right thigh 368–369, right shin 368–371. Of the flip guard's other spreads only one is left, the left forearm at 322–323; every other one fell on frames under the cutoff and is a SHORT hold instead. No guarded bone of the gated build turns more than 81.4° in one frame (85.1° with `--flip 90` alone), and every bone lands. `endOn` there lists the right upper arm (395–401) and the right shin (365–370). It does not list the right thigh, which is under 0.35 on one frame only (369, 0.16). The plan before the run expected the thigh too, and that expectation was wrong. On the dance `endOn` lists exactly S2's left upper arm (30–37); the three FLIPs are #15's, the largest one-frame turn is 78.2°, and every bone lands. A first implementation also held the lines across the body. It listed the eye line (head in profile) and the hip line (body side-on) as end-on, and holding the hip line narrowed the rig's hip tilt range to 39.3° against the pose's 125.2°. The cutoff was never measured on those lines, so they are excluded; with them out the rig reads 125.2° again. The default stays off: a default needs its own criterion and a third sequence.
 
+### The legs: foreshortening and planted feet
+
+A knee bending toward the camera is seen from the front only as a shorter leg, and a rig with rigid legs cannot lower its hip without lifting its feet ([#47](https://github.com/rig-c/pose/issues/47)). Two flags, both off by default:
+
+**`--leg-scale <min,max>`** scales each mapped leg segment (two of one side's hip, knee and ankle) along its own x axis — a `scalex` key — by its picture length on the frame over its **straight length**, the 95th percentile of its picture length over the sequence, clamped to [min, max]. The card's range is `0.8,1.05`. A segment the map aims other than `"x"` is refused (`LEGS_MAP`). `LEG-SCALE` lists each segment's frames clamped at either limit.
+
+rig-c's `scalex` multiplies the bone's x axis, and a child with the `normal` inherit mode takes its parent's whole world matrix. So under a thigh scaled by s, a shin at angle φ in the thigh's axes points at atan2(sin φ, s·cos φ), and is itself scaled by |(s·cos φ, sin φ)|. The rotate key `turn − turn above` assumes unit scale. A mapped bone under a scaled bone is therefore keyed through its parent's posed matrix: a `rotate` key k and a `scalex` key s' make its local matrix R(k) · L · diag(s', 1), L its setup local matrix, and k and s' are solved so its world x axis lands on its target at the scale asked. On HQ's dancer the unit-scale formula missed the shins by up to 2.4°, their length by 0.16 of setup and the ankles by 38 units; solved, every bone lands. The child's art is still sheared by its parent's scale, and a bone under it (a foot) is squashed along the shin: `SHEAR` reads both.
+
+**`--plant-feet`** places the hip so the supporting foot stays where it took support, through the posed (and scaled) legs, instead of moving it by the pose's mid_hip travel:
+
+- The supporting foot is the one whose reference ankle is lower in the picture. It changes only when the other ankle has been at least **0.02 leg lengths** lower for at least **0.1 s** (timed as `END-ON` runs are); a leg length is each side's median picture length hip → ankle, and the switch compares against their mean.
+- The new support is held where it is on the frame it takes over, and the hip blends from the old derivation to the new over **3 frames**.
+- A **jump** — both reference ankles **and** mid_hip more than **0.05** leg lengths above their **rolling floor**, the 95th-percentile picture y over ±1.0 s around the frame, for at least **2 frames** — releases the plant: the hip follows the pose's travel from where it was, and re-plants on landing (blended the same way). The body has to lift: an ankle's picture y drifts with depth, and under one floor for the whole sequence HQ's dancer standing still (frames 0–29 and 277–312, mid_hip moving 10 and 14 px) read as jumping, 152–155 of 313 frames in all.
+- A **step** releases the plant too: while the supporting ankle moves more than **0.03** leg lengths a frame, the other foot takes support if it is planted (not itself released or moving), and otherwise the hip follows the pose's travel. The released ankle may support again once it has moved less than **0.01** leg lengths a frame for **2 frames**. On the dancer the plant held the supporting ankle through a real step (frames 176–181, 579 → 718 px) and threw the hip sideways.
+- `FEET` lists the supports, the jumps and the steps (each with the side, its frames, who took support and where it re-planted); the report carries them under `feet` (`supports`, `jumps`, `steps`, `changes`).
+- The map needs one chain ending at each ankle whose last bone is aimed `"x"` (the ankle is that bone's tip), and a `translate` the legs hang from (`LEGS_MAP`). A `range`, or a set's `turn` or `offsets`, on a bone between the hip and an ankle is refused (`LEGS_RANGE`): the plant is derived before the range clamp, and a clamp after it would move the planted foot.
+
+Both are checked on the gated build: every scale lands, each ankle lands where the keys put it, and the hip's origin where the plant put it. The figures were fixed in #47 before the dancer was measured; the defaults stay off until they pass.
+
 Exit codes: `0` written, `1` refused (every reason printed, nothing written), `2` bad invocation. `rig-pose --help` has every flag.
 
 ## The pose: `rig-pose-sequence/1`
@@ -284,7 +309,7 @@ The answer is a second drawing of the arm for each of those poses, shown in plac
 
 - **Extract poses from video.** The input is joint positions; how you get them (a pose model, a dataset, a hand) is yours.
 - **Turn the body.** 2D only: a segment pointing at the camera foreshortens, and the rig cannot. The direction is matched; the length is not.
-- **Plant feet** beyond what the pose gives, **hands and fingers** (no bones for them yet, rig-c/parts#171), mobile.
+- **Plant feet** beyond what the pose gives (until `--plant-feet`, [#47](https://github.com/rig-c/pose/issues/47)), **hands and fingers** (no bones for them yet, rig-c/parts#171), mobile.
 
 ## Licence
 

package/cli.ts

@@ -51,6 +51,19 @@ retarget
   --bends refuse|clamp  a hinge (elbow, knee: any joint inside a chain) bent the wrong way refuses
                         the run (default), or is straightened on that frame and listed
   --bend-tolerance <d>  degrees past straight a hinge may bend the wrong way before it counts (default: 0)
+  --leg-scale <min,max>|off
+                        each leg segment (two of one side's hip, knee, ankle) is scaled along its own x axis
+                        (a scalex key) by its picture length over its straight length — the 95th percentile of
+                        its picture length — clamped to [min, max], listed as LEG-SCALE with the frames clamped;
+                        a bone under a scaled one is keyed through its parent's scale (default: off; 0.8,1.05
+                        is the card's range, rig-c/pose#47)
+  --plant-feet          the hip is placed so the supporting foot stays where it took support: the lower ankle
+                        in the picture, changing after the other has been 0.02 leg lengths lower for 0.1 s,
+                        blended over 3 frames; a jump (both ankles and mid_hip 0.05 leg lengths above their
+                        rolling floor — the 95th-percentile y over ±1 s — for ≥ 2 frames) follows the pose's
+                        travel and re-plants on landing; a supporting ankle moving > 0.03 leg lengths a frame
+                        releases its plant to the other foot, or to the pose's travel, until it is still
+                        (< 0.01 for 2 frames) (FEET lines)
   --switch-tolerance <d>  a set of alternate drawings (the map's "alternates") may show on a frame where
                         every segment of its chains is within d degrees of its key skeleton (default: 25)
   --switch-min <s>      a run of one set shorter than s seconds is dropped (default: 0.25)
@@ -155,8 +168,18 @@ function shortOf(f: Map<string, string>): number | 'off' {
   return num(f, 'short', 0.35, (v) => v > 0 && v < 1, 'off, or a fraction in (0, 1) of the segment\'s median picture length');
 }
 
+function legScaleOf(f: Map<string, string>): [number, number] | 'off' {
+  const v = f.get('leg-scale');
+  if (v === undefined || v === 'off') return 'off';
+  const parts = v.split(',').map((x) => (x.trim() === '' ? NaN : Number(x)));
+  if (parts.length !== 2 || !parts.every((x) => Number.isFinite(x)) || !(parts[0]! > 0) || parts[0]! > 1 || parts[1]! < 1) {
+    throw new Usage(`--leg-scale is "${v}"; it must be off, or min,max with 0 < min ≤ 1 ≤ max (the scale of a leg segment against its straight length, e.g. 0.8,1.05)`);
+  }
+  return [parts[0]!, parts[1]!];
+}
+
 function retargetArgs(argv: string[]): RetargetArgs {
-  const f = parseFlags(argv, ['rig', 'map', 'pose', 'out', 'name', 'person', 'base-motion', 'images', 'min-score', 'smooth', 'flip', 'short', 'bends', 'bend-tolerance', 'switch-tolerance', 'switch-min', 'switch-at', 'profile', 'build', 'render', 'report'], ['coco']);
+  const f = parseFlags(argv, ['rig', 'map', 'pose', 'out', 'name', 'person', 'base-motion', 'images', 'min-score', 'smooth', 'flip', 'short', 'bends', 'bend-tolerance', 'switch-tolerance', 'switch-min', 'switch-at', 'profile', 'build', 'render', 'report', 'leg-scale'], ['coco', 'plant-feet']);
   const bends = f.get('bends') ?? 'refuse';
   if (bends !== 'refuse' && bends !== 'clamp') throw new Usage(`--bends is "${bends}"; it must be refuse or clamp`);
   const switchAt = f.get('switch-at') ?? 'first';
@@ -179,6 +202,8 @@ function retargetArgs(argv: string[]): RetargetArgs {
     smooth: smoothOf(f),
     flip: flipOf(f),
     short: shortOf(f),
+    legScale: legScaleOf(f),
+    plantFeet: f.has('plant-feet'),
     bends,
     bendTolerance: num(f, 'bend-tolerance', 0, (n) => n >= 0 && n < 180, 'degrees in [0, 180)'),
     switchTolerance: num(f, 'switch-tolerance', 25, (n) => n >= 0 && n < 180, 'degrees in [0, 180)'),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rig-c/pose",
-  "version": "0.8.1",
+  "version": "0.9.0",
   "description": "Puts motion from a body-18 pose sequence onto a rig built with rig-c: bone keys in rig-c's motion format, checked through rig-c's gate before anything is written. A CLI for agents that cannot see the rig.",
   "type": "module",
   "bin": {

package/src/legs.ts

@@ -0,0 +1,488 @@
+/**
+ * The legs (rig-c/pose#47): foreshortening by length, and the hip derived from
+ * the supporting foot. Pure — no file, no clock, no process.
+ *
+ * **Leg scale.** A knee bending toward the camera is seen from the front only
+ * as a shorter leg. Each mapped leg segment (two of one side's hip, knee and
+ * ankle) is scaled along its own x axis (`scalex`): its picture length on the
+ * frame over its *straight length*, the 95th percentile of its picture length
+ * over the sequence, clamped to a declared range. The frames clamped are listed.
+ *
+ * **A scaled parent turns its child.** rig-c's `scalex` multiplies the bone's
+ * x axis, and a child with the `normal` inherit mode takes the parent's whole
+ * world matrix — so under a thigh scaled by s, a shin at angle φ in the thigh's
+ * axes points at atan2(sin φ, s·cos φ), not φ, and its own length is scaled by
+ * |(s·cos φ, sin φ)|. The rotate key `turn − turn above` assumes unit scale. A
+ * mapped bone below a scaled bone is therefore keyed through its parent's
+ * posed matrix (`posePath`): with rig-c's semantics, a `rotate` key k and a
+ * `scalex` key s' make the bone's local matrix R(k) · L · diag(s', 1), L its
+ * setup local matrix (from rig-c's setup world matrices), so k and s' are the
+ * ones that put its world x axis on the target angle at the asked length. Its
+ * art is still sheared by the parent's scale; that is measured, not hidden
+ * (`shear` in the report).
+ *
+ * **Planted feet.** The hip is no longer the pose's mid_hip travel scaled. On
+ * every frame one foot supports: the one whose reference ankle is lower in the
+ * picture, changing only when the other ankle has been ≥ `PLANT_SWITCH` leg
+ * lengths lower for ≥ `PLANT_SWITCH_SECONDS`. The supporting foot is held where
+ * it was on the frame it took support, and the hip is placed so it stays there,
+ * through the posed (scaled) legs. A change of support blends the two
+ * derivations over `PLANT_BLEND` frames. A jump — both ankles and mid_hip more
+ * than `JUMP_RISE` leg lengths above their rolling floor (the 95th-percentile
+ * picture y over ± `FLOOR_SECONDS`), for ≥ `JUMP_FRAMES` frames — releases the
+ * plant: the hip follows the pose's travel from where it was, and re-plants on
+ * landing. A step does too: while the supporting ankle moves more than
+ * `STEP_SPEED` leg lengths a frame its plant is released, the other foot takes
+ * support if it is planted (not released, not moving) and otherwise the hip
+ * follows the pose; the released ankle may support again once it has moved
+ * less than `STILL_SPEED` for `STILL_FRAMES` frames (rig-c/pose#47, round 2).
+ * The floor is rolling because an ankle's picture y drifts with depth: under
+ * one floor for the sequence, HQ's dancer standing still read as jumping.
+ */
+import type { Chain, JointMap, Rest } from './map.ts';
+
+type Pt = [number, number];
+/** A world 2×2: columns (a, c) — the x axis — and (b, d) — the y axis. */
+export type M2 = [number, number, number, number];
+
+const DEG = 180 / Math.PI;
+
+/** A change of support needs the other ankle this many leg lengths lower … */
+export const PLANT_SWITCH = 0.02;
+/** … for at least this long, in seconds (first frame's time to the end of the last, as END-ON times a run). */
+export const PLANT_SWITCH_SECONDS = 0.1;
+/** A change of support (and a landing) blends the hip over this many frames. */
+export const PLANT_BLEND = 3;
+/** Both ankles and mid_hip more than this many leg lengths above their rolling floors: a jump. */
+export const JUMP_RISE = 0.05;
+/** A rolling floor: this percentile of the picture y around the frame. */
+export const FLOOR_PERCENTILE = 0.95;
+/** A segment's straight length: this percentile of its picture length over the sequence. */
+export const STRAIGHT_PERCENTILE = 0.95;
+
+export type Side = 'r' | 'l';
+export const SIDES: readonly Side[] = ['r', 'l'];
+
+/** A segment of one side's hip, knee and ankle. */
+export function isLegSegment(a: string, b: string): boolean {
+  const side = (x: string) => (x.startsWith('r_') ? 'r' : x.startsWith('l_') ? 'l' : null);
+  if (a === b || side(a) === null || side(a) !== side(b)) return false;
+  const LEG = ['hip', 'knee', 'ankle'];
+  return LEG.includes(a.slice(2)) && LEG.includes(b.slice(2));
+}
+
+/** Linear-interpolated percentile (numpy's default) of the finite values. */
+export function percentile(xs: readonly number[], q: number): number {
+  const s = xs.filter((x) => Number.isFinite(x)).sort((a, b) => a - b);
+  if (s.length === 0) return NaN;
+  const pos = q * (s.length - 1);
+  const lo = Math.floor(pos);
+  const hi = Math.min(s.length - 1, lo + 1);
+  return s[lo]! + (s[hi]! - s[lo]!) * (pos - lo);
+}
+
+export interface Leg {
+  side: Side;
+  chain: Chain;
+  /** The chain's last bone: its x axis ends at the ankle (`<bone>:tip`). */
+  ankleBone: string;
+}
+
+/**
+ * Each side's leg: the (non-reach) chain whose last joint is that side's
+ * ankle. Every refusal names what it found.
+ */
+export function legsOf(map: JointMap, why: string): { legs: Record<Side, Leg> } | { problems: string[] } {
+  const problems: string[] = [];
+  const legs: Partial<Record<Side, Leg>> = {};
+  for (const side of SIDES) {
+    const ankle = `${side}_ankle`;
+    const found = map.chains.filter((c) => !c.reach && c.joints[c.joints.length - 1] === ankle);
+    if (found.length !== 1) {
+      problems.push(`${why} needs one chain ending at "${ankle}" (its last bone's x axis ends at the ankle); the map has ${found.length === 0 ? 'none' : found.map((c) => `"${c.name}"`).join(', ')}`);
+      continue;
+    }
+    const chain = found[0]!;
+    const k = chain.bones.length - 1;
+    if (chain.aim[k] !== 'x') problems.push(`${why}: chain "${chain.name}" ends at "${ankle}" with bone "${chain.bones[k]}" aimed ${JSON.stringify(chain.aim[k])}; the ankle is read as that bone's tip, so it must be aimed along its own x axis ("x")`);
+    legs[side] = { side, chain, ankleBone: chain.bones[k]! };
+  }
+  return problems.length > 0 ? { problems } : { legs: legs as Record<Side, Leg> };
+}
+
+// --- 2×2 -------------------------------------------------------------------
+
+const mul = (p: M2, q: M2): M2 => [p[0] * q[0] + p[1] * q[2], p[0] * q[1] + p[1] * q[3], p[2] * q[0] + p[3] * q[2], p[2] * q[1] + p[3] * q[3]];
+const inv = (m: M2): M2 => {
+  const det = m[0] * m[3] - m[1] * m[2];
+  return [m[3] / det, -m[1] / det, -m[2] / det, m[0] / det];
+};
+const apply = (m: M2, v: Pt): Pt => [m[0] * v[0] + m[1] * v[1], m[2] * v[0] + m[3] * v[1]];
+const rot = (deg: number): M2 => {
+  const r = deg / DEG;
+  return [Math.cos(r), -Math.sin(r), Math.sin(r), Math.cos(r)];
+};
+const scaleX = (s: number): M2 => [s, 0, 0, 1];
+export const restMatrix = (rest: Rest, bone: string): M2 => {
+  const b = rest.get(bone)!;
+  return [b.a, b.b, b.c, b.d];
+};
+
+/**
+ * How one mapped bone is posed on a frame: its world turn from setup (the
+ * target less the rest angle), its target (the world angle of its aim), whether
+ * its aim is its own x axis, and the scale asked of its x axis (1: none).
+ */
+export interface Posing {
+  turn: number;
+  target: number;
+  aimX: boolean;
+}
+
+export interface PathPose {
+  /** Each bone's posed origin, relative to the first bone's origin. */
+  origin: Map<string, Pt>;
+  /** Each bone's posed world 2×2. */
+  m: Map<string, M2>;
+  /** For a mapped bone under a scaled bone: the rotate key (degrees, wrapped) and the scalex key that land it. */
+  solved: Map<string, { rotate: number; scale: number }>;
+}
+
+/**
+ * Pose a path of bones, parents first, the first the path's top (its origin is
+ * (0, 0)). A mapped bone with no scaled bone above it turns rigidly from setup
+ * (R(turn) · setup world · diag(scale, 1)); a mapped bone under a scaled bone
+ * is solved through its parent's posed matrix (the header); an unmapped bone
+ * keeps its setup local matrix. Every setup matrix and origin is rig-c's.
+ */
+export function posePath(rest: Rest, path: readonly string[], posing: (b: string) => Posing | null, scaleOf: (b: string) => number | null): PathPose | string {
+  const origin = new Map<string, Pt>();
+  const m = new Map<string, M2>();
+  const solved = new Map<string, { rotate: number; scale: number }>();
+  const scaledAbove = new Set<string>();
+  for (const b of path) {
+    const rb = rest.get(b)!;
+    const W0 = restMatrix(rest, b);
+    const pz = posing(b);
+    const s = scaleOf(b) ?? 1;
+    const p = rb.parent;
+    const top = origin.size === 0;
+    if (top || p === null || !m.has(p)) {
+      if (!top) return `bone "${b}" is on the path but its parent "${p}" is not`;
+      origin.set(b, [0, 0]);
+      m.set(b, mul(mul(rot(pz?.turn ?? 0), W0), scaleX(s)));
+      if (scaleOf(b) !== null) scaledAbove.add(b);
+      continue;
+    }
+    const Wp0 = restMatrix(rest, p);
+    const Wp = m.get(p)!;
+    const rp = rest.get(p)!;
+    const local = apply(inv(Wp0), [rb.worldX - rp.worldX, rb.worldY - rp.worldY]);
+    const po = origin.get(p)!;
+    const o = apply(Wp, local);
+    origin.set(b, [po[0] + o[0], po[1] + o[1]]);
+    const L0 = mul(inv(Wp0), W0);
+    const under = scaledAbove.has(p);
+    if (pz === null) m.set(b, mul(Wp, L0));
+    else if (!under) m.set(b, mul(mul(rot(pz.turn), W0), scaleX(s)));
+    else {
+      if (!pz.aimX) return `bone "${b}" is mapped under a scaled bone and aimed other than along its x axis; only an "x" aim is solved through a scaled parent`;
+      const len0 = Math.hypot(W0[0], W0[2]);
+      const X: Pt = [s * len0 * Math.cos(pz.target / DEG), s * len0 * Math.sin(pz.target / DEG)];
+      const v = apply(inv(Wp), X);
+      const l0: Pt = [L0[0], L0[2]];
+      const k = (Math.atan2(v[1], v[0]) - Math.atan2(l0[1], l0[0])) * DEG;
+      const sk = Math.hypot(v[0], v[1]) / Math.hypot(l0[0], l0[1]);
+      m.set(b, mul(mul(mul(Wp, rot(k)), L0), scaleX(sk)));
+      solved.set(b, { rotate: k, scale: sk });
+    }
+    if (under || scaleOf(b) !== null) scaledAbove.add(b);
+  }
+  return { origin, m, solved };
+}
+
+/** Where `bone`'s x axis ends on a posed path: its origin plus its world x column times its length. */
+export function tipOf(rest: Rest, pose: PathPose, bone: string): Pt {
+  const o = pose.origin.get(bone)!;
+  const w = pose.m.get(bone)!;
+  const len = rest.get(bone)!.length;
+  return [o[0] + w[0] * len, o[1] + w[2] * len];
+}
+
+/** The bones from `top` down to each of `ends` (inclusive), parents first; null when an end does not descend from top. */
+export function pathFrom(rest: Rest, top: string, ends: readonly string[]): string[] | null {
+  const set = new Set<string>([top]);
+  for (const e of ends) {
+    const up: string[] = [];
+    let b: string | null = e;
+    while (b !== null && b !== top) {
+      up.push(b);
+      b = rest.get(b)!.parent;
+    }
+    if (b === null) return null;
+    for (const x of up) set.add(x);
+  }
+  const depth = (b: string): number => {
+    let d = 0;
+    for (let a = rest.get(b)!.parent; a !== null; a = rest.get(a)!.parent) d++;
+    return d;
+  };
+  return [...set].sort((x, y) => depth(x) - depth(y) || (x < y ? -1 : x > y ? 1 : 0));
+}
+
+/** The root of `b`'s ancestry. */
+export function rootOf(rest: Rest, b: string): string {
+  let x = b;
+  for (let p = rest.get(x)!.parent; p !== null; p = rest.get(x)!.parent) x = p;
+  return x;
+}
+
+// --- leg scale -------------------------------------------------------------
+
+export interface LegScale {
+  chain: string;
+  bone: string;
+  joints: [string, string];
+  /** The straight length: the 95th percentile of the segment's picture length, px. */
+  straight: number;
+  /** The picture length over the straight length, before the clamp: lowest, median, highest. */
+  ratio: { min: number; median: number; max: number };
+  /** The range the scale is clamped to. */
+  limits: [number, number];
+  /** Runs of frames clamped at the low and at the high limit. */
+  low: Array<[number, number]>;
+  high: Array<[number, number]>;
+  /** The scale keyed on each frame (clamped). */
+  scale: number[];
+}
+
+/** One segment's scale per frame: picture length ÷ its 95th percentile, clamped; and the runs clamped. */
+export function legScaleOf(lengths: readonly number[], limits: [number, number]): Omit<LegScale, 'chain' | 'bone' | 'joints'> {
+  const straight = percentile(lengths, STRAIGHT_PERCENTILE);
+  const ratio = lengths.map((l) => l / straight);
+  const scale = ratio.map((r) => Math.min(Math.max(r, limits[0]), limits[1]));
+  const sorted = [...ratio].sort((a, b) => a - b);
+  const mid = sorted.length >> 1;
+  const median = sorted.length % 2 === 1 ? sorted[mid]! : (sorted[mid - 1]! + sorted[mid]!) / 2;
+  return {
+    straight,
+    ratio: { min: sorted[0]!, median, max: sorted[sorted.length - 1]! },
+    limits,
+    low: runs(ratio.map((r) => r < limits[0])),
+    high: runs(ratio.map((r) => r > limits[1])),
+    scale,
+  };
+}
+
+function runs(flags: readonly boolean[]): Array<[number, number]> {
+  const out: Array<[number, number]> = [];
+  for (let i = 0; i < flags.length; i++) {
+    if (!flags[i]) continue;
+    let j = i;
+    while (j + 1 < flags.length && flags[j + 1]) j++;
+    out.push([i, j]);
+    i = j;
+  }
+  return out;
+}
+
+// --- supports, jumps and steps ---------------------------------------------
+
+/** The points a jump reads, each above its rolling floor by more than `JUMP_RISE` leg lengths. */
+export const JUMP_POINTS = ['r_ankle', 'l_ankle', 'mid_hip'] as const;
+/** A jump lasts at least this many frames. */
+export const JUMP_FRAMES = 2;
+/** A rolling floor: `FLOOR_PERCENTILE` of the picture y over ± this many seconds around the frame. */
+export const FLOOR_SECONDS = 1.0;
+/** A supporting ankle moving more than this many leg lengths a frame is stepping: its plant is released. */
+export const STEP_SPEED = 0.03;
+/** A released ankle re-plants once it moves less than this many leg lengths a frame … */
+export const STILL_SPEED = 0.01;
+/** … for this many frames. */
+export const STILL_FRAMES = 2;
+
+export interface Step {
+  side: Side;
+  /** First frame the ankle moved past `STEP_SPEED`, and the last frame before it re-planted (or the last frame). */
+  frames: [number, number];
+  /** The frame it re-planted on (still for `STILL_FRAMES`), or null if it never did. */
+  replant: number | null;
+  /** The side that took support when it released, or null: the hip followed the pose's travel. */
+  to: Side | null;
+}
+
+export interface Feet {
+  /** Each side's median picture length hip → ankle, px; the unit of every threshold below (mid_hip: their mean). */
+  legLength: Record<Side, number>;
+  /** Per frame: the side that supports, or null (a jump, or a step with no other foot planted). */
+  support: Array<Side | null>;
+  /** Runs of one supporting side: [first, last] frames and the side. */
+  supports: Array<{ side: Side; frames: [number, number] }>;
+  /** Runs of jump frames. */
+  jumps: Array<[number, number]>;
+  /** Every release of a supporting foot by a step. */
+  steps: Step[];
+  /** The frames a change of support (or a landing, or a re-plant) was keyed on: the blend starts there. */
+  changes: Array<{ frame: number; from: Side | null; to: Side }>;
+}
+
+/** Each frame's rolling floor of a picture-y series: its `FLOOR_PERCENTILE` over the frames within ± `FLOOR_SECONDS`. */
+export function rollingFloor(ys: readonly number[], times: readonly number[]): number[] {
+  return ys.map((_, i) => {
+    const w: number[] = [];
+    for (let j = 0; j < ys.length; j++) if (Math.abs(times[j]! - times[i]!) <= FLOOR_SECONDS + 1e-9) w.push(ys[j]!);
+    return percentile(w, FLOOR_PERCENTILE);
+  });
+}
+
+/**
+ * Which foot supports on each frame, from the reference ankles and hips (picture
+ * px, y down) — the header's rules. `times` are the key times; `secondsOf`
+ * times a run of frames as the rest of the retarget does.
+ */
+export function supportsOf(ankle: Record<Side, readonly Pt[]>, hip: Record<Side, readonly Pt[]>, times: readonly number[], secondsOf: (run: [number, number]) => number): Feet {
+  const n = ankle.r.length;
+  const legLength = {} as Record<Side, number>;
+  for (const s of SIDES) legLength[s] = percentile(ankle[s].map((a, i) => Math.hypot(a[0] - hip[s][i]![0], a[1] - hip[s][i]![1])), 0.5);
+  const mean = (legLength.r + legLength.l) / 2;
+  // A jump: both ankles and mid_hip above their rolling floors, for ≥ JUMP_FRAMES frames.
+  const midY = hip.r.map((h, i) => (h[1] + hip.l[i]![1]) / 2);
+  const rises: Array<{ ys: number[]; unit: number }> = [
+    { ys: ankle.r.map((a) => a[1]), unit: legLength.r },
+    { ys: ankle.l.map((a) => a[1]), unit: legLength.l },
+    { ys: midY, unit: mean },
+  ];
+  const up = rises.map(({ ys, unit }) => {
+    const floor = rollingFloor(ys, times);
+    return ys.map((y, i) => floor[i]! - y > JUMP_RISE * unit);
+  });
+  const lifted = Array.from({ length: n }, (_, i) => up.every((u) => u[i]));
+  const jumps = runs(lifted).filter(([a, b]) => b - a + 1 >= JUMP_FRAMES);
+  const jump = new Array<boolean>(n).fill(false);
+  for (const [a, b] of jumps) for (let i = a; i <= b; i++) jump[i] = true;
+  // Ankle speeds, leg lengths a frame (0 on the first frame).
+  const speed = {} as Record<Side, number[]>;
+  for (const s of SIDES) speed[s] = ankle[s].map((a, i) => (i === 0 ? 0 : Math.hypot(a[0] - ankle[s][i - 1]![0], a[1] - ankle[s][i - 1]![1]) / legLength[s]));
+  const moving = (s: Side, i: number) => speed[s][i]! > STEP_SPEED;
+  const still = (s: Side, i: number) => {
+    for (let k = i - STILL_FRAMES + 1; k <= i; k++) if (k >= 0 && !(speed[s][k]! < STILL_SPEED)) return false;
+    return true;
+  };
+  const support: Array<Side | null> = new Array<Side | null>(n).fill(null);
+  const changes: Feet['changes'] = [];
+  const steps: Step[] = [];
+  const open: Partial<Record<Side, Step>> = {};
+  let cur: Side | null = null;
+  let lowerFrom = -1;
+  const lower = (cands: Side[], i: number): Side => (cands.length === 2 ? (ankle.l[i]![1] > ankle.r[i]![1] ? 'l' : 'r') : cands[0]!);
+  for (let i = 0; i < n; i++) {
+    // A released ankle re-plants once it has been still for STILL_FRAMES frames.
+    for (const s of SIDES) {
+      const st = open[s];
+      if (st !== undefined && still(s, i)) {
+        st.replant = i;
+        st.frames[1] = i - 1;
+        delete open[s];
+      }
+    }
+    if (jump[i]) {
+      cur = null;
+      lowerFrom = -1;
+      continue;
+    }
+    const free = (s: Side) => open[s] === undefined && !moving(s, i);
+    if (cur !== null && moving(cur, i)) {
+      const other: Side = cur === 'r' ? 'l' : 'r';
+      const to: Side | null = free(other) ? other : null;
+      const st: Step = { side: cur, frames: [i, n - 1], replant: null, to };
+      steps.push(st);
+      open[cur] = st;
+      if (to !== null) changes.push({ frame: i, from: cur, to });
+      cur = to;
+      lowerFrom = -1;
+    } else if (cur === null) {
+      const cands = SIDES.filter(free);
+      if (cands.length > 0) {
+        cur = lower(cands, i);
+        changes.push({ frame: i, from: null, to: cur });
+        lowerFrom = -1;
+      }
+    } else {
+      const other: Side = cur === 'r' ? 'l' : 'r';
+      if (free(other) && ankle[other][i]![1] - ankle[cur][i]![1] >= PLANT_SWITCH * mean) {
+        if (lowerFrom < 0) lowerFrom = i;
+        if (secondsOf([lowerFrom, i]) >= PLANT_SWITCH_SECONDS - 1e-9) {
+          changes.push({ frame: i, from: cur, to: other });
+          cur = other;
+          lowerFrom = -1;
+        }
+      } else lowerFrom = -1;
+    }
+    support[i] = cur;
+  }
+  const supports: Feet['supports'] = [];
+  for (let i = 0; i < n; i++) {
+    const s = support[i];
+    if (s === null || s === undefined) continue;
+    const last = supports[supports.length - 1];
+    if (last !== undefined && last.side === s && last.frames[1] === i - 1) last.frames[1] = i;
+    else supports.push({ side: s, frames: [i, i] });
+  }
+  return { legLength, support, supports, jumps, steps, changes };
+}
+
+/**
+ * The hip's world origin on every frame, from the supporting foot (header).
+ * `offset(i, side)` is the ankle's posed position relative to the hip's origin
+ * on frame i; `travel(i)` the pose's own travel of the hip from frame 0, world.
+ * `start` is the hip's origin on frame 0 (its setup origin).
+ */
+export function plantHip(feet: Feet, offset: (i: number, s: Side) => Pt, travel: (i: number) => Pt, start: Pt): Pt[] {
+  const n = feet.support.length;
+  const hip: Pt[] = [];
+  /** How the hip is derived on a frame: held over a foot's anchor, or carried by the pose's travel from a frame's hip. */
+  type Mode = { kind: 'plant'; side: Side; anchor: Pt } | { kind: 'travel'; from: number; at: Pt };
+  const of = (mode: Mode, i: number): Pt => {
+    if (mode.kind === 'plant') {
+      const o = offset(i, mode.side);
+      return [mode.anchor[0] - o[0], mode.anchor[1] - o[1]];
+    }
+    const a = travel(i);
+    const b = travel(mode.from);
+    return [mode.at[0] + a[0] - b[0], mode.at[1] + a[1] - b[1]];
+  };
+  let mode: Mode | null = null;
+  let from: Mode | null = null;
+  let blendAt = -1;
+  for (let i = 0; i < n; i++) {
+    const s = feet.support[i] ?? null;
+    if (i === 0) {
+      if (s === null) mode = { kind: 'travel', from: 0, at: start };
+      else {
+        const o = offset(0, s);
+        mode = { kind: 'plant', side: s, anchor: [start[0] + o[0], start[1] + o[1]] };
+      }
+    } else if (s === null && mode!.kind === 'plant') {
+      mode = { kind: 'travel', from: i - 1, at: hip[i - 1]! };
+      from = null;
+      blendAt = -1;
+    } else if (s !== null && (mode!.kind === 'travel' || (mode as { side: Side }).side !== s)) {
+      // The new support is held where it is on this frame, under the hip the old derivation gives here.
+      const here = of(mode!, i);
+      const o = offset(i, s);
+      from = mode;
+      mode = { kind: 'plant', side: s, anchor: [here[0] + o[0], here[1] + o[1]] };
+      blendAt = i;
+    }
+    const to = of(mode!, i);
+    if (from !== null && i - blendAt < PLANT_BLEND) {
+      const w = (i - blendAt + 1) / (PLANT_BLEND + 1);
+      const f = of(from, i);
+      hip.push([f[0] + (to[0] - f[0]) * w, f[1] + (to[1] - f[1]) * w]);
+    } else {
+      from = null;
+      hip.push(to);
+    }
+  }
+  return hip;
+}

package/src/retarget.ts

@@ -64,11 +64,13 @@ import { screenToSpineDegrees } from 'rig-c/transform';
 import type { Body18 } from './joints.ts';
 import { isBody18, VIRTUAL } from './joints.ts';
 import type { Chain, JointMap, Rest, RigSlots } from './map.ts';
-import { aimAngle, rigPoint } from './map.ts';
+import { aimAngle, descends, rigPoint } from './map.ts';
 import type { Joint } from './pose.ts';
-import { Problems } from './problems.ts';
+import { Problems, Refusal } from './problems.ts';
 import type { ArtRange, SlotTrack, Switch, SwitchOptions } from './switch.ts';
 import { clampArt, coveredChains, measureArt, overflow, RANGE_SLACK, runsOf, selectSwitches } from './switch.ts';
+import type { Feet, LegScale, PathPose, Posing, Side } from './legs.ts';
+import { isLegSegment, legScaleOf, legsOf, pathFrom, plantHip, posePath, rootOf, SIDES, supportsOf, tipOf } from './legs.ts';
 
 const DEG = 180 / Math.PI;
 
@@ -85,6 +87,10 @@ export interface RetargetOptions extends SwitchOptions {
   flip: number | 'off';
   /** A segment shorter in the picture than this fraction of its median length has its angle held there (`holdShort`); 'off' reads every frame. */
   short: number | 'off';
+  /** Leg segments scaled along their x axis by picture length over straight length, clamped to [min, max] (`legs.ts`); 'off' (the default) scales nothing. */
+  legScale?: [number, number] | 'off';
+  /** The hip derived from the supporting foot (`legs.ts`); false (the default) moves it by the pose's travel. */
+  plantFeet?: boolean;
 }
 
 export interface Hold {
@@ -170,7 +176,7 @@ export interface MotionKey {
 }
 export interface MotionTrack {
   bone: string;
-  property: 'rotate' | 'translate';
+  property: 'rotate' | 'translate' | 'scalex';
   keys: MotionKey[];
 }
 export interface Animation {
@@ -251,6 +257,29 @@ export interface Retarget {
   range: RangeDemand[];
   /** Every run a bone inside a span turned from its drawn angle past its range. */
   artRange: ArtRange[];
+  /** With --leg-scale: each leg segment's scale, straight length and clamped runs. */
+  legScale: LegScale[];
+  /** Per scaled bone, the scale its x axis must reach on each frame (relative to setup); the scalex key of a bone under a scaled bone differs from it. */
+  scales: Map<string, number[]>;
+  /** The supports and jumps read off the reference ankles, when the map has both legs (whether or not --plant-feet used them). */
+  feet: Feet | null;
+  /** Whether the hip was derived from the supporting foot. */
+  planted: boolean;
+  /** Each ankle's world position on every frame, as the keys put it, when legs are scaled or feet planted. */
+  ankles: { bones: Record<Side, string>; at: Record<Side, Pt[]> } | null;
+  /** The translated bone's origin against its thigh roots' midpoint, at setup. */
+  pivot: Pivot | null;
+}
+
+/** The hip's pivot against the thigh roots, at setup (rig-c/pose#47). */
+export interface Pivot {
+  bone: string;
+  roots: [string, string];
+  /** Hip origin − the roots' midpoint, world units. */
+  offset: Pt;
+  distance: number;
+  /** The distance in hip widths (the roots' distance apart). */
+  hipWidths: number;
 }
 
 type Pt = [number, number];
@@ -358,6 +387,24 @@ const r3 = (v: number) => {
   const r = Math.round(v * 1000) / 1000;
   return Object.is(r, -0) ? 0 : r;
 };
+/** A scale key: to 1e-6, so its rounding moves an ankle 500 units out by at most 0.00025. */
+const r6 = (v: number) => {
+  const r = Math.round(v * 1e6) / 1e6;
+  return Object.is(r, -0) ? 0 : r;
+};
+
+/** The translated bone's origin against the midpoint of the two legs' first bones, at setup. */
+function pivotOf(rest: Rest, bone: string | null, legs: ReturnType<typeof legsOf> | null): Pivot | null {
+  if (bone === null || legs === null || !('legs' in legs)) return null;
+  const roots: [string, string] = [legs.legs.r.chain.bones[0]!, legs.legs.l.chain.bones[0]!];
+  const a = rest.get(roots[0])!;
+  const b = rest.get(roots[1])!;
+  const h = rest.get(bone)!;
+  const offset: Pt = [h.worldX - (a.worldX + b.worldX) / 2, h.worldY - (a.worldY + b.worldY) / 2];
+  const width = Math.hypot(b.worldX - a.worldX, b.worldY - a.worldY);
+  const distance = Math.hypot(offset[0], offset[1]);
+  return { bone, roots, offset, distance, hipWidths: width > 1e-9 ? distance / width : NaN };
+}
 
 /**
  * Retarget. Refuses (every reason at once) when a point the map needs is never
@@ -493,30 +540,17 @@ export function retarget(rest: Rest, map: JointMap, frames: ReadonlyArray<Partia
         const s = rigLen / poseLen;
         scale = { factor: s, pose: poseLen, rig: rigLen };
         const P = series.get(t.joint)!;
-        const bone = rest.get(t.bone)!;
-        const parent = bone.parent === null ? null : rest.get(bone.parent)!;
-        const keys: MotionKey[] = [];
-        const at: Pt[] = [];
         for (let i = 0; i < n; i++) {
           const wx = (P[i]![0] - P[0]![0]) * s;
           const wy = -(P[i]![1] - P[0]![1]) * s;
-          let lx = wx;
-          let ly = wy;
-          if (parent !== null) {
-            const det = parent.a * parent.d - parent.b * parent.c;
-            lx = (parent.d * wx - parent.b * wy) / det;
-            ly = (-parent.c * wx + parent.a * wy) / det;
-          }
-          keys.push({ t: keyTimes[i]!, v: [r3(lx), r3(ly)] });
-          at.push([bone.worldX + wx, bone.worldY + wy]);
           travel.push([wx, wy]);
         }
-        translateTrack = { bone: t.bone, property: 'translate', keys };
-        origin = { bone: t.bone, at };
       }
     }
   }
   p.throwIfAny();
+  /** The pose's own travel of the hip, world, before --plant-feet replaces it. */
+  const poseTravel: Pt[] = travel.map((v) => [v[0], v[1]]);
 
   // Each mapped bone's target world angle per frame, reaches last.
   const targets = new Map<string, number[]>();
@@ -595,6 +629,111 @@ export function retarget(rest: Rest, map: JointMap, frames: ReadonlyArray<Partia
   }
   p.throwIfAny();
 
+  // The legs (#47): each leg segment's scale, the supports and jumps, and with
+  // --plant-feet the hip derived from the supporting foot — before the reaches,
+  // which are aimed from where the hip is.
+  const legScaleOn = opts.legScale !== undefined && opts.legScale !== 'off';
+  const plantOn = opts.plantFeet === true;
+  const legScale: LegScale[] = [];
+  const scales = new Map<string, number[]>();
+  let feet: Feet | null = null;
+  let legs: ReturnType<typeof legsOf> | null = null;
+  let legPath: string[] | null = null;
+  let legTop: string | null = null;
+  const restTurn = (b: string, i: number): number => targets.get(b)![i]! - restOf.get(b)!;
+  const aimX = new Map<string, boolean>();
+  for (const c of map.chains) c.bones.forEach((b, k) => aimX.set(b, c.aim[k] === 'x'));
+  {
+    const why = plantOn ? '--plant-feet' : legScaleOn ? '--leg-scale' : 'reading the feet';
+    legs = legsOf(map, why);
+    if ('problems' in legs) {
+      if (plantOn || legScaleOn) for (const x of legs.problems) p.add('LEGS_MAP', x);
+    } else {
+      const L = legs.legs;
+      const top = t !== null && SIDES.every((s) => L[s].ankleBone === t.bone || descends(rest, L[s].ankleBone, t.bone)) ? t.bone : rootOf(rest, L.r.ankleBone);
+      if (plantOn && (t === null || top !== t.bone)) p.add('LEGS_MAP', t === null ? '--plant-feet places the hip, and the map has no "translate"' : `--plant-feet places the translated bone "${t.bone}", and the legs' last bones (${L.r.ankleBone}, ${L.l.ankleBone}) do not both descend from it`);
+      const path = pathFrom(rest, top, [L.r.ankleBone, L.l.ankleBone]);
+      if (path === null || rootOf(rest, L.l.ankleBone) !== rootOf(rest, L.r.ankleBone)) {
+        if (plantOn || legScaleOn) p.add('LEGS_MAP', `the legs' last bones ${L.r.ankleBone} and ${L.l.ankleBone} do not hang from one bone`);
+      } else {
+        legPath = path;
+        legTop = top;
+      }
+      const hipOf = (s: Side) => series.get(`${s}_hip`);
+      const ankleOf = (s: Side) => series.get(`${s}_ankle`);
+      const hr = hipOf('r'), hl = hipOf('l'), ar = ankleOf('r'), al = ankleOf('l');
+      if (hr !== undefined && hl !== undefined && ar !== undefined && al !== undefined) feet = supportsOf({ r: ar, l: al }, { r: hr, l: hl }, keyTimes, secondsOf);
+      else if (plantOn) p.add('LEGS_MAP', `--plant-feet reads both hips and both ankles from the pose; the map's chains use ${['r_hip', 'l_hip', 'r_ankle', 'l_ankle'].filter((j) => !series.has(j)).join(', ')} nowhere`);
+    }
+  }
+  if (legScaleOn) {
+    const limits = opts.legScale as [number, number];
+    for (const c of map.chains) {
+      if (c.reach) continue;
+      c.bones.forEach((b, k) => {
+        const joints: [string, string] = [c.joints[k]!, c.joints[k + 1]!];
+        if (!isLegSegment(joints[0], joints[1])) return;
+        if (c.aim[k] !== 'x') {
+          p.add('LEGS_MAP', `--leg-scale scales chain "${c.name}" bone "${b}" (${joints[0]} → ${joints[1]}) along its own x axis, and the map aims it ${JSON.stringify(c.aim[k])}; a leg segment it scales must be aimed "x"`);
+          return;
+        }
+        const from = series.get(joints[0])!;
+        const to = series.get(joints[1])!;
+        const ls = legScaleOf(from.map((f, i) => Math.hypot(to[i]![0] - f[0], to[i]![1] - f[1])), limits);
+        if (!(ls.straight > 1e-6)) {
+          p.add('LEGS_MAP', `--leg-scale: chain "${c.name}" bone "${b}"'s segment ${joints[0]} → ${joints[1]} has a straight length (95th percentile) of ${ls.straight}px; there is nothing to scale against`);
+          return;
+        }
+        legScale.push({ chain: c.name, bone: b, joints, ...ls });
+        scales.set(b, ls.scale);
+      });
+    }
+    if (legScale.length === 0 && !p.any) p.add('LEGS_MAP', '--leg-scale scales the leg segments (two of one side\'s hip, knee and ankle), and the map aims none');
+  }
+  p.throwIfAny();
+  /** Every bone on the legs' path posed on frame i, by the targets as they stand. */
+  const poseLegs = (i: number): PathPose => {
+    const r = posePath(rest, legPath!, (b): Posing | null => (targets.has(b) ? { turn: restTurn(b, i), target: targets.get(b)![i]!, aimX: aimX.get(b)! } : null), (b) => scales.get(b)?.[i] ?? null);
+    if (typeof r === 'string') throw new Refusal([{ code: 'LEGS_MAP', text: r }]);
+    return r;
+  };
+  if (plantOn) {
+    // The plant is derived from the targets before the range clamp, so nothing after may turn a bone on the legs' path.
+    const onPath = new Set(legPath!);
+    for (const c of map.chains) for (const b of Object.keys(c.range)) if (onPath.has(b)) p.add('LEGS_RANGE', `--plant-feet places the hip through chain "${c.name}" bone "${b}", which has a "range"; a clamp after the plant would move the planted foot — drop the range or --plant-feet`);
+    for (const a of map.alternates) {
+      for (const b of [...Object.keys(a.turn), ...Object.keys(a.offsets)]) if (onPath.has(b)) p.add('LEGS_RANGE', `--plant-feet places the hip through bone "${b}", which set "${a.name}" turns or offsets; that would move the planted foot — drop it from the set or --plant-feet`);
+    }
+    p.throwIfAny();
+    const offsets = Array.from({ length: n }, (_, i) => {
+      const lp = poseLegs(i);
+      return { r: tipOf(rest, lp, legs !== null && 'legs' in legs ? legs.legs.r.ankleBone : ''), l: tipOf(rest, lp, legs !== null && 'legs' in legs ? legs.legs.l.ankleBone : '') };
+    });
+    const tb = rest.get(t!.bone)!;
+    const hip = plantHip(feet!, (i, s) => offsets[i]![s], (i) => poseTravel[i]!, [tb.worldX, tb.worldY]);
+    for (let i = 0; i < n; i++) travel[i] = [hip[i]![0] - tb.worldX, hip[i]![1] - tb.worldY];
+  }
+  if (t !== null && scale !== null) {
+    const bone = rest.get(t.bone)!;
+    const parent = bone.parent === null ? null : rest.get(bone.parent)!;
+    const keys: MotionKey[] = [];
+    const at: Pt[] = [];
+    for (let i = 0; i < n; i++) {
+      const [wx, wy] = travel[i]!;
+      let lx = wx;
+      let ly = wy;
+      if (parent !== null) {
+        const det = parent.a * parent.d - parent.b * parent.c;
+        lx = (parent.d * wx - parent.b * wy) / det;
+        ly = (-parent.c * wx + parent.a * wy) / det;
+      }
+      keys.push({ t: keyTimes[i]!, v: [r3(lx), r3(ly)] });
+      at.push([bone.worldX + wx, bone.worldY + wy]);
+    }
+    translateTrack = { bone: t.bone, property: 'translate', keys };
+    origin = { bone: t.bone, at };
+  }
+
   // Reaches: from the bone's posed origin at the pose's end point, anchored at
   // the translated bone. A reach above another is aimed first.
   const depth = (b: string): number => {
@@ -685,6 +824,25 @@ export function retarget(rest: Rest, map: JointMap, frames: ReadonlyArray<Partia
   const artRange = measureArt(sw.switches, map, targets, endOf, keyTimes, RANGE_GAP);
   clampArt(sw.switches, map, targets);
 
+  // The legs on their final targets: a bone under a scaled bone is keyed through
+  // its parent's posed matrix (legs.ts), and each ankle's world position is read.
+  const legPoses: PathPose[] | null = legPath !== null && (legScaleOn || plantOn) ? Array.from({ length: n }, (_, i) => poseLegs(i)) : null;
+  let ankles: Retarget['ankles'] = null;
+  if (legPoses !== null && legs !== null && 'legs' in legs) {
+    const L = legs.legs;
+    const topRest = rest.get(legTop!)!;
+    const at = { r: [] as Pt[], l: [] as Pt[] };
+    legPoses.forEach((lp, i) => {
+      const o: Pt = origin !== null && origin.bone === legTop ? origin.at[i]! : [topRest.worldX, topRest.worldY];
+      for (const sd of SIDES) {
+        const tip = tipOf(rest, lp, L[sd].ankleBone);
+        at[sd].push([o[0] + tip[0], o[1] + tip[1]]);
+      }
+    });
+    ankles = { bones: { r: L.r.ankleBone, l: L.l.ankleBone }, at };
+  }
+  const solvedKey = (b: string, i: number) => legPoses?.[i]!.solved.get(b);
+
   // Keys: the bone's turn less the turn of the nearest mapped bone above it.
   const tracks: Array<MotionTrack | SlotTrack> = [];
   for (const c of map.chains) {
@@ -699,6 +857,22 @@ export function retarget(rest: Rest, map: JointMap, frames: ReadonlyArray<Partia
         keys.push({ t: keyTimes[i]!, v: [r3(v)] });
       }
       tracks.push({ bone: b, property: 'rotate', keys });
+      // A bone under a scaled bone: the rotate key that lands it through its parent's scale (legs.ts).
+      if (solvedKey(b, 0) !== undefined) {
+        let last = 0;
+        keys.forEach((k, i) => {
+          const raw = solvedKey(b, i)!.rotate;
+          last = i === 0 ? wrap(raw) : last + wrap(raw - last);
+          k.v = [r3(last)];
+        });
+      }
+    }
+  }
+  // Scale keys: a scaled leg segment's own scale, or the scale that lands a bone under one at its asked length.
+  for (const c of map.chains) {
+    for (const b of c.bones) {
+      if (!scales.has(b) && solvedKey(b, 0) === undefined) continue;
+      tracks.push({ bone: b, property: 'scalex', keys: Array.from({ length: n }, (_, i) => ({ t: keyTimes[i]!, v: [r6(solvedKey(b, i)?.scale ?? scales.get(b)?.[i] ?? 1)] })) });
     }
   }
   if (translateTrack !== null) tracks.push(translateTrack);
@@ -708,6 +882,7 @@ export function retarget(rest: Rest, map: JointMap, frames: ReadonlyArray<Partia
     animation: { duration: keyTimes[n - 1]!, tracks },
     times: keyTimes, targets, origin, holds, bends, short, endOn, flips, scale,
     switches: sw.switches, shown: sw.shown, distances: sw.distances, turns, turnsUnread, range, artRange,
+    legScale, scales, feet, planted: plantOn, ankles, pivot: pivotOf(rest, t?.bone ?? null, legs),
   };
 }
 

package/src/run.ts

@@ -13,7 +13,9 @@ import { lineOf, Problems, Refusal, type Problem } from './problems.ts';
 import { bendLine, endOnLine, flipLine, holdLine, rangeLine, retarget, shortLine, turnLine, type RetargetOptions } from './retarget.ts';
 import { attachmentBones, baseMotionOf, buildInto, rigcVersion, folds, gate, readBuild, resolveRig, restOf, slotsOf } from './rigc.ts';
 import { artRangeLine, chainsMoving, switchLine, uncoveredFolds } from './switch.ts';
-import { landed, measureLanding, measurePosture, poseFrames, postureLines, ANGLE_TOLERANCE, ORIGIN_TOLERANCE } from './verify.ts';
+import { landed, measureFeet, measureLanding, measurePosture, measureShear, poseFrames, postureLines } from './verify.ts';
+import { legsOf } from './legs.ts';
+import type { LegScale } from './legs.ts';
 
 export interface RetargetArgs extends RetargetOptions {
   rig: string;
@@ -85,7 +87,7 @@ export function runRetarget(a: RetargetArgs, log: (line: string) => void): RunRe
     resolveMap(map, rest, a.map, slots);
 
     const r = retarget(rest, map, frames, times, a, slots);
-    say(`rig-pose retarget: ${seq.frames.length} frame(s), ${r.animation.duration.toFixed(3)}s, onto "${input.name}" as "${a.name}" — ${r.animation.tracks.length} track(s); min-score ${a.minScore}, smooth ${a.smooth}, flip ${a.flip === 'off' ? 'off' : `${a.flip}°`}, short ${a.short}, bends ${a.bends} (tolerance ${a.bendTolerance}°)`);
+    say(`rig-pose retarget: ${seq.frames.length} frame(s), ${r.animation.duration.toFixed(3)}s, onto "${input.name}" as "${a.name}" — ${r.animation.tracks.length} track(s); min-score ${a.minScore}, smooth ${a.smooth}, flip ${a.flip === 'off' ? 'off' : `${a.flip}°`}, short ${a.short}, bends ${a.bends} (tolerance ${a.bendTolerance}°)${a.legScale !== undefined && a.legScale !== 'off' ? `, leg-scale ${a.legScale[0]}–${a.legScale[1]}` : ''}${a.plantFeet === true ? ', plant-feet' : ''}`);
     say(`  RIGC   rig-c ${rigc.version} (${rigc.entry}) gates and poses this run`);
     if (r.scale !== null) say(`  SCALE  ${r.scale.factor.toFixed(5)} rig units per picture px (rig ${r.scale.rig.toFixed(2)} / pose median ${r.scale.pose.toFixed(2)})`);
     for (const h of r.holds) say(`  HOLD   ${holdLine(h, r.times)}`);
@@ -104,6 +106,16 @@ export function runRetarget(a: RetargetArgs, log: (line: string) => void): RunRe
     }
     for (const e of r.range) say(`  RANGE  ${rangeLine(e, r.times)}`);
     for (const e of r.artRange) say(`  ART-RANGE ${artRangeLine(e, r.times)}`);
+    for (const l of r.legScale) say(`  LEG-SCALE ${legScaleLine(l, r.times)}`);
+    if (r.pivot !== null) say(`  PIVOT  bone "${r.pivot.bone}"'s origin is ${r.pivot.distance.toFixed(2)} units (${r.pivot.hipWidths.toFixed(3)} hip widths) from its thigh roots' midpoint (${r.pivot.roots.join(' + ')}): dx ${r.pivot.offset[0].toFixed(2)}, dy ${r.pivot.offset[1].toFixed(2)}, at setup — the pivot every hip turn swings the legs about`);
+    if (r.feet !== null) {
+      const f = r.feet;
+      const span = (x: [number, number]) => (x[0] === x[1] ? `${x[0]}` : `${x[0]}–${x[1]}`);
+      say(`  FEET   ${r.planted ? 'planted' : 'read, not planted (no --plant-feet)'}: leg length (median hip → ankle) r ${f.legLength.r.toFixed(1)}px, l ${f.legLength.l.toFixed(1)}px; ${f.supports.length} support span(s), ${f.changes.filter((c) => c.from !== null).length} change(s) of support, ${f.jumps.length} jump(s), ${f.steps.length} step(s)`);
+      say(`  FEET   supports: ${f.supports.map((x) => `${x.side} ${span(x.frames)}`).join(', ') || 'none'}`);
+      say(`  FEET   jumps (both ankles and mid_hip > 0.05 leg lengths above their rolling floor, ≥ 2 frames): ${f.jumps.map(span).join(', ') || 'none'}`);
+      say(`  FEET   steps (the supporting ankle > 0.03 leg lengths a frame; re-planted after 2 frames < 0.01): ${f.steps.map((x) => `${x.side} ${span(x.frames)} → ${x.to === null ? 'the pose\'s travel' : `${x.to} supports`}, ${x.replant === null ? 'never re-planted' : `re-planted at ${x.replant}`}`).join('; ') || 'none'}`);
+    }
 
     const motion = { ...base, animations: { ...animations, [a.name]: r.animation } };
     const g1 = gate(input.rig, motion, join(scratch, 'with'), a.profile, a.images);
@@ -117,16 +129,30 @@ export function runRetarget(a: RetargetArgs, log: (line: string) => void): RunRe
     const landings = measureLanding(doc, a.name, map, r, posed);
     const p = new Problems();
     for (const l of landings) {
-      const unit = l.kind === 'angle' ? '°' : ' units';
-      const tol = l.kind === 'angle' ? ANGLE_TOLERANCE : ORIGIN_TOLERANCE;
-      const line = `bone "${l.bone}" ${l.kind === 'angle' ? 'aim' : 'origin'} — worst |reached − asked| ${l.worst.toPrecision(3)}${unit} at frame ${l.frame} (t=${r.times[l.frame]!.toFixed(3)}s); the tolerance is ${tol}${unit}`;
+      const unit = l.kind === 'angle' ? '°' : l.kind === 'scale' ? ' of its setup length' : ' units';
+      const what = l.kind === 'angle' ? 'aim' : l.kind === 'scale' ? 'scale' : l.kind === 'foot' ? 'ankle' : 'origin';
+      const tol = l.kind === 'foot' ? Number(l.tolerance.toPrecision(3)) : l.tolerance;
+      const line = `bone "${l.bone}" ${what} — worst |reached − asked| ${l.worst.toPrecision(3)}${unit} at frame ${l.frame} (t=${r.times[l.frame]!.toFixed(3)}s); the tolerance is ${tol}${unit}`;
       if (landed(l)) say(`  LAND   ${line}`);
       else p.add('POSE_LANDS', `${line} — the rig does not turn the way the key formula assumes (a constraint, a scaled or sheared parent, a non-normal inherit mode)`);
     }
     p.throwIfAny();
 
-    const posture = measurePosture(posed, new Map(doc.bones.map((b) => [b.name, b.length ?? 0])), map, r, frames, a.minScore);
+    const lengths = new Map(doc.bones.map((b) => [b.name, b.length ?? 0]));
+    const posture = measurePosture(posed, lengths, map, r, frames, a.minScore);
     if (posture !== null) for (const l of postureLines(posture)) say(`  POSTURE ${l}`);
+    const legBones = legBonesOf(map);
+    const feetReading = legBones === null ? null : measureFeet(posed, lengths, r, legBones);
+    if (feetReading !== null) {
+      const f = feetReading;
+      say(`  FEET   the posed build, outside jumps: the lowest ankle's vertical range ${f.lowest.range.toFixed(2)} units = ${f.lowest.legs.toFixed(4)} leg lengths (rig leg r ${f.legLength.r.toFixed(1)}, l ${f.legLength.l.toFixed(1)} units) over ${f.lowest.frames} frames`);
+      const worst = (k: 'verticalLegs' | 'horizontalLegs') => f.plants.reduce<(typeof f.plants)[number] | null>((m, x) => (m === null || x[k] > m[k] ? x : m), null);
+      const wv = worst('verticalLegs');
+      const wh = worst('horizontalLegs');
+      if (wv !== null && wh !== null) say(`  FEET   the supporting ankle over each support span: worst vertical range ${wv.vertical.toFixed(2)} units = ${wv.verticalLegs.toFixed(4)} leg lengths (${wv.side} ${wv.frames[0]}–${wv.frames[1]}), worst horizontal drift ${wh.horizontal.toFixed(2)} units = ${wh.horizontalLegs.toFixed(4)} leg lengths (${wh.side} ${wh.frames[0]}–${wh.frames[1]})`);
+    }
+    const shear = r.scales.size === 0 ? [] : measureShear(doc, posed, r.scales.keys());
+    for (const x of shear) say(`  SHEAR  bone "${x.bone}": art sheared up to ${x.shear.toFixed(2)}° (frame ${x.frame}); world x axis ${x.x[0].toFixed(3)} … ${x.x[1].toFixed(3)}, y axis ${x.y[0].toFixed(3)} … ${x.y[1].toFixed(3)} of setup — a scaled bone, or one under it; a reading`);
 
     const dts = r.times.slice(1).map((t, i) => t - r.times[i]!).sort((x, y) => x - y);
     const fps = dts.length === 0 ? 12 : Math.max(1, Math.min(60, Math.round(1 / dts[dts.length >> 1]!)));
@@ -160,7 +186,7 @@ export function runRetarget(a: RetargetArgs, log: (line: string) => void): RunRe
         animation: a.name,
         frames: seq.frames.length,
         duration: r.animation.duration,
-        options: { minScore: a.minScore, smooth: a.smooth, flip: a.flip, short: a.short, bends: a.bends, bendTolerance: a.bendTolerance, switchTolerance: a.switchTolerance, switchMin: a.switchMin, switchAt: a.switchAt, profile: a.profile },
+        options: { minScore: a.minScore, smooth: a.smooth, flip: a.flip, short: a.short, bends: a.bends, bendTolerance: a.bendTolerance, switchTolerance: a.switchTolerance, switchMin: a.switchMin, switchAt: a.switchAt, profile: a.profile, legScale: a.legScale ?? 'off', plantFeet: a.plantFeet === true },
         scale: r.scale,
         holds: r.holds,
         short: r.short,
@@ -176,6 +202,10 @@ export function runRetarget(a: RetargetArgs, log: (line: string) => void): RunRe
         turns: r.turns,
         range: r.range,
         artRange: r.artRange,
+        legScale: r.legScale.map(({ scale: _scale, ...rest }) => rest),
+        pivot: r.pivot,
+        feet: r.feet === null ? null : { planted: r.planted, legLength: r.feet.legLength, supports: r.feet.supports, jumps: r.feet.jumps, steps: r.feet.steps, changes: r.feet.changes, reading: feetReading },
+        shear,
       }, null, 2)}\n`);
     }
     say(`  wrote ${a.out} — animations: ${Object.keys(motion.animations).join(', ')}`);
@@ -235,3 +265,18 @@ function windowLines(map: JointMap, switches: ReadonlyArray<{ set: string; frame
   }
   return out;
 }
+
+/** Each leg's first bone (its root, the thigh) and last bone (whose tip is the ankle), when the map has both. */
+function legBonesOf(map: JointMap): { r: { root: string; ankle: string }; l: { root: string; ankle: string } } | null {
+  const l = legsOf(map, 'reading the feet');
+  if ('problems' in l) return null;
+  return { r: { root: l.legs.r.chain.bones[0]!, ankle: l.legs.r.ankleBone }, l: { root: l.legs.l.chain.bones[0]!, ankle: l.legs.l.ankleBone } };
+}
+
+/** A LEG-SCALE line: the segment, its straight length, its ratio's spread, and the frames clamped. */
+function legScaleLine(l: LegScale, times: readonly number[]): string {
+  const span = (x: [number, number]) => (x[0] === x[1] ? `${x[0]}` : `${x[0]}–${x[1]}`);
+  const count = (rs: Array<[number, number]>) => rs.reduce((k, x) => k + x[1] - x[0] + 1, 0);
+  const clamp = (rs: Array<[number, number]>, at: number, how: string) => (rs.length === 0 ? `none ${how} ${at}` : `${count(rs)} frame(s) ${how} ${at}, clamped (frames ${rs.map(span).join(', ')})`);
+  return `chain "${l.chain}" bone "${l.bone}" (${l.joints[0]} → ${l.joints[1]}): straight length ${l.straight.toFixed(1)}px (95th percentile of ${times.length} frames); picture length ÷ straight ${l.ratio.min.toFixed(3)} … ${l.ratio.max.toFixed(3)} (median ${l.ratio.median.toFixed(3)}); scalex keyed in [${l.limits[0]}, ${l.limits[1]}]: ${clamp(l.low, l.limits[0], 'under')}; ${clamp(l.high, l.limits[1], 'over')}`;
+}

package/src/verify.ts

@@ -8,7 +8,7 @@
  * a guess about which rigs are safe; it is posed, and the distance between the
  * aim each bone reached and the aim the pose asked for is the verdict.
  */
-import { poseRawAnimation, type CompiledDocument, type RawBone } from 'rig-c/core';
+import { poseRawAnimation, poseRawSetup, type CompiledDocument, type RawBone } from 'rig-c/core';
 import type { Body18 } from './joints.ts';
 import { aimAngle, pointAt, type JointMap } from './map.ts';
 import type { Joint } from './pose.ts';
@@ -17,10 +17,13 @@ import { pictureAngle, pointOn, wrap } from './retarget.ts';
 
 export interface Landing {
   bone: string;
-  /** The largest |reached − asked| over the frames, degrees (rotate) or world units (translate). */
+  /** The largest |reached − asked| over the frames: degrees (an aim), world units (an origin, an ankle), or a fraction of the setup length (a scale). */
   worst: number;
   frame: number;
-  kind: 'angle' | 'origin';
+  /** `scale`: the bone's world x axis against its setup length times the leg scale asked (#47); `foot`: the ankle (the leg's last bone's tip) against where the keys put it. */
+  kind: 'angle' | 'origin' | 'scale' | 'foot';
+  /** The tolerance it is held to. */
+  tolerance: number;
 }
 
 /**
@@ -32,6 +35,20 @@ export interface Landing {
  */
 export const ANGLE_TOLERANCE = 0.01;
 export const ORIGIN_TOLERANCE = 0.01;
+/**
+ * A scale key is rounded to 1e-6 and a bone under a scaled bone takes its
+ * parent's rounding too; rig-c stores float32 (≈ 6e-8 relative). 1e-4 sits
+ * two orders above that.
+ */
+export const SCALE_TOLERANCE = 1e-4;
+/**
+ * An ankle sits at the end of a lever as long as the leg: each keyed rotation
+ * on the way (the hip, the thigh, the shin; rounded to 0.001°, ±8.7e-6 rad)
+ * moves it by up to 8.7e-6 × its setup distance from the hip's origin, so three
+ * move it ≤ 2.6e-5 × that. The tolerance is the origin's plus 1e-4 × that
+ * distance, about four times the sum (0.06 units on a 520-unit leg).
+ */
+export const FOOT_TOLERANCE_PER_UNIT = 1e-4;
 
 /** Every bone, world, on every key frame of the animation, by rig-c's poser. */
 export function poseFrames(doc: CompiledDocument, animation: string, times: readonly number[]): Array<Map<string, RawBone>> {
@@ -58,8 +75,24 @@ export function measureLanding(doc: CompiledDocument, animation: string, map: Jo
           frame = i;
         }
       });
-      out.push({ bone: b, worst, frame, kind: 'angle' });
+      out.push({ bone: b, worst, frame, kind: 'angle', tolerance: ANGLE_TOLERANCE });
+    });
+  }
+  const setup = new Map(poseRawSetup(doc).bones.map((b) => [b.name, b]));
+  for (const [b, asked] of r.scales) {
+    const s0 = setup.get(b)!;
+    const len0 = Math.hypot(s0.a, s0.c);
+    let worst = -1;
+    let frame = 0;
+    posed.forEach((bones, i) => {
+      const o = bones.get(b)!;
+      const e = Math.abs(Math.hypot(o.a, o.c) / len0 - asked[i]!);
+      if (e > worst) {
+        worst = e;
+        frame = i;
+      }
     });
+    out.push({ bone: b, worst, frame, kind: 'scale', tolerance: SCALE_TOLERANCE });
   }
   if (r.origin !== null) {
     let worst = -1;
@@ -73,13 +106,132 @@ export function measureLanding(doc: CompiledDocument, animation: string, map: Jo
         frame = i;
       }
     });
-    out.push({ bone: r.origin.bone, worst, frame, kind: 'origin' });
+    out.push({ bone: r.origin.bone, worst, frame, kind: 'origin', tolerance: ORIGIN_TOLERANCE });
+  }
+  if (r.ankles !== null) {
+    const top = r.origin?.bone;
+    for (const side of ['r', 'l'] as const) {
+      const bone = r.ankles.bones[side];
+      const s0 = setup.get(bone)!;
+      const tip0: [number, number] = [s0.worldX + s0.a * (lengths.get(bone) ?? 0), s0.worldY + s0.c * (lengths.get(bone) ?? 0)];
+      const h0 = top === undefined ? null : setup.get(top)!;
+      const lever = h0 === null ? Math.hypot(tip0[0], tip0[1]) : Math.hypot(tip0[0] - h0.worldX, tip0[1] - h0.worldY);
+      let worst = -1;
+      let frame = 0;
+      posed.forEach((bones, i) => {
+        const got = pointAt(bones, lengths, `${bone}:tip`)!;
+        const want = r.ankles!.at[side][i]!;
+        const e = Math.hypot(got[0] - want[0], got[1] - want[1]);
+        if (e > worst) {
+          worst = e;
+          frame = i;
+        }
+      });
+      out.push({ bone: `${bone}:tip`, worst, frame, kind: 'foot', tolerance: ORIGIN_TOLERANCE + FOOT_TOLERANCE_PER_UNIT * lever });
+    }
   }
   return out;
 }
 
 export function landed(l: Landing): boolean {
-  return l.worst <= (l.kind === 'angle' ? ANGLE_TOLERANCE : ORIGIN_TOLERANCE);
+  return l.worst <= l.tolerance;
+}
+
+/**
+ * How a scaled bone, or a bone under one, has its art distorted: the angle
+ * between its world x and y axes less 90° (shear), and each world axis's length
+ * against setup (a foot under a scaled shin is squashed along the shin). A
+ * reading, not a gate: rig-c's `scalex` on a bone reaches every bone below it.
+ */
+export interface Shear {
+  bone: string;
+  /** Worst |angle(x, y) − 90°|, degrees, and its frame. */
+  shear: number;
+  frame: number;
+  /** The world x and y axes' lengths over setup's: lowest and highest over the frames. */
+  x: [number, number];
+  y: [number, number];
+}
+
+export function measureShear(doc: CompiledDocument, posed: Array<Map<string, RawBone>>, scaled: Iterable<string>): Shear[] {
+  const setup = new Map(poseRawSetup(doc).bones.map((b) => [b.name, b]));
+  const under = new Set<string>(scaled);
+  for (const b of doc.bones) if (b.parent !== undefined && b.parent !== null && under.has(b.parent)) under.add(b.name);
+  const out: Shear[] = [];
+  for (const b of doc.bones) {
+    if (!under.has(b.name)) continue;
+    const s0 = setup.get(b.name)!;
+    const x0 = Math.hypot(s0.a, s0.c);
+    const y0 = Math.hypot(s0.b, s0.d);
+    let shear = -1;
+    let frame = 0;
+    const xs: number[] = [];
+    const ys: number[] = [];
+    posed.forEach((bones, i) => {
+      const o = bones.get(b.name)!;
+      const e = Math.abs(wrap((Math.atan2(o.d, o.b) - Math.atan2(o.c, o.a)) * (180 / Math.PI) - 90));
+      if (e > shear) {
+        shear = e;
+        frame = i;
+      }
+      xs.push(Math.hypot(o.a, o.c) / x0);
+      ys.push(Math.hypot(o.b, o.d) / y0);
+    });
+    const rx = rangeOf(xs);
+    const ry = rangeOf(ys);
+    out.push({ bone: b.name, shear, frame, x: [rx.min, rx.max], y: [ry.min, ry.max] });
+  }
+  return out;
+}
+
+/**
+ * The feet on the posed build (#43, #47), outside the jumps read off the
+ * reference: the lowest ankle's vertical range, and per support span, the
+ * supporting ankle's vertical range and horizontal drift — in world units and
+ * in that side's leg length (the median, over the frames, of its thigh's origin
+ * to its ankle).
+ */
+export interface FeetReading {
+  legLength: { r: number; l: number };
+  /** The lowest ankle's world y range over the frames outside jumps. */
+  lowest: { range: number; legs: number; frames: number };
+  /** Per support span: the supporting ankle's ranges outside jumps. */
+  plants: Array<{ side: 'r' | 'l'; frames: [number, number]; vertical: number; horizontal: number; verticalLegs: number; horizontalLegs: number }>;
+}
+
+export function measureFeet(posed: Array<Map<string, RawBone>>, lengths: ReadonlyMap<string, number>, r: Retarget, legs: { r: { root: string; ankle: string }; l: { root: string; ankle: string } }): FeetReading | null {
+  if (r.feet === null) return null;
+  const tip = (bones: Map<string, RawBone>, side: 'r' | 'l') => pointAt(bones, lengths, `${legs[side].ankle}:tip`)!;
+  const legLength = { r: 0, l: 0 };
+  for (const side of ['r', 'l'] as const) {
+    legLength[side] = medianOf(posed.map((bones) => {
+      const a = tip(bones, side);
+      const o = bones.get(legs[side].root)!;
+      return Math.hypot(a[0] - o.worldX, a[1] - o.worldY);
+    }));
+  }
+  const jump = new Set<number>();
+  for (const [a, b] of r.feet.jumps) for (let i = a; i <= b; i++) jump.add(i);
+  const ys: number[] = [];
+  posed.forEach((bones, i) => {
+    if (jump.has(i)) return;
+    ys.push(Math.min(tip(bones, 'r')[1], tip(bones, 'l')[1]));
+  });
+  const lr = rangeOf(ys);
+  const mean = (legLength.r + legLength.l) / 2;
+  const plants = r.feet.supports.map((s) => {
+    const xs: number[] = [];
+    const yy: number[] = [];
+    for (let i = s.frames[0]; i <= s.frames[1]; i++) {
+      const a = tip(posed[i]!, s.side);
+      xs.push(a[0]);
+      yy.push(a[1]);
+    }
+    const v = rangeOf(yy).range;
+    const h = rangeOf(xs).range;
+    return { side: s.side, frames: s.frames, vertical: v, horizontal: h, verticalLegs: v / legLength[s.side], horizontalLegs: h / legLength[s.side] };
+  });
+  return { legLength, lowest: { range: lr.range, legs: lr.range / mean, frames: ys.length }, plants };
 }
 
 export interface Range {