@rig-c/pose 0.20.3 → 0.20.5

package/README.md

@@ -195,19 +195,19 @@ Re-checked on the exam01 test rig with `--short 0.35 --flip 90 --bends clamp`. O
 
 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.
+**`--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 larger of the two sides' 95th-percentile picture lengths for that segment over the sequence ([#148](https://github.com/rig-c/pose/issues/148)), 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.
+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 φ)|. A child (or its intermediate control bone) with `noScale` or `noScaleOrReflection` ([#153](https://github.com/rig-c/pose/issues/153)) still has its direction carried through the parent's scaled matrix, so its angle is skewed the same way, while rig-c normalises that direction to unit length so the parent's scale is not inherited. 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' put its world x axis on its target at the scale asked (under `noScale`, s' is the bone's own asked scale s directly). 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. A `normal` 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 legs at the scale the pose asked for (when a segment asks for a scale below `--leg-scale`'s clamp floor, the clamp does not lift the hip by what it withheld, [#107](https://github.com/rig-c/pose/issues/107); on a supporting leg, the segment's `scalex` follows the asked scale down to the bound #95 derives from the leg's own range so the supporting ankle stays on #85's floor while the free leg keeps the configured clamp, and any frame clamped at #95's bound lifts the hip by the remainder so the ankle never sinks, listed as `LEG-SCALE past the floor (support)`, [#133](https://github.com/rig-c/pose/issues/133)), 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), and once confirmed takes support from the frame it crossed that margin ([#102](https://github.com/rig-c/pose/issues/102)); 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 in y from the old derivation to the new over **3 frames** while taking the new derivation's x immediately ([#102](https://github.com/rig-c/pose/issues/102)), so the planted foot does not slide across the blend.
-- 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). At a walking hand-over the front foot has not landed yet while the back ankle lifts its heel and the hip rises 0.051–0.065 leg lengths; when the front foot lands while the back ankle stays above its floor, a back ankle that holds its height in y (< **0.01** leg lengths a frame for **2 frames**) is on a raised heel rather than in flight and is not read as a jump ([#101](https://github.com/rig-c/pose/issues/101)). 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 **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**, starting from the first immediately preceding push-off frame where both ankles are already above their rolling floor while mid_hip lags ([#142](https://github.com/rig-c/pose/issues/142)) — releases the plant: the hip follows the pose's travel from where it was, and re-plants on landing (blended the same way). At a walking hand-over the front foot has not landed yet while the back ankle lifts its heel and the hip rises 0.051–0.065 leg lengths; when the front foot lands while the back ankle stays above its floor, a back ankle that holds its height in y (< **0.01** leg lengths a frame for **2 frames**) is on a raised heel rather than in flight and is not read as a jump ([#101](https://github.com/rig-c/pose/issues/101)). 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.
 - **In place** ([#92](https://github.com/rig-c/pose/issues/92)). On a sequence with `"travel": "in-place"`, the supporting foot of a figure that does not travel moves back in the picture while the body stays. Holding it where it planted turns that slide into the body's travel, so the hip walks off and never comes back. Under the declaration each plant's anchor follows its own ankle's picture x, scaled into the rig, from the frame it planted, and keeps its y on the one floor. No step releases a foot, since a foot that follows its track has no plant to drag. Every foot may take support, and the lower one does, by the rules above. The loop is then closed: the hip's x on frame i moves by −drift · i / (n − 1), where drift is its x on the last frame less its x on the first. The last frame's hip x is then the first's, and the loop carries no net travel. The y is the floor's and is not touched. `FEET` prints the drift closed, in place of the steps line, and the report's `feet.closure` carries `{ drift, frames }` (`null` otherwise). On the tests' synthetic in-place loop (40 frames, each supporting ankle sliding back 2 px a frame, the hips still), the hip moves less than 10⁻⁹ px. The same joints without the declaration put it 68 px forward over the loop. With a slide of 0.04 leg lengths a frame, both feet are released as stepping and never re-plant without the declaration, and the supports alternate with it. Jumps are read as before.
 - 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.
 - **Read from the lower ankle** ([#113](https://github.com/rig-c/pose/issues/113), [#119](https://github.com/rig-c/pose/issues/119)). On a sequence not declared `"in-place"`, a foot whose ankle is at least **0.02 leg lengths** higher in the picture than the other's never takes support: not when a plant starts, and not when a step releases the other foot. Before, a step handed support to the only foot free to take it, even a folded, lifted one, and the hip was then placed under a foot in the air. A supporting foot that the other ankle has been that much lower than for **0.1 s** hands support to it when it may take it, as before; when the lower foot may not (it is released and not yet still, or moving), the supporting foot is released, and the hip follows the pose's travel until a foot may take support. On a frame after a jump or a step's release where the only foot free under #113 is the higher one (`cause: "higher"`), the lower foot supports **tracked, not planted** ([#119](https://github.com/rig-c/pose/issues/119)): the hip puts it on #85's floor and follows its scaled ankle track (`FEET tracked`, `feet.tracked`) until it has been still for 2 frames (`< 0.01`), when the normal plant takes over at that position. Steps and jumps are read as before, and under `"in-place"` #92's reading stands. `FEET support read from the lower ankle` names every run of frames whose support differs from the reading before #113, the side before and after (`none`: no foot supports), and for each `none` why: `released`, the supporting foot let go because the lower ankle could not take support (released by a step, or moving), or the only foot free to take support was the higher one. The report's `feet.lowered` holds them as `{ frames, was, now, cause }` (absent in place). On the tests' synthetic step under a lifted leg (the lifted ankle 0.2 leg lengths up, the grounded one stepping 0.05 leg lengths on frame 10 and still from 11), the lifted leg took support on frames 10–11 before; now frames 10–11 track the lower foot on the floor (`feet.tracked`) and the grounded one is planted from 12, when it is still again.
-- **One floor** ([#85](https://github.com/rig-c/pose/issues/85)). A 2D rig has no depth, so its floor is one line, and a planted foot is on it. The picture disagrees: a step toward the camera puts the foot lower in the frame, and a camera residual puts a whole span higher, so a plant held where the picture puts each span leaves the floor stepping between spans. Every support span's supporting ankle is therefore moved in y onto one floor, the hip and everything above with it. A span's *planted height* is the world y (on the rig, posed by rig-c) its supporting ankle would be held at; the floor is the median of the spans' planted heights, or **`--floor <y>`** (world units, y up; only with `--plant-feet`, exit 2 without it). Each span's *shift* is floor − its planted height. A change of support still blends the hip over the 3 frames, now between two spans on the floor, and a planted foot does not leave the floor: on each blend frame the **supporting** leg is stretched along its chain about its root, by the factor `--stance` uses, k = (root y − floor y) / (root y − ankle y), held within **[0.92, 1.08]**, its lower bound on the frame the supporting leg's own range as `--stance`'s ([#95](https://github.com/rig-c/pose/issues/95); where that went below 0.92, a `FEET bound from the leg's own range` line, the report's `feet.blend.range`, and each blend run's `lower`). A frame that needs more is held at the bound, the rest left to the blend, and listed `FEET past the bounds` with the k needed and how far the foot was left from the floor. An ankle already within 0.01 units (the landing check's origin tolerance) is not stretched. The stretched scales are scale targets, so the landing check holds them; `--stance` then stretches the free leg, a different chain, to the supporting ankle. A jump follows the pose's travel from the hip it left, which is on the floor, carried linearly from take-off so the landing frame meets the floor and clamped so no frame inside the flight puts a foot below it ([#103](https://github.com/rig-c/pose/issues/103)), and is held the same way over its first 3 planted frames. `--stance` is unchanged: it stretches the free leg to the supporting ankle, which is on the floor. On the tests' synthetic stick, three spans 0, 6 and 1 px apart in the picture (0, 9 and 1.5 units on the rig) plant within 0.0001 units of one floor. With the shift forced to 0 they stay 9 units apart; without the stretch, the supporting ankle leaves the floor by 6.75 units on the first blend frame.
+- **One floor** ([#85](https://github.com/rig-c/pose/issues/85)). A 2D rig has no depth, so its floor is one line, and a planted foot is on it. The picture disagrees: a step toward the camera puts the foot lower in the frame, and a camera residual puts a whole span higher, so a plant held where the picture puts each span leaves the floor stepping between spans. Every support span's supporting ankle is therefore moved in y onto one floor, the hip and everything above with it. A span's *planted height* is the world y (on the rig, posed by rig-c) its supporting ankle would be held at; the floor is the median of the spans' planted heights, or **`--floor <y>`** (world units, y up; only with `--plant-feet`, exit 2 without it). Each span's *shift* is floor − its planted height. A change of support still blends the hip over the 3 frames, now between two spans on the floor, and a planted foot does not leave the floor: on each blend frame the **supporting** leg is stretched along its chain about its root, by the factor `--stance` uses, k = (root y − floor y) / (root y − ankle y), held within **[0.92, 1.08]**, its lower bound on the frame the supporting leg's own range as `--stance`'s ([#95](https://github.com/rig-c/pose/issues/95); where that went below 0.92, a `FEET bound from the leg's own range` line, the report's `feet.blend.range`, and each blend run's `lower`). A frame that needs more is held at the bound, the rest left to the blend, and listed `FEET past the bounds` with the k needed and how far the foot was left from the floor. An ankle already within 0.01 units (the landing check's origin tolerance) is not stretched. The stretched scales are scale targets, so the landing check holds them; `--stance` then stretches the free leg, a different chain, to the supporting ankle. A jump follows the pose's travel from the hip it left, which is on the floor, carried linearly from take-off so the landing frame meets the floor and clamped so no frame inside the flight puts a foot below it ([#103](https://github.com/rig-c/pose/issues/103)), and is held the same way over its first 3 planted frames, with the flight's carry held across the landing blend so it fades out with the blend weights rather than dropping on the first frame after landing ([#147](https://github.com/rig-c/pose/issues/147)). `--stance` is unchanged: it stretches the free leg to the supporting ankle, which is on the floor. On the tests' synthetic stick, three spans 0, 6 and 1 px apart in the picture (0, 9 and 1.5 units on the rig) plant within 0.0001 units of one floor. With the shift forced to 0 they stay 9 units apart; without the stretch, the supporting ankle leaves the floor by 6.75 units on the first blend frame.
 - `FEET` lists the supports, the jumps and the steps (each with the side, its frames, who took support and where it re-planted; in place, the loop's closure instead), and with `--plant-feet` the floor: its world y and where it came from, each span's shift in units and in that side's rig leg at setup (thigh origin → ankle), and the shifts' range, then one line per run of blend frames whose supporting leg was stretched (`blend held on the floor`) and per run `past the bounds`. The report carries them under `feet` (`supports`, `jumps`, `steps`, `changes`, `floor`, `shifts`, `blend`, `closure`).
 - **`--stance <leg lengths>`** (only with `--plant-feet`, which it is refused without; off by default) plants **both** feet when the free one is near the floor ([#60](https://github.com/rig-c/pose/issues/60)). On a frame with a supporting side (so outside every jump), the free ankle's height above the supporting one is read in the picture, in the free side's leg length — the leg length `FEET` uses. The tolerance is a **distance** ([#114](https://github.com/rig-c/pose/issues/114)): within it, above the supporting ankle or below it, the frame is **planted both**: every bone of the free leg's chain has its `scalex` key multiplied by k = (root y − floor y) / (root y − ankle y) on the posed rig, the root being the chain's first bone's origin and the floor the supporting ankle, so the foot reaches the floor. A free ankle within the tolerance below the supporting one is planted too: its k is under 1, since a foot slightly under the floor is the same fault as one floating above it. A free ankle **past the tolerance below** the supporting one is not a stance but a support error (the foot read as supporting is the one in the air), so that frame is never planted both and keeps the pose's height; it is named on a `STANCE past the tolerance below` line with the side, the frames and the largest distance, and read `"below"` in the report's `stance.runs`. Before #114 the gap was signed, so any free ankle below the supporting one counted as within, and a lifted foot read as supporting had the grounded leg shrunk up to it. On the tests' synthetic stance, a free ankle 0.5 leg lengths below is read below and not planted; one 0.03 below is planted with k under 1. k is held within **[0.92, 1.08]**, except that the lower bound comes from the leg's own range in the sequence ([#95](https://github.com/rig-c/pose/issues/95)): per side, r = the leg's picture length hip → ankle on the frame ÷ its straight length (the 95th percentile of that length, as `--leg-scale` reads a segment's), and the frame's lower bound is min(0.92, r), so the rig leg may fold as far as the picture folds it on that frame and never less far than 0.92. The upper bound stays 1.08, since a picture leg does not read longer than straight. A sequence whose legs never fold below 0.92 keeps exactly [0.92, 1.08]. Where the range set a bound below 0.92 on a planted-both frame, one `STANCE bound from the leg's own range` line gives each side's lowest, as does the report's `stance.range`. A frame past its bound is listed `past the bounds` with the bound it had, held at the bound and not forced. Past the tolerance above, the foot is **lifted** and keeps the pose's height. The state is read with **hysteresis** and a **shortest run** ([#87](https://github.com/rig-c/pose/issues/87)), on the distance: a planted foot leaves the stance when its distance from the supporting one goes past the tolerance, and one past it is planted again only under **0.8** of it (both figures are on the `STANCE` line). A change of state takes effect only when its condition holds for **0.1 s** (by the frames' times). A shorter crossing with the other state on both sides of it keeps their state and is listed `absorbed` with its frames and the height that crossed (`absorbed: true` in the report's `stance.runs`, beside the run that took it in). One that runs to the end of a support span is taken, since nothing of the other state follows it. A threshold read frame by frame turned noise at the threshold into a pop: one frame at 0.0708 against 0.07 dropped the stretch for one frame and the foot jumped up and back. The stretched scales are the scale targets, so the landing check holds them. Measured with `--stance 0.07` and HQ's flags (`--smooth 7 --flip 90 --short 0.35 --bends clamp --leg-scale 0.8,1.05 --plant-feet --carry-idle`): on HQ's dancer, frames 94–175 outside the jumps, the free ankle's height above the supporting one on the posed build went from median 18.3 and p90 25.4 units to 0.0 and 0.0. On a second sequence (Toca, 492 frames at 30 fps) the 29 frames labelled by eye as both feet flat, outside the jumps, read 0.0 and 0.0. Of the 6 labelled one foot lifted, 5 stay above the tolerance; the sixth (frame 360) was 0.042 leg lengths up in the picture, within the tolerance, and so planted; without `--stance` it stood 6.5 units up, also under the tolerance (22.6 units there). That is 83 %, under the 90 % the card asked.
 - 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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rig-c/pose",
-  "version": "0.20.3",
+  "version": "0.20.5",
   "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

@@ -12,14 +12,16 @@
  * 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).
+ * |(s·cos φ, sin φ)|. A child with `noScale` or `noScaleOrReflection`
+ * (rig-c/pose#153) still has its direction carried through the parent's scaled
+ * matrix, so its angle is skewed the same way, while rig-c normalises that
+ * direction to unit length so the parent's scale is not inherited. 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' put its world x
+ * axis on the target angle at the asked length (under `noScale`, s' is the
+ * bone's own asked scale s directly). Its art is still sheared by a `normal`
+ * 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
@@ -35,7 +37,9 @@
  * picture y over ± `FLOOR_SECONDS`), for ≥ `JUMP_FRAMES` frames, excluding a
  * hand-over whose back ankle stays up and holds its height in y (`< STILL_SPEED`
  * for `STILL_FRAMES` frames) when the front foot lands (a raised heel,
- * rig-c/pose#101) — releases the plant: the hip follows the pose's travel from
+ * rig-c/pose#101), and starting from the first preceding push-off frame where
+ * both ankles are already above their rolling floor while mid_hip lags
+ * (rig-c/pose#142) — 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
@@ -162,12 +166,37 @@ export interface PathPose {
   solved: Map<string, { rotate: number; scale: number }>;
 }
 
+/**
+ * World 2×2 of a `noScale` or `noScaleOrReflection` bone under `Wp` at rotate
+ * key `k` (degrees) and scalex key `sk` (rig-c/pose#153), matching rig-c's
+ * `modeMatrix` (`rigc/src/core/world.ts`): the bone's local x direction is
+ * rotated by `k`, carried through `Wp` and normalised to unit length before its
+ * setup local frame (`F0`) and `sk` are applied.
+ */
+export function poseNoScale(Wp: M2, Wp0: M2, W0: M2, inherit: 'noScale' | 'noScaleOrReflection', k: number, sk: number): M2 {
+  const L0 = mul(inv(Wp0), W0);
+  const l0: Pt = [L0[0], L0[2]];
+  const len0 = Math.hypot(W0[0], W0[2]);
+  const u0: Pt = [W0[0] / len0, W0[2] / len0];
+  const flip0 = inherit === 'noScale' && Wp0[0] * Wp0[3] - Wp0[1] * Wp0[2] < 0 ? -1 : 1;
+  const turned0: M2 = [u0[0], -u0[1] * flip0, u0[1], u0[0] * flip0];
+  const F0 = mul(inv(turned0), W0);
+  const u = apply(Wp, apply(rot(k), l0));
+  const invLen = 1 / Math.sqrt(u[0] * u[0] + u[1] * u[1]);
+  const ux = u[0] * invLen;
+  const uy = u[1] * invLen;
+  const flip = inherit === 'noScale' && Wp[0] * Wp[3] - Wp[1] * Wp[2] < 0 ? -1 : 1;
+  const turned: M2 = [ux, -uy * flip, uy, ux * flip];
+  return mul(mul(turned, F0), scaleX(sk));
+}
+
 /**
  * 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.
+ * keeps its setup local matrix (or its `noScale` unit frame, #153). 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>();
@@ -197,7 +226,8 @@ export function posePath(rest: Rest, path: readonly string[], posing: (b: string
     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));
+    const noScale = rb.inherit === 'noScale' || rb.inherit === 'noScaleOrReflection' ? rb.inherit : null;
+    if (pz === null) m.set(b, noScale !== null ? poseNoScale(Wp, Wp0, W0, noScale, 0, 1) : 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`;
@@ -206,8 +236,9 @@ export function posePath(rest: Rest, path: readonly string[], posing: (b: string
       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)));
+      // Under noScale / noScaleOrReflection (#153), rig-c normalises the direction carried through Wp to unit length, so the parent's scale is not inherited and the bone's own scalex is s directly.
+      const sk = noScale !== null ? s : Math.hypot(v[0], v[1]) / Math.hypot(l0[0], l0[1]);
+      m.set(b, noScale !== null ? poseNoScale(Wp, Wp0, W0, noScale, k, sk) : mul(mul(mul(Wp, rot(k)), L0), scaleX(sk)));
       solved.set(b, { rotate: k, scale: sk });
     }
     if (under || scaleOf(b) !== null) scaledAbove.add(b);
@@ -268,7 +299,7 @@ export interface LegScale {
   chain: string;
   bone: string;
   joints: [string, string];
-  /** The straight length: the 95th percentile of the segment's picture length, px. */
+  /** The straight length: the larger of the two sides' 95th-percentile picture lengths for this segment (#148), px. */
   straight: number;
   /** The picture length over the straight length, before the clamp: lowest, median, highest. */
   ratio: { min: number; median: number; max: number };
@@ -290,9 +321,8 @@ export interface LegScale {
   support?: SupportScaleRun[];
 }
 
-/** One segment's scale per frame: picture length ÷ its 95th percentile, clamped; its asked scale without the clamp floor (#107); and the runs clamped. */
-export function legScaleOf(lengths: readonly number[], limits: [number, number]): Omit<LegScale, 'chain' | 'bone' | 'joints'> {
-  const straight = percentile(lengths, STRAIGHT_PERCENTILE);
+/** One segment's scale per frame: picture length ÷ straight length (the larger of the two sides' 95th percentiles, #148), clamped; its asked scale without the clamp floor (#107); and the runs clamped. */
+export function legScaleOf(lengths: readonly number[], limits: [number, number], straight = percentile(lengths, STRAIGHT_PERCENTILE)): Omit<LegScale, 'chain' | 'bone' | 'joints'> {
   const ratio = lengths.map((l) => l / straight);
   const scale = ratio.map((r) => Math.min(Math.max(r, limits[0]), limits[1]));
   const asked = ratio.map((r) => Math.min(r, limits[1]));
@@ -444,6 +474,9 @@ function readSupports(ankle: Record<Side, readonly Pt[]>, hip: Record<Side, read
   // #101: at a hand-over the front foot has not landed yet while the back ankle lifts its heel; when
   // the front foot lands (the first frame after its lifted run) while the back ankle stays up, a back
   // ankle that holds its height in y (< STILL_SPEED a frame for STILL_FRAMES frames) is a raised heel.
+  // #142: a run's push-off lifts the ankles off the floor while mid_hip is already rising from its
+  // crouch bottom; a jump starts at the first immediately preceding frame where both ankles are above
+  // their rolling floors and mid_hip is rising, so the support span ends at its ankle's push-off.
   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 },
@@ -471,6 +504,7 @@ function readSupports(ankle: Record<Side, readonly Pt[]>, hip: Record<Side, read
   };
   const lifted = Array.from({ length: n }, (_, i) => up.every((u) => u[i]));
   const jumps = runs(lifted).filter(([a, b]) => b - a + 1 >= JUMP_FRAMES && !raisedHeel(a, b));
+  for (const j of jumps) while (j[0] > 1 && up[0]![j[0] - 1] && up[1]![j[0] - 1] && midY[j[0] - 1]! < midY[j[0] - 2]!) j[0]--;
   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).
@@ -683,23 +717,6 @@ function placeHip(feet: Feet, offset: (i: number, s: Side) => Pt, travel: (i: nu
   const tracked = new Array<Side | null>(n).fill(null);
   for (const t of feet.tracked ?? []) for (let i = t.frames[0]; i <= t.frames[1]; i++) tracked[i] = t.side;
   const trkX = trackFn ?? follow;
-  // #142: on a run (two or more flights), each support span's push-off ankle lift and side-to-side
-  // straight-length asymmetry would otherwise swing floorY - offset(i, s)[1] far past the pose's
-  // own bounce and ratchet the un-floored picture pass per cycle. Keep the support spans' mean floor
-  // shift across both support spans and flights, holding each grounded ankle on floorY via blends.
-  const isRun = feet.jumps.length >= 2 && feet.supports.length > 0;
-  let runShift = 0;
-  if (isRun && floorY !== null) {
-    const t0 = travel(0)[1];
-    const shifts: number[] = [];
-    for (let i = 0; i < n; i++) {
-      const s = feet.support[i] ?? null;
-      if (s === null) continue;
-      shifts.push(floorY - offset(i, s)[1] - (start[1] + travel(i)[1] - t0));
-    }
-    if (shifts.length > 0) runShift = shifts.reduce((a, b) => a + b, 0) / shifts.length;
-  }
-  const flightShift = runShift;
   /** How the hip is derived on a frame: held over a foot's anchor, tracking the lower foot on the floor (#119), or carried by the pose's travel from a frame's hip (and for a jump against `floorY`, carried so the landing frame meets the floor and frames inside the flight never go below it, #103). */
   type Mode =
     | { kind: 'plant'; side: Side; anchor: Pt; from: number }
@@ -710,13 +727,6 @@ function placeHip(feet: Feet, offset: (i: number, s: Side) => Pt, travel: (i: nu
       const o = offset(i, mode.side);
       // In place (#92) the anchor's x follows the supporting ankle's own track from the frame it planted.
       const dx = follow === undefined ? 0 : follow(i, mode.side) - follow(mode.from, mode.side);
-      if (isRun) {
-        const yPose = start[1] + travel(i)[1] - travel(0)[1] + (floorY === null ? 0 : runShift);
-        if (floorY === null) return [mode.anchor[0] + dx - o[0], yPose];
-        const d = -o[1];
-        const y = d > 0 ? Math.min(Math.max(yPose, mode.anchor[1] + STANCE_BOUNDS[0] * d), mode.anchor[1] + STANCE_BOUNDS[1] * d) : yPose;
-        return [mode.anchor[0] + dx - o[0], y];
-      }
       return [mode.anchor[0] + dx - o[0], mode.anchor[1] - o[1]];
     }
     if (mode.kind === 'track') {
@@ -727,17 +737,10 @@ function placeHip(feet: Feet, offset: (i: number, s: Side) => Pt, travel: (i: nu
     }
     const a = travel(i);
     const b = travel(mode.from);
-    if (isRun) {
-      let y = start[1] + a[1] - travel(0)[1] + (floorY === null ? 0 : flightShift);
-      if (mode.end !== undefined && floorY !== null && i <= mode.end) {
-        y = Math.max(y, floorY - Math.min(offset(i, 'r')[1], offset(i, 'l')[1]));
-      }
-      return [mode.at[0] + a[0] - b[0], y];
-    }
     let y = mode.at[1] + a[1] - b[1];
     if (mode.carry !== undefined && mode.land !== undefined && mode.end !== undefined && floorY !== null) {
-      if (mode.land < n && i <= mode.land && mode.land > mode.from) {
-        y += mode.carry * ((i - mode.from) / (mode.land - mode.from));
+      if (mode.land < n && mode.land > mode.from) {
+        y += mode.carry * ((Math.min(i, mode.land) - mode.from) / (mode.land - mode.from));
       }
       if (i <= mode.end) {
         y = Math.max(y, floorY - Math.min(offset(i, 'r')[1], offset(i, 'l')[1]));
@@ -787,7 +790,7 @@ function placeHip(feet: Feet, offset: (i: number, s: Side) => Pt, travel: (i: nu
         // 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 = isRun ? null : mode;
+        from = mode;
         mode = plant(i, s, [here[0] + o[0], here[1] + o[1]]);
         blendAt = i;
       }
@@ -815,10 +818,6 @@ function placeHip(feet: Feet, offset: (i: number, s: Side) => Pt, travel: (i: nu
     } else {
       from = null;
       hip.push(to);
-      const m = mode!;
-      if (isRun && floorY !== null && m.kind === 'plant' && Math.abs(to[1] - (m.anchor[1] - offset(i, m.side)[1])) > BLEND_HOLD_WITHIN) {
-        blends.push({ frame: i, side: m.side, y: m.anchor[1] });
-      }
     }
   }
   return { hip, anchors, blends };

package/src/map.ts

@@ -116,10 +116,14 @@ export interface RigSlot {
 }
 export type RigSlots = ReadonlyMap<string, RigSlot>;
 
+export type InheritMode = 'normal' | 'onlyTranslation' | 'noRotationOrReflection' | 'noScale' | 'noScaleOrReflection';
+
 /** The rig as the map is resolved against it: each bone's setup pose, by rig-c's poser. */
 export interface RestBone extends RawBone {
   /** The bone's `length` in the compiled model (0 when it has none). */
   length: number;
+  /** The bone's `inheritMode` in the compiled model, folded to its canonical lowercase-first name (`normal` when absent). */
+  inherit?: InheritMode;
 }
 export type Rest = ReadonlyMap<string, RestBone>;
 

package/src/reduce.ts

@@ -31,6 +31,7 @@
  * of the gated build against the dense targets with the tolerance added.
  */
 import { f32 } from 'rig-c/compile';
+import { poseNoScale } from './legs.ts';
 
 /** A key as the reducer writes it: a time, its values, and a raw curve on the segment to the next key. */
 export interface ReducedKey {
@@ -444,11 +445,21 @@ const wrap180 = (d: number): number => {
  * the reduced ones), or another bone of the same call given before it — times
  * the setup locals of the unmapped bones between (`via`).
  */
+export interface UnderStep {
+  wp0: M2;
+  w0: M2;
+  inherit?: 'noScale' | 'noScaleOrReflection';
+}
+
 export interface UnderBone {
   bone: string;
-  parent: { rigid: { turn: readonly number[]; world0: M2; scale: readonly number[] }; via: M2 } | { under: string; via: M2 };
+  parent: { rigid: { turn: readonly number[]; world0: M2; scale: readonly number[] }; via: M2; steps?: readonly UnderStep[] } | { under: string; via: M2; steps?: readonly UnderStep[] };
   /** Its setup local 2×2 in its parent's axes: inv(parent's setup world) · its setup world, by rig-c's setup. */
   local: M2;
+  /** Its parent's and its own setup world 2×2 when `inherit` is `noScale` or `noScaleOrReflection` (#153). */
+  wp0?: M2;
+  w0?: M2;
+  inherit?: 'noScale' | 'noScaleOrReflection';
   /** Its setup world x-axis length. */
   len0: number;
   /** The world angle its x axis is asked on every frame (degrees), and the scale of it asked (1: none). */
@@ -475,6 +486,12 @@ export function reduceUnderScale(times: readonly number[], bones: readonly Under
   const rotate = new Map<string, ReducedKey[]>();
   const scale = new Map<string, ReducedKey[]>();
   const rows: ReduceRow[] = [];
+  const stepVia = (m: M2, via: M2, steps: readonly UnderStep[] | undefined): M2 => {
+    if (steps === undefined || !steps.some((st) => st.inherit !== undefined)) return mul(m, via);
+    let cur = m;
+    for (const st of steps) cur = st.inherit !== undefined ? poseNoScale(cur, st.wp0, st.w0, st.inherit, 0, 1) : mul(cur, mul(inv(st.wp0), st.w0));
+    return cur;
+  };
   for (const b of bones) {
     for (const [what, xs] of [['target', b.target], ['asked', b.asked], ['dense', b.dense]] as const) {
       if (xs.length !== n) throw new Error(`reduce: bone "${b.bone}" has ${xs.length} ${what} value(s) for ${n} frame(s)`);
@@ -484,9 +501,9 @@ export function reduceUnderScale(times: readonly number[], bones: readonly Under
     if ('under' in p) {
       const above = world.get(p.under);
       if (above === undefined) throw new Error(`reduce: bone "${b.bone}" hangs from bone "${p.under}", which is not given before it`);
-      parent = above.map((m) => mul(m, p.via));
+      parent = above.map((m) => stepVia(m, p.via, p.steps));
     } else {
-      parent = Array.from({ length: n }, (_, i) => mul(mul(mul(rot(p.rigid.turn[i]!), p.rigid.world0), scaleX(p.rigid.scale[i]!)), p.via));
+      parent = Array.from({ length: n }, (_, i) => stepVia(mul(mul(rot(p.rigid.turn[i]!), p.rigid.world0), scaleX(p.rigid.scale[i]!)), p.via, p.steps));
     }
     const l0: [number, number] = [b.local[0], b.local[2]];
     const a0 = Math.atan2(l0[1], l0[0]) * DEG;
@@ -507,13 +524,14 @@ export function reduceUnderScale(times: readonly number[], bones: readonly Under
     const kAt = trackAt(rk, samples, 1).map((v) => v[0]!);
     const ae = worstOf(kAt.map((_, i) => i), (i) => aimError(i, kAt[i]!))!;
     rows.push({ bone: b.bone, kind: 'angle', before: n, after: rk.length, worst: ae.worst, frame: ae.frame });
-    // The scale that gives it the length asked on the rotate as reduced.
-    const reach = kAt.map((k, i) => Math.hypot(...axis(i, k)) / b.len0);
+    // The scale that gives it the length asked on the rotate as reduced (#153: under noScale, parent scale is normalised to 1).
+    const noScale = b.inherit;
+    const reach = noScale !== undefined ? kAt.map(() => 1) : kAt.map((k, i) => Math.hypot(...axis(i, k)) / b.len0);
     const sk = fitTrack(times, samples, { targets: reach.map((r, i) => [b.asked[i]! / r]), keep, tolerance: scaleTolerance, error: (i, v) => Math.abs(v[0]! * reach[i]! - b.asked[i]!), round: r6 });
     const sAt = trackAt(sk, samples, 1).map((v) => v[0]!);
     const se = worstOf(sAt.map((_, i) => i), (i) => Math.abs(sAt[i]! * reach[i]! - b.asked[i]!))!;
     rows.push({ bone: b.bone, kind: 'scale', before: n, after: sk.length, worst: se.worst, frame: se.frame });
-    world.set(b.bone, parent.map((m, i) => mul(mul(mul(m, rot(kAt[i]!)), b.local), scaleX(sAt[i]!))));
+    world.set(b.bone, parent.map((m, i) => (noScale !== undefined ? poseNoScale(m, b.wp0!, b.w0!, noScale, kAt[i]!, sAt[i]!) : mul(mul(mul(m, rot(kAt[i]!)), b.local), scaleX(sAt[i]!)))));
     rotate.set(b.bone, rk);
     scale.set(b.bone, sk);
   }

package/src/retarget.ts

@@ -82,7 +82,7 @@ import { Problems, Refusal } from './problems.ts';
 import type { ArtRange, ByHip, Raised, ReachShort, SlotTrack, Switch, SwitchOptions } from './switch.ts';
 import { clampArt, coveredChains, isRaised, measureArt, overflow, RANGE_SLACK, reachLimit, runsOf, selectSwitches, twoBone } from './switch.ts';
 import type { BlendHold, Closure, Feet, Floor, LegScale, PathPose, Posing, Side, Stance } from './legs.ts';
-import { holdBlend, isLegSegment, legScaleOf, legsOf, pathFrom, plantHip, posePath, rootOf, scaleSupport, SIDES, stanceOf, stanceRangeOf, supportsOf, tipOf, unshortenStanceShin } from './legs.ts';
+import { holdBlend, isLegSegment, legScaleOf, legsOf, pathFrom, percentile, plantHip, posePath, rootOf, scaleSupport, SIDES, stanceOf, stanceRangeOf, STRAIGHT_PERCENTILE, supportsOf, tipOf, unshortenStanceShin } from './legs.ts';
 
 const DEG = 180 / Math.PI;
 
@@ -680,6 +680,7 @@ export function retarget(rest: Rest, map: JointMap, frames: ReadonlyArray<Partia
   }
   if (legScaleOn) {
     const limits = opts.legScale as [number, number];
+    const rawSegments: Array<{ chain: string; bone: string; joints: [string, string]; kind: string; lengths: number[]; ownStraight: number }> = [];
     for (const c of map.chains) {
       if (c.reach) continue;
       c.bones.forEach((b, k) => {
@@ -691,15 +692,22 @@ export function retarget(rest: Rest, map: JointMap, frames: ReadonlyArray<Partia
         }
         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`);
+        const lengths = from.map((f, i) => Math.hypot(to[i]![0] - f[0], to[i]![1] - f[1]));
+        const ownStraight = percentile(lengths, STRAIGHT_PERCENTILE);
+        if (!(ownStraight > 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 ${ownStraight}px; there is nothing to scale against`);
           return;
         }
-        legScale.push({ chain: c.name, bone: b, joints, ...ls });
-        scales.set(b, ls.scale);
+        rawSegments.push({ chain: c.name, bone: b, joints, kind: `${joints[0].slice(2)}:${joints[1].slice(2)}`, lengths, ownStraight });
       });
     }
+    const straightByKind = new Map<string, number>();
+    for (const seg of rawSegments) straightByKind.set(seg.kind, Math.max(straightByKind.get(seg.kind) ?? 0, seg.ownStraight));
+    for (const seg of rawSegments) {
+      const ls = legScaleOf(seg.lengths, limits, straightByKind.get(seg.kind)!);
+      legScale.push({ chain: seg.chain, bone: seg.bone, joints: seg.joints, ...ls });
+      scales.set(seg.bone, 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');
   }
   if (opts.stance !== undefined && opts.stance !== 'off' && !plantOn) p.add('STANCE', `--stance ${opts.stance} plants the free foot beside the supporting one that --plant-feet holds, and --plant-feet is not given`);
@@ -775,16 +783,7 @@ export function retarget(rest: Rest, map: JointMap, frames: ReadonlyArray<Partia
     const ankleSeries = { r: series.get('r_ankle')!, l: series.get('l_ankle')! };
     const lower = stanceRangeOf(ankleSeries, { r: series.get('r_hip')!, l: series.get('l_hip')! });
     blendHold = holdBlend(planted.blends, n, posedFeet, lower);
-    const holdAnchorX = feet!.jumps.length >= 2 ? blendHold.stretch.map((b, i) => (b ? posedFeet(i).ankle[b.side][0] : 0)) : null;
     stretchChain(blendHold.stretch);
-    if (holdAnchorX !== null) {
-      for (let i = 0; i < n; i++) {
-        const b = blendHold.stretch[i];
-        if (!b) continue;
-        hip[i]![0] += holdAnchorX[i]! - posedFeet(i).ankle[b.side][0];
-        travel[i]![0] = hip[i]![0] - tb.worldX;
-      }
-    }
     // --stance (#60): with the hip placed, a free ankle within the tolerance of the floor has its leg
     // stretched (every bone of its chain's scalex, about the chain's root) until it reaches it.
     if (opts.stance !== undefined && opts.stance !== 'off') {

package/src/rigc.ts

@@ -13,7 +13,7 @@ import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'no
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { poseRawSetup, readModel, type CompiledDocument } from 'rig-c/core';
-import type { Rest, RestBone, RigSlot, RigSlots } from './map.ts';
+import type { InheritMode, Rest, RestBone, RigSlot, RigSlots } from './map.ts';
 import { isObject, parseJson, Problems, Refusal, typeName } from './problems.ts';
 
 export interface RigInput {
@@ -129,11 +129,18 @@ export function readBuild(build: string): CompiledDocument {
   return readModel(readFileSync(path, 'utf8'), path);
 }
 
-/** Every bone's setup pose, by rig-c's poser, with its model `length`. */
+/** Every bone's setup pose, by rig-c's poser, with its model `length` and `inheritMode`. */
 export function restOf(doc: CompiledDocument): Rest {
   const lengths = new Map(doc.bones.map((b) => [b.name, b.length ?? 0]));
+  const inherits = new Map<string, InheritMode>(
+    doc.bones.map((b) => {
+      const s = b.inheritMode;
+      const folded = s === undefined || s.length === 0 ? 'normal' : `${s[0]!.toLowerCase()}${s.slice(1)}`;
+      return [b.name, folded === 'onlyTranslation' || folded === 'noRotationOrReflection' || folded === 'noScale' || folded === 'noScaleOrReflection' ? folded : 'normal'];
+    }),
+  );
   const out = new Map<string, RestBone>();
-  for (const b of poseRawSetup(doc).bones) out.set(b.name, { ...b, length: lengths.get(b.name) ?? 0 });
+  for (const b of poseRawSetup(doc).bones) out.set(b.name, { ...b, length: lengths.get(b.name) ?? 0, inherit: inherits.get(b.name) ?? 'normal' });
   return out;
 }
 

package/src/run.ts

@@ -431,21 +431,34 @@ function reduceTracks(r: ReturnType<typeof retarget>, map: JointMap, rest: Rest,
     return d;
   };
   const underBones = [...rotate.keys()].filter(under).sort((x, y) => depth(x) - depth(y));
+  const noScaleOf = (b: string): 'noScale' | 'noScaleOrReflection' | undefined => {
+    const inh = rest.get(b)!.inherit;
+    return inh === 'noScale' || inh === 'noScaleOrReflection' ? inh : undefined;
+  };
   const given: UnderBone[] = underBones.map((b) => {
     if (!scalex.has(b)) throw new Refusal([{ code: 'POSE_REDUCE', text: `bone "${b}" hangs under a scaled bone and has no scalex track, so it was not keyed through its parent's posed matrix; --reduce re-solves only a bone the legs keyed that way` }]);
-    // Up through the unmapped bones between (their setup locals), to a bone given before it or one the key formula holds for.
+    // Up through the unmapped bones between (their setup locals, or their noScale unit frames, #153), to a bone given before it or one the key formula holds for.
     let via: M2 = M2_IDENTITY;
+    const steps: Array<{ wp0: M2; w0: M2; inherit?: 'noScale' | 'noScaleOrReflection' }> = [];
     let p = rest.get(b)!.parent!;
     while (under(p) && !mapped.has(p)) {
-      via = mulM2(setupLocal(world0(rest.get(p)!.parent!), world0(p)), via);
+      const wp0 = world0(rest.get(p)!.parent!);
+      const w0 = world0(p);
+      via = mulM2(setupLocal(wp0, w0), via);
+      const inherit = noScaleOf(p);
+      steps.unshift({ wp0, w0, ...(inherit !== undefined ? { inherit } : {}) });
       p = rest.get(p)!.parent!;
     }
-    const parent: UnderBone['parent'] = under(p) ? { under: p, via } : { rigid: { turn: turnOf(p), world0: world0(p), scale: scaleAt.get(p) ?? new Array<number>(n).fill(1) }, via };
+    const viaSteps = steps.some((st) => st.inherit !== undefined) ? { steps } : {};
+    const parent: UnderBone['parent'] = under(p) ? { under: p, via, ...viaSteps } : { rigid: { turn: turnOf(p), world0: world0(p), scale: scaleAt.get(p) ?? new Array<number>(n).fill(1) }, via, ...viaSteps };
+    const wp0 = world0(rest.get(b)!.parent!);
     const w0 = world0(b);
+    const inherit = noScaleOf(b);
     return {
       bone: b,
       parent,
-      local: setupLocal(world0(rest.get(b)!.parent!), w0),
+      local: setupLocal(wp0, w0),
+      ...(inherit !== undefined ? { wp0, w0, inherit } : {}),
       len0: Math.hypot(w0[0], w0[2]),
       target: r.targets.get(b)!,
       asked: r.scales.get(b) ?? new Array<number>(n).fill(1),
@@ -671,7 +684,7 @@ 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')}`;
+  return `chain "${l.chain}" bone "${l.bone}" (${l.joints[0]} → ${l.joints[1]}): straight length ${l.straight.toFixed(1)}px (larger 95th percentile of ${times.length} frames, both legs); 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')}`;
 }
 
 /** A LEG-SCALE past the floor (support) line (rig-c/pose#133): the supporting leg segment scaled below `--leg-scale`'s floor down to #95's bound. */