@rig-c/pose 0.21.0 → 0.22.1

package/README.md

@@ -196,7 +196,7 @@ 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 larger of the two sides' 95th-percentile picture lengths for that segment over the sequence ([#148](https://github.com/rig-c/pose/issues/148); on a non-`in-place` sequence longer than 25 frames, each frame's segment length is normalised by the rolling 25-frame median trunk length over the sequence median so residual camera zoom does not shrink earlier phrases against a zoomed-in ending, and the shared thigh + shin straight lengths are capped at the larger 95th-percentile whole-leg `hip → ankle` length so a drifting knee split does not inflate their sum, [#159](https://github.com/rig-c/pose/issues/159)), 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); on a non-`in-place` sequence longer than 25 frames, each frame's segment length is normalised by a continuous rate-limited figure-scale signal `figureScaleOf` over `nose → lower ankle` standing height — frame-to-frame step ≤ 1 %, frozen spans ≥ 5 frames held at their median — so camera zoom neither shrinks earlier phrases nor lags behind frozen endings, and `--camera <file>` writes that track as `rig-pose-camera/1` without changing `motion.json`, [#159](https://github.com/rig-c/pose/issues/159), [#161](https://github.com/rig-c/pose/issues/161), [#163](https://github.com/rig-c/pose/issues/163)), 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 φ)|. 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.
 
@@ -253,6 +253,7 @@ The retarget writes one key per pose frame on every mapped bone. That is faithfu
   - A scaled bone's `scalex` track is thinned within 5e-5 of its setup length: half of the scale landing check's 1e-4, so a reduced curve cannot fail that check.
   - A mapped bone under a scaled bone (keyed through its parent's posed matrix by `--leg-scale`) is solved again through its parent as reduced. Its rotate is then thinned with the error read as the world aim it lands on, and its `scalex` with the error read as the world length it lands on. Its world error is its own fit error, as down any other chain.
   - Each ankle is held to the plant's tolerance plus the most the reduction may move it: the hip's tolerance (with `--reduce-hip`), plus the leg from the hip to the ankle (each bone's setup offset from its parent and the last bone's length) times the largest scale asked, times the angle tolerance in radians plus 5e-5. The ankle's `LAND` line prints that tolerance.
+  - When `--leg-scale` is active, each trunk bone (`chest` and `head`, not an ancestor of any scaled bone) has its kept knots and Bézier handles smoothed within `deg` of its dense world aim to minimise the mean absolute second difference of its evaluated local angle and its child's compensated local angle, holding any limb children within 0.03° of their fitted world aim (rig-c/pose#116).
 
 Exit codes: `0` written, `1` refused (every reason printed, nothing written), `2` bad invocation. `rig-pose --help` has every flag.
 
@@ -313,7 +314,7 @@ Which bones carry which joints. You write it for your rig:
   ⚠️ **Seen from the front, an elbow's side is not a joint limit.** An elbow flexes toward the camera, and its picture falls on either side of the upper arm depending on how the arm is turned. On a real 13 s front-facing dance (313 frames, RTMPose), the right elbow sat on the "wrong" side of the rig's rest on 165 frames (median 23°), and the left on 200 (median 29°, up to 179° with the hands behind the head). Every one was a real elbow bend. The knees strayed at most 8.8° and 14.7°, which is pose noise around a straight leg. So for front-facing material, arms go `"free"`. Legs on `"rest"` with `--bends clamp` hold only while the knees stay near straight. On a second dance with knee bends (Toca Toca, rig-c/pose#27), that setting straightened the left knee for most of the dance: `leg_l1` was 48.3° off at p90, against 0.0–0.3° with free legs. Leave legs `"free"` unless the dance keeps its knees straight.
 - `mid_hip` and `mid_shoulder` are the midpoints of the two hips and the two shoulders.
 - `translate.scale` is one length measured on both: two points on the rig, two points in the pose (its median over the frames where both are good). Pick a long segment that does not foreshorten much.
-- `face` (optional, [#138](https://github.com/rig-c/pose/issues/138)): `{ "yaw"?: { "bone": "yaw", "range": [-15, 15] }, "pitch"?: { "bone": "pitch", "range": [-10, 15] } }` (`min ≤ 0 ≤ max`, `min < max`). Reads per-frame yaw and pitch from `nose` against `r_eye + l_eye` (and `r_ear + l_ear` when present), compresses each axis into its declared range so peaks are scaled rather than clipped flat, and keys the named dial bone's `rotate` track (`FACE`).
+- `face` (optional, [#138](https://github.com/rig-c/pose/issues/138), [#164](https://github.com/rig-c/pose/issues/164)): `{ "yaw"?: { "bone": "yaw", "range": [-15, 15] }, "pitch"?: { "bone": "pitch", "range": [-10, 15] } }` (`min ≤ 0 ≤ max`, `min < max`). Reads per-frame yaw and pitch from `nose` against `r_eye + l_eye` (and `r_ear + l_ear` when present), maps 1:1 inside `0.8 × range` (`[-12, 12]°` on `[-15, 15]°`) and compresses only the overshoot above the knee into the remaining 20% of the range so a single outlier frame does not crush the rest of the clip, and keys the named dial bone's `rotate` track (`FACE`).
 
 ### A joint's range: `range`
 
@@ -359,7 +360,7 @@ The bound exists because speed alone rewarded showing art far from its pose. Unb
 
 Either way the `SWITCH` line ends with `moved on …, off …`: each boundary's old and new frame (the same under `first`), the frames and seconds it moved, the speed on both and its window, and the report carries the same under `moved`.
 
-**What is written.** An `attachment` track per slot whose picture changes: the set's attachment (or `null` for a hidden slot) where a span starts, and the slot's setup attachment, as the compiled model states it, where it ends. A direct switch from one set to another puts the first set's slots back to setup on the second's first frame, so an extra slot that is empty at setup goes empty. A switch onto frame *i* is keyed halfway between frames *i*−1 and *i*: a stepped key on the frame's own time fires a frame late wherever a player's accumulated time lands just below it (rig-c's docs/AUTHORING.md §4.5), and halfway both the pose's times and a renderer's `i / fps` see it on frame *i*. Before the first key a slot shows its setup attachment, so no key is written at 0 unless a span starts there. Offsets are `translate` keys at the same times, `stepped`. rig-c's gate checks these keys like any other.
+**What is written.** An `attachment` track per slot whose picture changes: the set's attachment (or `null` for a hidden slot) where a span starts, and the slot's setup attachment, as the compiled model states it, where it ends. A direct switch from one set to another puts the first set's slots back to setup on the second's first frame, so an extra slot that is empty at setup goes empty. Between two sets that both draw an arm behind the torso, a frame that belongs to neither set stays behind (the nearer set's layer); the default front slot is for a frame no set can claim **and** whose arm is read in front — not a fallback ([#136](https://github.com/rig-c/pose/issues/136), [#139](https://github.com/rig-c/pose/issues/139), [#162](https://github.com/rig-c/pose/issues/162)). A switch onto frame *i* is keyed halfway between frames *i*−1 and *i*: a stepped key on the frame's own time fires a frame late wherever a player's accumulated time lands just below it (rig-c's docs/AUTHORING.md §4.5), and halfway both the pose's times and a renderer's `i / fps` see it on frame *i*. Before the first key a slot shows its setup attachment, so no key is written at 0 unless a span starts there. Offsets are `translate` keys at the same times, `stepped`. rig-c's gate checks these keys like any other.
 
 **TURN.** The cutoff was measured on the three lines across the body before it was fixed ([#6](https://github.com/rig-c/pose/issues/6)): on the 13 s front-facing dance their picture length never drops under 0.81 of its median and none reverses; on a second sequence the hip line falls to 0.17 at frames 465–491 (side-on) and the eye line to 0.22 at 26–58 (head in profile), and 3 frames reverse. 0.5 lies between. A line is reversed when it points more than 90° from the subject's right joint to the left (front-facing, it points at 0°). The lines are read after holds, held as the map's points are even where the map does not use them; a line whose points are good on no frame is named as not measured.
 

package/cli.ts

@@ -165,6 +165,9 @@ retarget
   --report <file>       write the run's measurements (holds, short, endOn, flips, bends, landings, folds,
                         switches, uncovered, turns, range, artRange, raised, byHip,
                         idleDropped, idleKeptOut, merged, reduce) as JSON
+  --camera <file>       write the sequence's camera track (rig-pose-camera/1: continuous figure scale s,
+                        raw standing height ratio, pan tx/ty, and composite videoS) as a sidecar JSON file
+                        without changing motion.json (rig-c/pose#161)
 
   It writes nothing until rigc's gate is green with the animation in, every mapped bone lands on
   the angle the pose asks for (posed by rig-c's own poser), and no hinge bends the wrong way.
@@ -262,7 +265,7 @@ function legScaleOf(f: Map<string, string>): [number, number] | 'off' {
 }
 
 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', 'leg-scale', 'idle', 'merge', 'reduce', 'reduce-hip', 'stance', 'floor'], ['coco', 'plant-feet', 'carry-idle', 'raised-by-head']);
+  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', 'camera', 'leg-scale', 'idle', 'merge', 'reduce', 'reduce-hip', 'stance', 'floor'], ['coco', 'plant-feet', 'carry-idle', 'raised-by-head']);
   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';
@@ -299,6 +302,7 @@ function retargetArgs(argv: string[]): RetargetArgs {
     build: f.get('build'),
     render: f.get('render'),
     report: f.get('report'),
+    camera: f.get('camera'),
     idle: f.get('idle'),
     carryIdle: f.has('carry-idle'),
     merge: f.get('merge'),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rig-c/pose",
-  "version": "0.21.0",
+  "version": "0.22.1",
   "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/face.ts

@@ -11,6 +11,13 @@ type Pt = [number, number];
 
 const DEG = 180 / Math.PI;
 
+/**
+ * Fraction of each side's limit below which `mapFaceAxis` is 1:1 identity
+ * (`rig-c/pose#164`); above `FACE_KNEE * limit` (`12°` for `15°`, `8°` for `10°`),
+ * a piecewise-linear knee compresses only the overshoot `[k, peak]` into `[k, limit]`.
+ */
+export const FACE_KNEE = 0.8;
+
 export interface FaceSpan {
   min: number;
   max: number;
@@ -20,11 +27,13 @@ export interface FaceSpan {
 export interface FaceAxisReading {
   bone: string;
   limits: [number, number];
+  /** Knee thresholds `[kneeNeg, kneePos]` in degrees (`FACE_KNEE * limits`), inside which mapping is 1:1. */
+  knee: [number, number];
   read: FaceSpan;
   mapped: FaceSpan;
-  /** Compression factors [kNeg, kPos] in (0, 1] applied to negative and positive read angles. */
+  /** Peak-to-limit ratios `[kNeg, kPos]` in (0, 1] for negative and positive sides. */
   scale: [number, number];
-  /** Pearson correlation between the read angle and the mapped keys over the clip. */
+  /** Spearman rank (monotone) correlation between the read angle and the mapped keys over the clip. */
   corr: number;
   /** Per-frame read angle in degrees, before range compression. */
   raw: number[];
@@ -65,16 +74,31 @@ function spanOf(xs: readonly number[]): FaceSpan {
   return { min: r3(min), max: r3(max), range: r3(max - min) };
 }
 
+function ranksOf(xs: readonly number[]): number[] {
+  const idx = xs.map((_, i) => i).sort((a, b) => xs[a]! - xs[b]!);
+  const out = new Array<number>(xs.length).fill(0);
+  for (let i = 0; i < idx.length;) {
+    let j = i;
+    while (j + 1 < idx.length && xs[idx[j + 1]!]! === xs[idx[i]!]!) j++;
+    const rank = 0.5 * (i + j);
+    for (let k = i; k <= j; k++) out[idx[k]!] = rank;
+    i = j + 1;
+  }
+  return out;
+}
+
 function corrOf(a: readonly number[], b: readonly number[]): number {
   if (a.length < 2 || a.length !== b.length) return 1;
-  const ma = a.reduce((x, y) => x + y, 0) / a.length;
-  const mb = b.reduce((x, y) => x + y, 0) / b.length;
+  const ra = ranksOf(a);
+  const rb = ranksOf(b);
+  const ma = ra.reduce((x, y) => x + y, 0) / ra.length;
+  const mb = rb.reduce((x, y) => x + y, 0) / rb.length;
   let num = 0;
   let da = 0;
   let db = 0;
-  for (let i = 0; i < a.length; i++) {
-    const xa = a[i]! - ma;
-    const xb = b[i]! - mb;
+  for (let i = 0; i < ra.length; i++) {
+    const xa = ra[i]! - ma;
+    const xb = rb[i]! - mb;
     num += xa * xb;
     da += xa * xa;
     db += xb * xb;
@@ -153,12 +177,21 @@ export function readFaceAngles(
   return { ears, yaw, pitch };
 }
 
+function mapKneeSide(u: number, limit: number, peak: number): number {
+  if (!(limit > 1e-9)) return 0;
+  if (!(peak > limit)) return u;
+  const k = FACE_KNEE * limit;
+  if (u <= k) return u;
+  if (u >= peak) return limit;
+  return k + ((limit - k) * (u - k)) / (peak - k);
+}
+
 /**
  * Compress a read angle series into `axis.range` (`[min, max]` with `min <= 0 <= max`):
- * negative readings scale by `kNeg = min(1, limits[0] / rawMin)` and positive
- * readings by `kPos = min(1, limits[1] / rawMax)`, so peaks above the range are
- * compressed to the limit rather than clipped flat, while motion already inside
- * the range keeps unit gain (`1`).
+ * readings on a side whose peak stays inside the limit map 1:1 (`f(x) = x`); when a
+ * side's peak exceeds its limit `L`, readings up to the knee `k = FACE_KNEE * L`
+ * (`0.8 * L`, `rig-c/pose#164`) still map 1:1 and only the overshoot `[k, peak]` is
+ * compressed linearly into `[k, L]`.
  */
 export function mapFaceAxis(raw: readonly number[], axis: FaceAxis): FaceAxisReading {
   const limits = axis.range;
@@ -168,12 +201,17 @@ export function mapFaceAxis(raw: readonly number[], axis: FaceAxis): FaceAxisRea
     if (x < rawMin) rawMin = x;
     if (x > rawMax) rawMax = x;
   }
+  const limNeg = -limits[0];
+  const limPos = limits[1];
+  const peakNeg = -rawMin;
+  const peakPos = rawMax;
   const kNeg = rawMin < limits[0] && rawMin < -1e-9 ? limits[0] / rawMin : 1;
   const kPos = rawMax > limits[1] && rawMax > 1e-9 ? limits[1] / rawMax : 1;
-  const keys = raw.map((x) => r3(x < 0 ? x * kNeg : x * kPos));
+  const keys = raw.map((x) => r3(x < 0 ? -mapKneeSide(-x, limNeg, peakNeg) : mapKneeSide(x, limPos, peakPos)));
   return {
     bone: axis.bone,
     limits: [limits[0], limits[1]],
+    knee: [r3(FACE_KNEE * limits[0]), r3(FACE_KNEE * limits[1])],
     read: spanOf(raw),
     mapped: spanOf(keys),
     scale: [r3(kNeg), r3(kPos)],
@@ -215,7 +253,7 @@ export function faceLine(f: FaceReading): string {
   for (const name of ['yaw', 'pitch'] as const) {
     const ax = f[name];
     if (ax === undefined) continue;
-    axes.push(`${name} → bone "${ax.bone}" [${ax.limits[0]}, ${ax.limits[1]}]°: ${sg(ax.mapped.min)}° … ${sg(ax.mapped.max)}° (scale ${ax.scale[0].toFixed(3)}/${ax.scale[1].toFixed(3)}, r=${ax.corr.toFixed(3)})`);
+    axes.push(`${name} → bone "${ax.bone}" [${ax.limits[0]}, ${ax.limits[1]}]° (knee [${ax.knee[0]}, ${ax.knee[1]}]°): ${sg(ax.mapped.min)}° … ${sg(ax.mapped.max)}° (scale ${ax.scale[0].toFixed(3)}/${ax.scale[1].toFixed(3)}, r=${ax.corr.toFixed(3)})`);
   }
   return `${joints}: ${readPart}; mapped ${axes.join(', ')}`;
 }

package/src/legs.ts

@@ -834,6 +834,82 @@ export const STANCE_BOUNDS: readonly [number, number] = [0.92, 1.08];
 /** Per side, per frame: the lower bound of the leg's stretch (#95). */
 export type StanceLower = Record<Side, readonly number[]>;
 
+/** Maximum per-frame relative step of the continuous figure-scale curve (`rig-c/pose#163`). */
+export const FIGURE_SCALE_STEP = 0.01;
+/** Consecutive frames whose raw figure height stays within this many pixels over ≥ `FROZEN_MIN_FRAMES` frames hold their span median (`rig-c/pose#163`). */
+export const FROZEN_STEP_PX = 0.5;
+export const FROZEN_MIN_FRAMES = 5;
+
+function medianOf(xs: readonly number[]): number {
+  const s = [...xs].sort((a, b) => a - b);
+  const m = s.length >> 1;
+  return s.length % 2 === 1 ? s[m]! : (s[m - 1]! + s[m]!) / 2;
+}
+
+/**
+ * Continuous per-frame figure scale `s[i]` (`s[0] = 1`, `rig-c/pose#163`,
+ * `rig-c/pose#161`): L2 projection of `log(raw)` onto the rate-limited corridor
+ * `|log(s[i+1] / s[i])| <= log(1 + FIGURE_SCALE_STEP)` (`≤ 1%` per frame),
+ * holding any frozen span (`≥ FROZEN_MIN_FRAMES` frames where consecutive raw
+ * heights move by `≤ FROZEN_STEP_PX`) constant at its span median.
+ */
+export function figureScaleOf(raw: readonly number[], maxStep = FIGURE_SCALE_STEP): number[] {
+  const m = raw.length;
+  if (m === 0) return [];
+  const u = raw.map((v) => Math.log(Math.max(1e-6, v)));
+  const spans: Array<{ lo: number; hi: number; val: number }> = [];
+  for (let i = 0; i < m - 1;) {
+    if (Math.abs(raw[i + 1]! - raw[i]!) > FROZEN_STEP_PX) {
+      i++;
+      continue;
+    }
+    let j = i + 1;
+    while (j + 1 < m && Math.abs(raw[j + 1]! - raw[j]!) <= FROZEN_STEP_PX) j++;
+    if (j - i + 1 >= FROZEN_MIN_FRAMES) {
+      const med = Math.log(Math.max(1e-6, medianOf(raw.slice(i, j + 1))));
+      for (let k = i; k <= j; k++) u[k] = med;
+      spans.push({ lo: i, hi: j, val: med });
+    }
+    i = j + 1;
+  }
+  const r0 = Math.log(1 + maxStep);
+  const r = new Array<number>(Math.max(0, m - 1)).fill(r0);
+  for (const sp of spans) {
+    for (let i = sp.lo; i < sp.hi; i++) r[i] = 0;
+  }
+  for (let k = 0; k + 1 < spans.length; k++) {
+    const a = spans[k]!;
+    const b = spans[k + 1]!;
+    const gap = b.lo - a.hi;
+    if (gap > 0) {
+      const needed = Math.abs(b.val - a.val) / gap;
+      if (needed > r0) {
+        for (let i = a.hi; i < b.lo; i++) r[i] = needed * 1.0001;
+      }
+    }
+  }
+  const lam = new Array<number>(Math.max(0, m - 1)).fill(0);
+  const y = [...u];
+  for (let iter = 0; iter < 5000; iter++) {
+    let maxChange = 0;
+    for (let i = 0; i < m - 1; i++) {
+      const z = lam[i]! + 0.5 * (y[i + 1]! - y[i]!);
+      const thresh = 0.5 * r[i]!;
+      const next = z > thresh ? z - thresh : z < -thresh ? z + thresh : 0;
+      const d = next - lam[i]!;
+      if (Math.abs(d) > 1e-12) {
+        lam[i] = next;
+        y[i] = y[i]! + d;
+        y[i + 1] = y[i + 1]! - d;
+        if (Math.abs(d) > maxChange) maxChange = Math.abs(d);
+      }
+    }
+    if (maxChange < 1e-11) break;
+  }
+  const y0 = y[0]!;
+  return y.map((v) => Math.exp(v - y0));
+}
+
 /**
  * The leg's own range (rig-c/pose#95). Per side, r(i) = the leg's picture
  * length hip → ankle on frame i ÷ its straight length (`STRAIGHT_PERCENTILE`
@@ -842,16 +918,20 @@ export type StanceLower = Record<Side, readonly number[]>;
  * fold as far as the picture's leg is folded on that frame, never less far
  * than the default. A leg with no straight length keeps the default.
  */
-export function stanceRangeOf(ankle: Record<Side, readonly Pt[]>, hip: Record<Side, readonly Pt[]>, inPlace = false): StanceLower {
+export function stanceRangeOf(ankle: Record<Side, readonly Pt[]>, hip: Record<Side, readonly Pt[]>, inPlace = false, figureScale?: readonly number[]): StanceLower {
   const out = {} as Record<Side, number[]>;
+  const n = ankle.r.length;
+  const scale = !inPlace && n > 25
+    ? (figureScale ?? figureScaleOf(ankle.r.map((ar, i) => Math.max(
+        Math.hypot(ar[0] - hip.r[i]![0], ar[1] - hip.r[i]![1]),
+        Math.hypot(ankle.l[i]![0] - hip.l[i]![0], ankle.l[i]![1] - hip.l[i]![1]),
+      ))))
+    : null;
   for (const s of SIDES) {
-    const len = ankle[s].map((a, i) => Math.hypot(a[0] - hip[s][i]![0], a[1] - hip[s][i]![1]));
-    const n = len.length;
-    const globalStraight = percentile(len, STRAIGHT_PERCENTILE);
-    out[s] = len.map((l, i) => {
-      const straight = inPlace || n <= 25 ? globalStraight : percentile(len.slice(Math.max(0, i - 24), Math.min(n, i + 25)), STRAIGHT_PERCENTILE);
-      return straight > 1e-9 && Number.isFinite(l) ? Math.min(STANCE_BOUNDS[0], l / straight) : STANCE_BOUNDS[0];
-    });
+    const raw = ankle[s].map((a, i) => Math.hypot(a[0] - hip[s][i]![0], a[1] - hip[s][i]![1]));
+    const len = scale !== null ? raw.map((l, i) => (scale[i]! > 1e-6 ? l / scale[i]! : l)) : raw;
+    const straight = percentile(len, STRAIGHT_PERCENTILE);
+    out[s] = len.map((l) => (straight > 1e-9 && Number.isFinite(l) ? Math.min(STANCE_BOUNDS[0], l / straight) : STANCE_BOUNDS[0]));
   }
   return out;
 }

package/src/reduce.ts

@@ -379,6 +379,365 @@ export function reduceKeys(times: readonly number[], bones: readonly ReduceBone[
   return { rotate: ordered, hip: hipKeys, rows, errors: errorsOrdered };
 }
 
+// ---------------------------------------------------------------------------
+// trunk-chain smoothing within the stated tolerance (rig-c/pose#116)
+// ---------------------------------------------------------------------------
+
+interface TrackBasis {
+  keys: readonly ReducedKey[];
+  samples: readonly number[];
+  K: number;
+  spans: number;
+  P: number;
+  hx1s: number[];
+  hx2s: number[];
+  f0: number[];
+  cols: Float64Array[];
+  d2Cols: Float64Array[];
+  activeFrames: number[][];
+  activeD2: number[][];
+  x0: Float64Array;
+}
+
+function evalTrack1D(keys: readonly ReducedKey[], samples: readonly number[]): number[] {
+  return trackAt(keys, samples, 1).map((v) => v[0]!);
+}
+
+function buildBasis(keys: readonly ReducedKey[], samples: readonly number[]): TrackBasis {
+  const K = keys.length;
+  const n = samples.length;
+  const spans = K - 1;
+  const hx1s: number[] = [];
+  const hx2s: number[] = [];
+  for (let j = 0; j < spans; j++) {
+    const t0 = keys[j]!.t;
+    const t1 = keys[j + 1]!.t;
+    hx1s.push(t0 + (t1 - t0) / 3);
+    hx2s.push(t0 + (2 * (t1 - t0)) / 3);
+  }
+  const zeroKeys: ReducedKey[] = keys.map((k, j) => (j + 1 < K ? { t: k.t, v: [0], curve: [hx1s[j]!, 0, hx2s[j]!, 0] } : { t: k.t, v: [0] }));
+  const f0 = evalTrack1D(zeroKeys, samples);
+  const P = K + 2 * spans;
+  const cols: Float64Array[] = [];
+  for (let p = 0; p < P; p++) {
+    const testKeys = zeroKeys.map((k) => ({ t: k.t, v: [...k.v], ...(k.curve !== undefined ? { curve: [...k.curve] } : {}) }));
+    if (p < K) testKeys[p]!.v[0] = 1;
+    else if (p < K + spans) testKeys[p - K]!.curve![1] = 1;
+    else testKeys[p - K - spans]!.curve![3] = 1;
+    const fp = evalTrack1D(testKeys, samples);
+    const col = new Float64Array(n);
+    for (let i = 0; i < n; i++) col[i] = fp[i]! - f0[i]!;
+    cols.push(col);
+  }
+  const d2Cols: Float64Array[] = cols.map((col) => {
+    const d = new Float64Array(Math.max(0, n - 2));
+    for (let i = 0; i < n - 2; i++) d[i] = col[i + 2]! - 2 * col[i + 1]! + col[i]!;
+    return d;
+  });
+  const activeFrames: number[][] = cols.map((col) => {
+    const idx: number[] = [];
+    for (let i = 0; i < n; i++) if (Math.abs(col[i]!) > 1e-9) idx.push(i);
+    return idx;
+  });
+  const activeD2: number[][] = d2Cols.map((dcol) => {
+    const idx: number[] = [];
+    for (let i = 0; i < dcol.length; i++) if (Math.abs(dcol[i]!) > 1e-9) idx.push(i);
+    return idx;
+  });
+  const x0 = new Float64Array(P);
+  for (let j = 0; j < K; j++) x0[j] = keys[j]!.v[0]!;
+  for (let j = 0; j < spans; j++) {
+    const c = keys[j]!.curve;
+    if (c !== undefined) {
+      x0[K + j] = c[1]!;
+      x0[K + spans + j] = c[3]!;
+    } else {
+      x0[K + j] = (2 * keys[j]!.v[0]! + keys[j + 1]!.v[0]!) / 3;
+      x0[K + spans + j] = (keys[j]!.v[0]! + 2 * keys[j + 1]!.v[0]!) / 3;
+    }
+  }
+  return { keys, samples, K, spans, P, hx1s, hx2s, f0, cols, d2Cols, activeFrames, activeD2, x0 };
+}
+
+function solveMinPWL(terms: ReadonlyArray<{ a: number; b: number; w: number }>, lo: number, hi: number): number {
+  const cands = [lo, hi];
+  for (let i = 0; i < terms.length; i++) {
+    const t = terms[i]!;
+    if (Math.abs(t.a) > 1e-12) {
+      const r = -t.b / t.a;
+      if (r > lo && r < hi) cands.push(r);
+    }
+  }
+  let bestX = lo;
+  let bestVal = Infinity;
+  for (let c = 0; c < cands.length; c++) {
+    const x = cands[c]!;
+    let val = 0;
+    for (let i = 0; i < terms.length; i++) {
+      const t = terms[i]!;
+      val += t.w * Math.abs(t.a * x + t.b);
+    }
+    if (val < bestVal) {
+      bestVal = val;
+      bestX = x;
+    }
+  }
+  return bestX;
+}
+
+function optimizeBasis(
+  basis: TrackBasis,
+  lb: readonly number[],
+  ub: readonly number[],
+  wSmooth = 1.0,
+  refY?: readonly number[],
+  refD2?: readonly number[],
+): { keys: ReducedKey[]; y: number[] } {
+  const { keys, samples, K, spans, P, hx1s, hx2s, f0, cols, d2Cols, activeFrames, activeD2, x0 } = basis;
+  const n = samples.length;
+  const x = new Float64Array(x0);
+  const y = new Float64Array(n);
+  for (let i = 0; i < n; i++) {
+    let s = f0[i]!;
+    for (let p = 0; p < P; p++) s += cols[p]![i]! * x[p]!;
+    y[i] = s;
+  }
+  const seamWeight = Math.abs(y[n - 1]! - y[0]!) < 2.0 ? 20.0 : 0.0;
+  const seamDiff0 = y[n - 1]! - y[0]!;
+  const stepLimit = Math.max(5.0, Math.max(...ub.map((u, i) => Math.abs(u - lb[i]!))) * 5);
+  for (const pen of [2, 10, 50, 500, 10000, 100000]) {
+    for (let sweep = 0; sweep < 12; sweep++) {
+      for (let p = 0; p < P; p++) {
+        const col = cols[p]!;
+        const dcol = d2Cols[p]!;
+        const af = activeFrames[p]!;
+        const ad = activeD2[p]!;
+        const terms: Array<{ a: number; b: number; w: number }> = [];
+        for (let k = 0; k < ad.length; k++) {
+          const i = ad[k]!;
+          const targetD2 = refD2 !== undefined ? refD2[i]! : 0;
+          const curD2 = y[i + 2]! - 2 * y[i + 1]! + y[i]! - targetD2;
+          terms.push({ a: dcol[i]!, b: curD2, w: wSmooth / Math.max(1, n - 2) });
+        }
+        if (seamWeight > 0 && (Math.abs(col[0]!) > 1e-9 || Math.abs(col[n - 1]!) > 1e-9)) {
+          const aSeam = col[n - 1]! - col[0]!;
+          const bSeam = y[n - 1]! - y[0]! - seamDiff0;
+          terms.push({ a: aSeam, b: bSeam, w: seamWeight });
+        }
+        for (let k = 0; k < af.length; k++) {
+          const i = af[k]!;
+          const ci = col[i]!;
+          const mid = 0.5 * (lb[i]! + ub[i]!);
+          const half = Math.max(1e-6, 0.5 * (ub[i]! - lb[i]!));
+          const bMid = y[i]! - mid;
+          terms.push({ a: ci, b: bMid - half, w: pen * 0.5 });
+          terms.push({ a: ci, b: bMid + half, w: pen * 0.5 });
+          if (refY !== undefined) {
+            terms.push({ a: ci, b: y[i]! - refY[i]!, w: 1.0 / n });
+          } else {
+            terms.push({ a: ci, b: bMid, w: 1e-5 / n });
+          }
+        }
+        const dx = solveMinPWL(terms, -stepLimit, stepLimit);
+        if (Math.abs(dx) > 1e-9) {
+          x[p]! += dx;
+          for (let k = 0; k < af.length; k++) y[af[k]!]! += col[af[k]!]! * dx;
+        }
+      }
+    }
+  }
+  const outKeys: ReducedKey[] = keys.map((k, j) => {
+    const v0 = r3(x[j]!);
+    if (j + 1 < K) {
+      const cy1 = r3(x[K + j]!);
+      const cy2 = r3(x[K + spans + j]!);
+      if (k.curve === undefined) {
+        const v1 = r3(x[j + 1]!);
+        const lin1 = r3((2 * v0 + v1) / 3);
+        const lin2 = r3((v0 + 2 * v1) / 3);
+        if (Math.abs(cy1 - lin1) <= 0.001 && Math.abs(cy2 - lin2) <= 0.001) return { t: k.t, v: [v0] };
+      }
+      return { t: k.t, v: [v0], curve: [hx1s[j]!, cy1, hx2s[j]!, cy2] };
+    }
+    return { t: k.t, v: [v0] };
+  });
+  return { keys: outKeys, y: evalTrack1D(outKeys, samples) };
+}
+
+function msdDeg(arr: readonly number[]): number {
+  if (arr.length < 3) return 0;
+  let s = 0;
+  for (let i = 1; i < arr.length - 1; i++) s += Math.abs(wrap180(arr[i + 1]! - arr[i]!) - wrap180(arr[i]! - arr[i - 1]!));
+  return s / (arr.length - 2);
+}
+
+function d2Of(arr: readonly number[]): number[] {
+  const res: number[] = [];
+  for (let i = 0; i < arr.length - 2; i++) res.push(arr[i + 2]! - 2 * arr[i + 1]! + arr[i]!);
+  return res;
+}
+
+function solveLimbPreservingJitter(
+  basis: TrackBasis,
+  yOld: readonly number[],
+  lb: readonly number[],
+  ub: readonly number[],
+): { keys: ReducedKey[]; y: number[] } {
+  const jOld = msdDeg(yOld);
+  const baseD2 = d2Of(yOld);
+  let scale = 1.0;
+  let sm = optimizeBasis(basis, lb, ub, 4.0, yOld, baseD2);
+  for (let sIter = 0; sIter < 2; sIter++) {
+    const jNew = msdDeg(sm.y);
+    if (Math.abs(jNew - jOld) <= 0.02 || jNew < 1e-6) break;
+    scale *= jOld / jNew;
+    sm = optimizeBasis(basis, lb, ub, 4.0, yOld, baseD2.map((d) => d * scale));
+  }
+  return sm;
+}
+
+/**
+ * Smooths the reduced trunk and head rotate tracks within the stated world-aim
+ * tolerance (#116): fitTrack's per-span least-squares handles leave C0 slope
+ * breaks at knots pinned to the raw frame values, which across a parent→child
+ * trunk chain (`chest` → `head`) can amplify local second-difference jitter
+ * above the sequence's own. Optimizing knot values and handle y-coordinates
+ * jointly within the ±tolerance world-aim tube removes those C0 breaks while
+ * keeping any limb chains hanging from the trunk within 0.04 of their landing
+ * and jitter.
+ */
+export function smoothTrunk(
+  times: readonly number[],
+  bones: readonly ReduceBone[],
+  tolerance: number,
+  out: Reduced,
+  trunkBones: ReadonlySet<string>,
+): void {
+  const n = times.length;
+  if (n < 4 || trunkBones.size === 0) return;
+  const samples = samplesOf(times);
+  const byName = new Map(bones.map((b) => [b.bone, b]));
+  const roots = [...trunkBones].filter((b) => {
+    const info = byName.get(b);
+    return info !== undefined && (info.above === null || !trunkBones.has(info.above));
+  });
+  const tolInner = 0.985 * tolerance;
+
+  for (const root of roots) {
+    const rootKeys = out.rotate.get(root);
+    if (rootKeys === undefined || rootKeys.length <= 2) continue;
+    const headBones = [...trunkBones].filter((b) => byName.get(b)?.above === root && (out.rotate.get(b)?.length ?? 0) > 2);
+    if (headBones.length === 0) continue;
+    const arm0Bones = bones.filter((b) => !trunkBones.has(b.bone) && b.above === root && (out.rotate.get(b.bone)?.length ?? 0) > 2).map((b) => b.bone);
+    const arm0Set = new Set(arm0Bones);
+    const arm1Bones = bones.filter((b) => !trunkBones.has(b.bone) && b.above !== null && arm0Set.has(b.above) && (out.rotate.get(b.bone)?.length ?? 0) > 2).map((b) => b.bone);
+    const allManaged = [root, ...headBones, ...arm0Bones, ...arm1Bones];
+
+    const basisOf = new Map<string, TrackBasis>();
+    const yOldOf = new Map<string, number[]>();
+    for (const b of allManaged) {
+      const k = out.rotate.get(b)!;
+      basisOf.set(b, buildBasis(k, samples));
+      yOldOf.set(b, evalTrack1D(k, samples));
+    }
+
+    const rootInfo = byName.get(root)!;
+    const eAboveRoot = rootInfo.above === null ? new Array<number>(n).fill(0) : out.errors.get(rootInfo.above)!;
+    const targetRoot = rootInfo.dense.map((d, i) => d - eAboveRoot[i]!);
+    const yRootOld = yOldOf.get(root)!;
+
+    const rootLb = targetRoot.map((t) => t - tolInner);
+    const rootUb = targetRoot.map((t) => t + tolInner);
+    let smRoot = optimizeBasis(basisOf.get(root)!, rootLb, rootUb);
+    let eRoot = smRoot.y.map((v, i) => v - targetRoot[i]!);
+
+    const smSub = new Map<string, { keys: ReducedKey[]; y: number[] }>();
+    const eSub = new Map<string, number[]>();
+
+    const tightenAround = (i: number, excess: number) => {
+      for (let k = Math.max(0, i - 2); k <= Math.min(n - 1, i + 2); k++) {
+        const w = k === i ? 1.0 : 0.7;
+        if (smRoot.y[k]! > yRootOld[k]!) rootUb[k] = Math.min(rootUb[k]!, Math.max(yRootOld[k]!, smRoot.y[k]! - excess * w));
+        else rootLb[k] = Math.max(rootLb[k]!, Math.min(yRootOld[k]!, smRoot.y[k]! + excess * w));
+      }
+    };
+
+    const solveChildren = () => {
+      eSub.set(root, eRoot);
+      for (const h of headBones) {
+        const dH = byName.get(h)!.dense;
+        const targetH = dH.map((d, i) => d - eRoot[i]!);
+        const smH = optimizeBasis(basisOf.get(h)!, targetH.map((t) => t - tolInner), targetH.map((t) => t + tolInner));
+        smSub.set(h, smH);
+        eSub.set(h, smH.y.map((v, i) => v - targetH[i]!));
+      }
+      for (const b0 of arm0Bones) {
+        const yOld = yOldOf.get(b0)!;
+        const wOld = Math.max(...out.errors.get(b0)!.map(Math.abs));
+        const cap = Math.min(0.98 * tolerance, wOld + 0.035 * tolerance);
+        const targetB = byName.get(b0)!.dense.map((d, i) => d - eRoot[i]!);
+        const smB = solveLimbPreservingJitter(basisOf.get(b0)!, yOld, targetB.map((t) => t - cap), targetB.map((t) => t + cap));
+        smSub.set(b0, smB);
+        eSub.set(b0, smB.y.map((v, i) => v - targetB[i]!));
+      }
+      for (const b1 of arm1Bones) {
+        const up = byName.get(b1)!.above!;
+        const eUp = eSub.get(up)!;
+        const yOld = yOldOf.get(b1)!;
+        const wOld = Math.max(...out.errors.get(b1)!.map(Math.abs));
+        const cap = Math.min(0.98 * tolerance, wOld + 0.035 * tolerance);
+        const targetB = byName.get(b1)!.dense.map((d, i) => d - eUp[i]!);
+        const smB = solveLimbPreservingJitter(basisOf.get(b1)!, yOld, targetB.map((t) => t - cap), targetB.map((t) => t + cap));
+        smSub.set(b1, smB);
+        eSub.set(b1, smB.y.map((v, i) => v - targetB[i]!));
+      }
+    };
+
+    for (let round = 0; round < 5; round++) {
+      solveChildren();
+      let anyTightened = false;
+      for (let i = 0; i < n; i++) {
+        for (const h of headBones) {
+          const eh = eSub.get(h)![i]!;
+          if (Math.abs(eh) > 0.99 * tolerance) {
+            tightenAround(i, Math.abs(eh) - 0.975 * tolerance);
+            anyTightened = true;
+          }
+        }
+        for (const b of [...arm0Bones, ...arm1Bones]) {
+          const wOld = Math.max(...out.errors.get(b)!.map(Math.abs));
+          const cap = Math.min(0.985 * tolerance, wOld + 0.04 * tolerance);
+          const eb = eSub.get(b)![i]!;
+          if (Math.abs(eb) > cap) {
+            tightenAround(i, Math.abs(eb) - (cap - 0.01 * tolerance));
+            anyTightened = true;
+          }
+        }
+      }
+      if (!anyTightened) break;
+      smRoot = optimizeBasis(basisOf.get(root)!, rootLb, rootUb);
+      eRoot = smRoot.y.map((v, i) => v - targetRoot[i]!);
+      if (round === 4) solveChildren();
+    }
+
+    const updateBone = (b: string, keys: ReducedKey[], e: number[]) => {
+      out.rotate.set(b, keys);
+      out.errors.set(b, e);
+      const worst = worstOf(e.map((_, i) => i), (i) => Math.abs(e[i]!))!;
+      const rowIdx = out.rows.findIndex((r) => r.kind === 'angle' && r.bone === b);
+      if (rowIdx >= 0) {
+        out.rows[rowIdx] = { bone: b, kind: 'angle', before: n, after: keys.length, worst: worst.worst, frame: worst.frame };
+      }
+    };
+
+    updateBone(root, smRoot.keys, eRoot);
+    for (const b of [...headBones, ...arm0Bones, ...arm1Bones]) {
+      updateBone(b, smSub.get(b)!.keys, eSub.get(b)!);
+    }
+  }
+}
+
+
 /** The times the poser samples a track at: the running sum of the frame steps (verify.ts `poseFrames`). */
 export function samplesOf(times: readonly number[]): number[] {
   const samples: number[] = [times[0]!];

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, percentile, plantHip, posePath, rootOf, scaleSupport, SIDES, stanceOf, stanceRangeOf, STRAIGHT_PERCENTILE, supportsOf, tipOf, unshortenStanceShin } from './legs.ts';
+import { figureScaleOf, holdBlend, isLegSegment, legScaleOf, legsOf, pathFrom, percentile, plantHip, posePath, rootOf, scaleSupport, SIDES, stanceOf, stanceRangeOf, STRAIGHT_PERCENTILE, supportsOf, tipOf, unshortenStanceShin } from './legs.ts';
 import type { FaceReading } from './face.ts';
 import { readFace } from './face.ts';
 
@@ -326,6 +326,26 @@ export interface Retarget {
   byHip: ByHip[];
   /** With "face" in the map (#138): per-frame yaw/pitch reading and range-compressed mapping. */
   face: FaceReading | null;
+  /** Continuous per-frame figure scale relative to frame 0 (`#163`, `#161`). */
+  figureScale: FigureScaleReading;
+}
+
+export interface FigureScaleFrame {
+  frame: number;
+  t: number;
+  /** Continuous rate-limited figure scale relative to frame 0 (`s[0] = 1`, step ≤ 1%/frame, held on frozen spans). */
+  s: number;
+  /** Raw standing-height ratio relative to frame 0 (`raw[i] / raw[0]`). */
+  rawS: number;
+}
+
+export interface FigureScaleReading {
+  /** Largest frame-to-frame relative change `|s[i] - s[i-1]| / s[i-1]` and the frame `i` where it occurs. */
+  maxStep: { step: number; frame: number; t: number };
+  /** Ending scale over frame 0 (`s[n-1] / s[0]`). */
+  endOverStart: number;
+  /** Per-frame continuous scale `s` and raw scale `rawS`. */
+  frames: FigureScaleFrame[];
 }
 
 /** The hip's pivot against the thigh roots, at setup (rig-c/pose#47). */
@@ -687,20 +707,60 @@ export function retarget(rest: Rest, map: JointMap, frames: ReadonlyArray<Partia
       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`);
     }
   }
-  const poseScale: number[] | null =
-    t !== null && scale !== null && !inPlace
-      ? (() => {
-          const [pa, pb] = t.scale.pose;
-          const A = series.get(pa)!;
-          const B = series.get(pb)!;
-          const raw = A.map((a, i) => Math.hypot(B[i]![0] - a[0], B[i]![1] - a[1]));
-          return raw.map((_, i) => {
-            const win = raw.slice(Math.max(0, i - 12), Math.min(n, i + 13)).filter((v) => v > 1e-6);
-            const m = win.length > 0 ? median(win) : scale!.pose;
-            return m > 1e-6 ? m / scale!.pose : 1;
-          });
-        })()
-      : null;
+  const heldPt = (name: string): Pt[] | null => {
+    const known = series.get(name);
+    if (known !== undefined) return known;
+    const h = heldOf(name);
+    return 'never' in h ? null : h.at;
+  };
+  const rawFigureHeight: number[] = (() => {
+    const ar = heldPt('r_ankle');
+    const al = heldPt('l_ankle');
+    const top = heldPt('nose') ?? heldPt('neck');
+    if (ar !== null && al !== null && top !== null) {
+      const h = ar.map((r, i) => Math.max(r[1], al[i]![1]) - top[i]![1]);
+      if (h.every((v) => v > 1e-6)) return h;
+    }
+    const hr = heldPt('r_hip');
+    const hl = heldPt('l_hip');
+    if (ar !== null && al !== null && hr !== null && hl !== null) {
+      const h = ar.map((r, i) => Math.max(Math.hypot(r[0] - hr[i]![0], r[1] - hr[i]![1]), Math.hypot(al[i]![0] - hl[i]![0], al[i]![1] - hl[i]![1])));
+      if (h.every((v) => v > 1e-6)) return h;
+    }
+    if (t !== null) {
+      const [pa, pb] = t.scale.pose;
+      const A = series.get(pa)!;
+      const B = series.get(pb)!;
+      const h = A.map((a, i) => Math.hypot(B[i]![0] - a[0], B[i]![1] - a[1]));
+      if (h.every((v) => v > 1e-6)) return h;
+    }
+    return new Array<number>(n).fill(1);
+  })();
+  const continuousScale = figureScaleOf(rawFigureHeight);
+  const figureScale: FigureScaleReading = (() => {
+    const raw0 = rawFigureHeight[0] ?? 1;
+    let maxStep = 0;
+    let stepFrame = 0;
+    for (let i = 1; i < n; i++) {
+      const prev = continuousScale[i - 1]!;
+      const st = prev > 1e-9 ? Math.abs(continuousScale[i]! - prev) / prev : 0;
+      if (st > maxStep) {
+        maxStep = st;
+        stepFrame = i;
+      }
+    }
+    return {
+      maxStep: { step: r6(maxStep), frame: stepFrame, t: keyTimes[stepFrame] ?? 0 },
+      endOverStart: r6(continuousScale[n - 1] ?? 1),
+      frames: continuousScale.map((s, i) => ({
+        frame: i,
+        t: keyTimes[i]!,
+        s: r6(s),
+        rawS: r6(raw0 > 1e-9 ? rawFigureHeight[i]! / raw0 : 1),
+      })),
+    };
+  })();
+  const poseScale: number[] | null = t !== null && scale !== null && n > 25 && !inPlace ? continuousScale : null;
   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 }> = [];
@@ -727,6 +787,12 @@ export function retarget(rest: Rest, map: JointMap, frames: ReadonlyArray<Partia
     const straightByKind = new Map<string, number>();
     for (const seg of rawSegments) straightByKind.set(seg.kind, Math.max(straightByKind.get(seg.kind) ?? 0, seg.ownStraight));
     if (!inPlace && n > 25) {
+      for (const seg of rawSegments) {
+        seg.lengths = seg.lengths.map((l, i) => (continuousScale[i]! > 1e-6 ? l / continuousScale[i]! : l));
+        seg.ownStraight = percentile(seg.lengths, STRAIGHT_PERCENTILE);
+      }
+      straightByKind.clear();
+      for (const seg of rawSegments) straightByKind.set(seg.kind, Math.max(straightByKind.get(seg.kind) ?? 0, seg.ownStraight));
       const byChain = new Map<string, typeof rawSegments>();
       for (const seg of rawSegments) {
         const list = byChain.get(seg.chain) ?? [];
@@ -734,30 +800,15 @@ export function retarget(rest: Rest, map: JointMap, frames: ReadonlyArray<Partia
         byChain.set(seg.chain, list);
       }
       const chainTotals = [...byChain.values()].filter((list) => list.length >= 2).map((list) => list[0]!.lengths.map((_, i) => list.reduce((s, seg) => s + seg.lengths[i]!, 0)));
-      const rawBySeg = new Map(rawSegments.map((seg) => [seg, [...seg.lengths]]));
-      for (const seg of rawSegments) {
-        const globalStraight = straightByKind.get(seg.kind)!;
-        const peers = rawSegments.filter((s) => s.kind === seg.kind);
-        seg.lengths = rawBySeg.get(seg)!.map((l, i) => {
-          const lo = Math.max(0, i - 24);
-          const hi = Math.min(n, i + 25);
-          let localStraight = 0;
-          for (const peer of peers) localStraight = Math.max(localStraight, percentile(rawBySeg.get(peer)!.slice(lo, hi), STRAIGHT_PERCENTILE));
-          if (chainTotals.length > 0 && straightByKind.size >= 2) {
-            let sumKindStraight = 0;
-            for (const kind of straightByKind.keys()) {
-              let ks = 0;
-              for (const s of rawSegments) if (s.kind === kind) ks = Math.max(ks, percentile(rawBySeg.get(s)!.slice(lo, hi), STRAIGHT_PERCENTILE));
-              sumKindStraight += ks;
-            }
-            let maxChainTotal = 0;
-            for (const tot of chainTotals) maxChainTotal = Math.max(maxChainTotal, percentile(tot.slice(lo, hi), STRAIGHT_PERCENTILE));
-            if (sumKindStraight > maxChainTotal && maxChainTotal > 1e-6) {
-              localStraight *= maxChainTotal / sumKindStraight;
-            }
-          }
-          return localStraight > 1e-6 ? l * (globalStraight / localStraight) : l;
-        });
+      if (chainTotals.length > 0 && straightByKind.size >= 2) {
+        let sumKindStraight = 0;
+        for (const ks of straightByKind.values()) sumKindStraight += ks;
+        let maxChainTotal = 0;
+        for (const tot of chainTotals) maxChainTotal = Math.max(maxChainTotal, percentile(tot, STRAIGHT_PERCENTILE));
+        if (sumKindStraight > maxChainTotal && maxChainTotal > 1e-6) {
+          const k = maxChainTotal / sumKindStraight;
+          for (const [kind, ks] of straightByKind) straightByKind.set(kind, ks * k);
+        }
       }
     }
     for (const seg of rawSegments) {
@@ -838,7 +889,7 @@ export function retarget(rest: Rest, map: JointMap, frames: ReadonlyArray<Partia
     // (stanceOf's mechanism, its bounds) so its ankle stays on the floor. Before --stance, whose
     // floor is that supporting ankle. #95: the lower bound on a frame is the leg's own range there.
     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')! }, inPlace);
+    const lower = stanceRangeOf(ankleSeries, { r: series.get('r_hip')!, l: series.get('l_hip')! }, inPlace, continuousScale);
     blendHold = holdBlend(planted.blends, n, posedFeet, lower);
     const beforeBlendX = blendHold.stretch.map((b, i) => (b === null ? 0 : posedFeet(i).ankle[b.side][0]));
     stretchChain(blendHold.stretch);
@@ -1389,7 +1440,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, stance, floor, blendHold, closure, ankles, pivot: pivotOf(rest, t?.bone ?? null, legs), raised, byHip, face,
+    legScale, scales, feet, planted: plantOn, stance, floor, blendHold, closure, ankles, pivot: pivotOf(rest, t?.bone ?? null, legs), raised, byHip, face, figureScale,
   };
 }
 

package/src/run.ts

@@ -17,7 +17,7 @@ import { attachmentBones, baseMotionOf, buildInto, rigcVersion, folds, gate, rea
 import { artRangeLine, chainsMoving, raisedLine, RAISED_WITHIN, reachLine, switchLine, uncoveredFolds } from './switch.ts';
 import { landed, measureFeet, measureLanding, measurePosture, measureShear, poseFrames, postureLines } from './verify.ts';
 import { legsOf, PLANT_SWITCH, STANCE_BOUNDS } from './legs.ts';
-import { M2_IDENTITY, mulM2, reduceKeys, reduceScale, reduceUnderScale, SCALE_REDUCE, setupLocal, type M2, type ReduceBone, type Reduced, type ReduceRow, type UnderBone } from './reduce.ts';
+import { M2_IDENTITY, mulM2, reduceKeys, reduceScale, reduceUnderScale, SCALE_REDUCE, setupLocal, smoothTrunk, type M2, type ReduceBone, type Reduced, type ReduceRow, type UnderBone } from './reduce.ts';
 import type { BlendHold, Closure, Floor, LegScale, Lowered, Side, Stance, SupportScaleRun } from './legs.ts';
 import { faceLine } from './face.ts';
 
@@ -41,6 +41,8 @@ export interface RetargetArgs extends RetargetOptions {
   render?: string;
   /** Write the run's measurements as JSON here. */
   report?: string;
+  /** Write the sequence's per-frame relative figure scale and pan as a sidecar JSON here (#161). */
+  camera?: string;
   /** The rig's animation read as its idle (default: idle); naming one the motion spec lacks is refused. */
   idle?: string;
   /** Loop the idle's dropped tracks into the new animation (#43 item 2). */
@@ -72,7 +74,7 @@ export function runRetarget(a: RetargetArgs, log: (line: string) => void): RunRe
     if (path !== undefined && !existsSync(path)) args.add('ARG_PATH', `${flag} ${path} does not exist`);
   }
   // A file this run writes goes into a directory that is there already; --build and --render make theirs.
-  for (const [flag, path] of [['--out', a.out], ['--report', a.report]] as const) {
+  for (const [flag, path] of [['--out', a.out], ['--report', a.report], ['--camera', a.camera]] as const) {
     if (path === undefined) continue;
     const dir = dirname(path);
     if (!existsSync(dir)) args.add('ARG_PATH', `${flag} ${path} — directory ${dir} does not exist`);
@@ -292,6 +294,35 @@ export function runRetarget(a: RetargetArgs, log: (line: string) => void): RunRe
       if (!kept.green) refuse([{ code: 'RIG_GATE', text: `rigc build into --build ${a.build} is red where the same build was green in scratch (exit ${kept.run.status}); nothing written` }, ...kept.fails.map((x) => ({ code: 'RIGC', text: x }))]);
     }
     writeFileSync(a.out, `${JSON.stringify(motion, null, 2)}\n`);
+    if (a.camera !== undefined) {
+      const ss = r.figureScale.frames.map((x) => x.s);
+      const minS = ss.length === 0 ? 1 : Math.min(...ss);
+      const maxS = ss.length === 0 ? 1 : Math.max(...ss);
+      writeFileSync(a.camera, `${JSON.stringify({
+        spec: 'rig-pose-camera/1',
+        rig: input.name,
+        animation: a.name,
+        frames: r.figureScale.frames.map((f, i) => {
+          const cam = seq.camera?.[i];
+          const camS = cam?.s ?? 1;
+          return {
+            frame: f.frame,
+            t: f.t,
+            s: f.s,
+            rawS: f.rawS,
+            tx: cam?.tx ?? 0,
+            ty: cam?.ty ?? 0,
+            videoS: Number((f.s * camS).toFixed(6)),
+          };
+        }),
+        summary: {
+          minS,
+          maxS,
+          maxStep: r.figureScale.maxStep,
+          endOverStart: r.figureScale.endOverStart,
+        },
+      }, null, 2)}\n`);
+    }
     if (a.render !== undefined && f.meshes !== null && f.frames !== '') {
       rmSync(a.render, { recursive: true, force: true });
       cpSync(f.frames, a.render, { recursive: true });
@@ -330,8 +361,8 @@ export function runRetarget(a: RetargetArgs, log: (line: string) => void): RunRe
               face: {
                 ears: r.face.ears,
                 read: { yaw: r.face.read.yaw, pitch: r.face.read.pitch },
-                ...(r.face.yaw === undefined ? {} : { yaw: { bone: r.face.yaw.bone, limits: r.face.yaw.limits, read: r.face.yaw.read, mapped: r.face.yaw.mapped, scale: r.face.yaw.scale, corr: r.face.yaw.corr } }),
-                ...(r.face.pitch === undefined ? {} : { pitch: { bone: r.face.pitch.bone, limits: r.face.pitch.limits, read: r.face.pitch.read, mapped: r.face.pitch.mapped, scale: r.face.pitch.scale, corr: r.face.pitch.corr } }),
+                ...(r.face.yaw === undefined ? {} : { yaw: { bone: r.face.yaw.bone, limits: r.face.yaw.limits, knee: r.face.yaw.knee, read: r.face.yaw.read, mapped: r.face.yaw.mapped, scale: r.face.yaw.scale, corr: r.face.yaw.corr } }),
+                ...(r.face.pitch === undefined ? {} : { pitch: { bone: r.face.pitch.bone, limits: r.face.pitch.limits, knee: r.face.pitch.knee, read: r.face.pitch.read, mapped: r.face.pitch.mapped, scale: r.face.pitch.scale, corr: r.face.pitch.corr } }),
               },
             }),
         legScale: r.legScale.map(({ scale: _scale, asked: _asked, ...rest }) => rest),
@@ -345,6 +376,7 @@ export function runRetarget(a: RetargetArgs, log: (line: string) => void): RunRe
         reduce: reduced === null ? null : { tolerance: a.reduce, hipTolerance: a.reduceHip ?? null, rows: reduced.rows },
       }, null, 2)}\n`);
     }
+    if (a.camera !== undefined) say(`  wrote ${a.camera} — camera track (${r.figureScale.frames.length} frames)`);
     say(`  wrote ${a.out} — animations: ${Object.keys(motion.animations).join(', ')}`);
     return { lines, written: true };
   } finally {
@@ -412,6 +444,15 @@ function reduceTracks(r: ReturnType<typeof retarget>, map: JointMap, rest: Rest,
   if (hipTrack !== undefined && out.hip !== null) hipTrack.keys = out.hip;
   if (scalex.size === 0) return out;
 
+  // #116: smooth the trunk-and-head chain within the stated tolerance while keeping limb landings and jitter within 0.04.
+  const trunkBones = new Set(
+    map.chains
+      .filter((c) => c.bones.length === 1 && !(c.joints.includes('r_hip') && c.joints.includes('l_hip')))
+      .map((c) => c.bones[0]!),
+  );
+  smoothTrunk(r.times, bones, tolerance, out, trunkBones);
+  for (const [bone, keys] of out.rotate) rotate.get(bone)!.keys = keys;
+
   // #94: the scales of the bones the key formula holds for, then the bones under a scaled bone, parents first.
   const rows = new Map<string, ReduceRow>();
   for (const row of out.rows) if (row.kind === 'angle') rows.set(`rotate ${row.bone}`, row);

package/src/switch.ts

@@ -498,10 +498,9 @@ export function selectSwitches(map: JointMap, targets: ReadonlyMap<string, reado
       for (let i = sw.frames[0]; i <= sw.frames[1]; i++) row[i] = o;
     }
   }
-  // #136: when a group's base setup slots sit in front of the torso, an unswitched gap between two
-  // behind-the-torso switches keeps each chain on its behind-the-torso slots on the frames where that
-  // chain stays within tolerance of the surrounding behind sets (with the same minimum-span bridging),
-  // and across a joint behind-to-behind transition where all chains move from one behind set to another.
+  // #136/#139/#162: between two sets that both draw an arm behind the torso, a frame that belongs to
+  // neither set stays behind (the nearer set's layer). The default front slot is for a frame no set can
+  // claim and whose arm is read in front — not a fallback.
   const chainHolds: Array<{ set: string; chain: string; frames: [number, number] }> = [];
   for (const group of groups) {
     const layer = groupLayering(group, map, slots);
@@ -578,6 +577,56 @@ export function selectSwitches(map: JointMap, targets: ReadonlyMap<string, reado
           return false;
         });
         if (!frontNear) for (const cn of chains) for (let i = g0; i <= g1; i++) cPick.get(cn)![i] = set0;
+      } else {
+        for (const cn of chains) {
+          const arr = cPick.get(cn)!;
+          const frontSets = group.filter((a) => layer.isFront(a) && a.chains.includes(cn));
+          const d0s = byChain.get(set0.name)?.get(cn);
+          const d1s = byChain.get(set1.name)?.get(cn);
+          for (let i = g0; i <= g1; i++) {
+            if (arr[i] !== null) continue;
+            const claimedFront = frontSets.some((f) => (byChain.get(f.name)?.get(cn)?.[i] ?? Infinity) <= opts.switchTolerance);
+            if (!claimedFront) {
+              const d0 = d0s?.[i] ?? Infinity;
+              const d1 = d1s?.[i] ?? Infinity;
+              arr[i] = d0 <= d1 ? set0 : set1;
+            }
+          }
+          for (let i = g0; i <= g1;) {
+            const a = arr[i];
+            let j = i;
+            while (j + 1 <= g1 && arr[j + 1] === a) j++;
+            const before = arr[i - 1] ?? null;
+            const after = arr[j + 1] ?? null;
+            const span = times[j + 1]! - times[i]!;
+            if (span < opts.switchMin - 1e-9) {
+              if (a === null && before !== null && after !== null) {
+                for (let k = i; k <= j; k++) {
+                  const d0 = d0s?.[k] ?? Infinity;
+                  const d1 = d1s?.[k] ?? Infinity;
+                  arr[k] = d0 <= d1 ? set0 : set1;
+                }
+              } else if (before !== null && before === after && a !== before) {
+                for (let k = i; k <= j; k++) arr[k] = before;
+              }
+            }
+            i = j + 1;
+          }
+          for (let i = g0; i <= g1;) {
+            const a = arr[i];
+            let j = i;
+            while (j + 1 <= g1 && arr[j + 1] === a) j++;
+            const before = arr[i - 1] ?? null;
+            const after = arr[j + 1] ?? null;
+            if (before !== null && before === after && a !== before && times[j + 1]! - times[i]! < opts.switchMin - 1e-9) {
+              for (let k = i; k <= j; k++) arr[k] = before;
+            } else if (a !== null && i > g0 && j < g1 && times[j + 1]! - times[i]! < opts.switchMin - 1e-9) {
+              const fill = before ?? after ?? null;
+              for (let k = i; k <= j; k++) arr[k] = fill;
+            }
+            i = j + 1;
+          }
+        }
       }
       for (const s of layer.touched) {
         if (!shown.has(s)) shown.set(s, Array.from({ length: n }, () => slots.get(s)!.setup));