@rig-c/pose 0.9.0 → 0.11.0

package/README.md

@@ -54,9 +54,11 @@ and what the run cannot decide for you it lists:
 - `PIVOT` — when the map translates a bone and has both legs: the translated bone's origin against its thigh roots' midpoint at setup, in units and hip widths — the pivot every hip turn swings the legs about.
 - `FEET` — when the map has both legs: the supports and jumps read off the reference ankles (planted or not), and on the posed build, outside the jumps, the lowest ankle's vertical range and each support span's worst vertical range and horizontal drift of the supporting ankle, in leg lengths.
 - `SHEAR` — with `--leg-scale`: every scaled bone and every bone under one, how far its art is sheared and how long its world axes are against setup. A reading.
+- `IDLE`, `IDLE-DROPPED`, `IDLE-KEPT-OUT`, `MERGE` — the rig's idle against the new animation, and what `--carry-idle` and `--merge` put back ([below](#the-idle-what-the-retarget-drops)).
+- `REDUCE` — with `--reduce` ([below](#few-keys---reduce)): per bone, its keys before and after and its largest error, with the frame; then the total.
 - `TURN` — a line across the body (hips, shoulders, eyes) shorter in the picture than 0.5 of its median length, or reversed, for at least 0.15 s: the body or the head turned. A reading of the pose, made whether or not the map uses the line; it changes no key. The demand for a turned-body drawing, as `END-ON` is for a foreshortened limb.
 
-`--report <file>` writes all of it as JSON (`rig-pose-report/1`): `options` (every figure the run used, `switchTolerance`, `switchMin`, `switchAt`, `legScale` and `plantFeet` included), `scale`, `holds`, `short`, `endOn`, `bends`, `flips`, `gate`, `landings`, `posture`, `folds`, `legScale`, `pivot`, `feet` (`planted`, `legLength`, `floor`, `supports`, `jumps`, `changes`, and the posed `reading`), `shear`, and the demand lists:
+`--report <file>` writes all of it as JSON (`rig-pose-report/1`): `options` (every figure the run used, `switchTolerance`, `switchMin`, `switchAt`, `legScale` and `plantFeet` included), `scale`, `holds`, `short`, `endOn`, `bends`, `flips`, `gate`, `landings`, `posture`, `folds`, `legScale`, `pivot`, `feet` (`planted`, `legLength`, `floor`, `supports`, `jumps`, `changes`, and the posed `reading`), `shear`, `idleDropped`, `idleKeptOut` and `merged` ([below](#the-idle-what-the-retarget-drops)), `reduce` (the tolerances and each row of `REDUCE`, [below](#few-keys---reduce)), and the demand lists:
 
 - `switches: [{ set, chains, slots, hides, offsets, from, to, frames: [first, last], distance: { max, median }, artTurn: { <bone>: { max, median } }, moved: { on, off } }]` — one per span shown; `from` is the first frame's time, `to` the time the base art comes back (the animation's end when the span runs to it), `distance` in degrees over the frames shown, `artTurn` |wrap(target − drawn)| in degrees per bone the set has a `drawn` angle for. `moved.on` is the boundary the span starts on (null from the first frame), `moved.off` the one the base art or the next set comes back on (null to the end), each `{ frame: [selected, keyed], frames, seconds, window: [first, last], speed: { old, new } }`: signed frames and seconds, the frames it could move to, and the speed in degrees per frame on the old and the new frame. A boundary between two sets is the same entry in both.
 - `uncovered: [{ slot, attachment, chains, times }]` — every entry of `folds` on the times its slot still shows that mesh, with the map's chains that move it (the deepest: the arm, not the trunk it hangs from). `rigc render --folds` reads only what the pose shows, so a mesh swapped out or hidden by a switch is not read on those frames at all; `uncovered` is the fold times less the switched ones.
@@ -109,6 +111,42 @@ rig-c's `scalex` multiplies the bone's x axis, and a child with the `normal` inh
 
 Both are checked on the gated build: every scale lands, each ankle lands where the keys put it, and the hip's origin where the plant put it. The figures were fixed in #47 before the dancer was measured; the defaults stay off until they pass.
 
+### The idle: what the retarget drops
+
+A rig's motion spec usually has an `idle` — a blink, a breath, hair and hem sway — and the new animation keys none of it ([#43](https://github.com/rig-c/pose/issues/43), item 2). The run reads that animation (`--idle <name>` names another; naming one the spec lacks is `IDLE_NAME`) track by track against the new one, channel by channel — `translate` poses `translatex` and `translatey`, a `group` track poses each of its members, a slot's `rgba` its `rgb` and `alpha`:
+
+- `IDLE-DROPPED` — a track the new animation keys on none of its channels, and that turns no mapped bone (below): its target, property, keys and the idle's duration. The report lists them under `idleDropped` (`target`, `members`, `property`, `keys`, `duration`, `carried`, `notCarried`).
+- `IDLE-KEPT-OUT` — never carried (`idleKeptOut`), with the reason: a track the new animation keys itself, naming the track that keys it; or a `rotate`, `scale` or `shear` (any axis) of a bone **above** a mapped bone — between mapped bones, or above the first one (the map's chains and its translated bone) — naming the mapped bones below it: the retarget's keys hold every unmapped bone at its setup pose, so such a track would turn them off the angles the pose asks. A `translate` of such a bone is carried: it moves the bones under it and turns none. The exception is a translate of a bone above the **translated** bone (the hip), which is kept out because the retarget places that bone's origin. (Folding a carried parent's motion into the mapped bones' keys is a later card.) The idle's `drawOrder`, `events`, `ik`, `transform`, `deform` and `sequence` timelines are not tracks, and are listed here too.
+
+**`--carry-idle`** (off by default: a blink keyed over a set's art may not suit it, and that is the author's call) loops every dropped track into the new animation: the idle's keys repeated every idle duration and cut at the new animation's end, with the value interpolated there.
+
+- A key's `ease` or `curve` describes the segment to the next key, so a loop is built key by key. Where the idle's last key is at its duration and its first at 0, the two are one key at each seam (the next cycle's first; if their values differ, the line says where the loop jumps, as a player looping the idle does). Where the last key is earlier, it is keyed `stepped`, so it holds to the cycle's end as it does in the idle. Where the first key is later than 0, each later cycle opens with a stepped setup key: 0 for a bone's translate, shear and rotate, 1 for its scale, the slot's setup attachment; for any other property such a track is not carried, and the line says why.
+- A raw `curve` states absolute times, so a repeated one is shifted with its key. The segment the cut falls in is split there: linear and stepped as they are, a Bézier (a raw `curve`, or a named easing turned into one as rigc does) by de Casteljau, so the part kept is the same cubic and the last key carries neither ease nor curve. rig-c draws a Bézier as Spine's polyline, so a split segment and the idle's whole one sit off the cubic, and off each other, by that alone (measured on the test's eased segment: the idle's own up to 2.6e-3, the carried part up to 9.3e-4).
+- A track with `lag` or `stagger`, or whose values are per-member maps or models, is not carried, and the line says so.
+
+Every bone still has to land with the carried tracks in. A carried translate above the translated bone moves its origin off the pose's travel, and the run refuses with `POSE_LANDS`, naming the carried tracks above the bone that missed.
+
+On HQ's dancer (`--flip 90 --short 0.35 --bends clamp --carry-idle`) the idle has 26 tracks. Kept out: the four arm rotates, which the dance keys, and `chest_ctl` scalex, `neck` rotate and `head_ctl` rotate, which sit above the mapped chest, head and arms — carried, they missed the chest, the head and the arms by 0.16°–1.37°. Carried: the other 19, the blink (`group "eyes"` scaley) and the breath (`bone "chest_ctl"` translatey) among them. The gate is green, every bone lands (worst 0.00167°), and rig-c's poser shows the blink at every cycle (scaleY 0.12 at 2.37 s, 5.70 s, 9.08 s and 12.41 s, against the idle's at t mod 3.333 s within 8.9e-6) and the breath's chest_ctl offset (5.02 at 0.833, 4.167, 7.5, 10.833 s; 0 at 2.5, 5.833, 9.167, 12.5 s; 1.035 at the cut, 13 s).
+
+**`--merge <file>`** merges a timed track fragment into the new animation, at absolute times from its start — blinks read off the video, for example:
+
+```json
+{ "spec": "rig-pose-tracks/1", "tracks": [ { "group": "eyes", "property": "scaley", "keys": [ { "t": 2.3, "v": [1] }, { "t": 2.37, "v": [0.12] }, { "t": 2.45, "v": [1] } ] } ] }
+```
+
+Each track is a rigc-motion track. One posing a channel the new animation (or a carried idle track, or an earlier fragment track) already keys is refused by name (`MERGE_CONFLICT`): a fragment adds a track, it never replaces one. So is a key before 0 or past the animation's duration (`MERGE_TIME`), and a file of any other shape (`MERGE_SPEC`). What the track means — its target, property and values — is rigc's to judge: its gate checks every merged track like any other (`RIG_GATE`). `MERGE` lists each track merged; the report lists them under `merged`.
+
+### Few keys: `--reduce`
+
+The retarget writes one key per pose frame on every mapped bone. That is faithful, but nobody can edit it by hand. **`--reduce <deg>`** (off by default) thins each mapped bone's `rotate` track to a few keys with curves, so that every bone's **world** aim stays within `deg` of the dense keys on every pose frame. **`--reduce-hip <units>`** does the same for the hip's `translate`, holding its world origin within `units`; without it, the hip stays dense.
+
+- **Keys stay on the pose's own frame times.** Between two kept keys, the span is linear if a straight line is within the tolerance. Otherwise it gets one raw Bézier `curve`, with its handles at the span's thirds and its values fitted by least squares. The error is measured the way rig-c's poser evaluates a curve (its 10-piece polyline). A span still over the tolerance gets a key at its worst frame, and both halves are fitted again.
+- **Errors do not pile up down a chain.** Bones are fitted top-down, and each bone is fitted against its dense key less the error its nearest mapped parent already carries. So a bone's world error is its own fit error.
+- **Kept regardless:** the first and last frame; the frames either side of a switch boundary, on the chains the switch changes; and the first and last frame of every `FLIP` spread, `SHORT` span and `RANGE` run, on that bone.
+- **The landing check holds the dense targets** with the tolerance added (0.01° + `deg`; 0.01 + `units`), and it is posed by rig-c as always.
+- **On HQ's dancer** (`--smooth 7 --flip 90 --short 0.35 --bends clamp`; 313 frames, 11 mapped bones): `--reduce 1 --reduce-hip 1` takes the rotate keys from 3443 to 588 (5.86×), 296 of the spans curved, and the hip's translate keys from 313 to 96. The gate is green. rig-c's poser lands every bone within 0.9998° of the dense target (head) and the hip within 0.901 units. At 0.5° the keys drop 3.92×; at 2°, 8.38×.
+- **Not combined with `--leg-scale` or `--plant-feet`.** Their keys land a bone through a scaled parent or an ankle's lever, which this tolerance does not bound (rig-c/pose#32).
+
 Exit codes: `0` written, `1` refused (every reason printed, nothing written), `2` bad invocation. `rig-pose --help` has every flag.
 
 ## The pose: `rig-pose-sequence/1`

package/cli.ts

@@ -64,6 +64,26 @@ retarget
                         travel and re-plants on landing; a supporting ankle moving > 0.03 leg lengths a frame
                         releases its plant to the other foot, or to the pose's travel, until it is still
                         (< 0.01 for 2 frames) (FEET lines)
+  --idle <name>         the rig's animation read as its idle (default: idle). Every idle track the new
+                        animation does not key, on any channel, is listed as IDLE-DROPPED (a blink, a
+                        breath); one it keys is IDLE-KEPT-OUT, naming the track that keys it, and so is a
+                        rotate, scale or shear of a bone above a mapped bone (a translate of one is carried)
+  --carry-idle          loop the IDLE-DROPPED tracks into the new animation: the idle's keys repeated
+                        every idle duration and cut at the new animation's end, with the value
+                        interpolated there (default: off — a blink keyed over a set's art is the author's call)
+  --merge <file>        merge rig-pose-tracks/1 into the new animation: { "spec": "rig-pose-tracks/1",
+                        "tracks": [ <rigc-motion track> … ] } at absolute times from its start (blinks read
+                        off the video); a track on a target and property it already keys is refused
+                        (MERGE_CONFLICT), and so is a key past its duration (MERGE_TIME)
+  --reduce <deg>        thin each mapped bone's rotate keys to few keys with curves (linear, or one raw
+                        Bezier per span with handles at its thirds), on the pose's own frame times, so every
+                        bone's world aim stays within deg of the dense keys on every frame; fitted top-down,
+                        each bone against its parent's reduced error, so errors do not pile up down a chain.
+                        Kept regardless: the first and last frame, the frames either side of a switch boundary
+                        on the chains it changes, and the edges of every FLIP spread, SHORT span and RANGE run
+                        (REDUCE lines; default: off). Not with --leg-scale or --plant-feet (rig-c/pose#32)
+  --reduce-hip <units>  with --reduce, thin the hip's translate keys too, its world origin within units
+                        of the dense keys (default: the hip stays dense)
   --switch-tolerance <d>  a set of alternate drawings (the map's "alternates") may show on a frame where
                         every segment of its chains is within d degrees of its key skeleton (default: 25)
   --switch-min <s>      a run of one set shorter than s seconds is dropped (default: 0.25)
@@ -75,7 +95,8 @@ retarget
   --build <dir>         keep the gated build (skeleton.json, .atlas, .model.json) here
   --render <dir>        keep rigc's render of the animation (frames, contact.png, folds.json) here
   --report <file>       write the run's measurements (holds, short, endOn, flips, bends, landings, folds,
-                        switches, uncovered, turns, range, artRange) as JSON
+                        switches, uncovered, turns, range, artRange,
+                        idleDropped, idleKeptOut, merged, reduce) as JSON
 
   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.
@@ -179,7 +200,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'], ['coco', 'plant-feet']);
+  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'], ['coco', 'plant-feet', 'carry-idle']);
   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';
@@ -213,9 +234,26 @@ function retargetArgs(argv: string[]): RetargetArgs {
     build: f.get('build'),
     render: f.get('render'),
     report: f.get('report'),
+    idle: f.get('idle'),
+    carryIdle: f.has('carry-idle'),
+    merge: f.get('merge'),
+    ...reduceOf(f),
   };
 }
 
+/** --reduce and --reduce-hip (rig-c/pose#32): off unless given; the hip only with the bones. */
+function reduceOf(f: Map<string, string>): { reduce?: number; reduceHip?: number } {
+  if (!f.has('reduce')) {
+    if (f.has('reduce-hip')) throw new Usage('--reduce-hip is given without --reduce; the hip is thinned with the bones, not alone');
+    return {};
+  }
+  const reduce = num(f, 'reduce', 0, (n) => n > 0 && n < 180, 'degrees in (0, 180)');
+  for (const other of ['leg-scale', 'plant-feet'] as const) {
+    if (f.has(other) && f.get(other) !== 'off') throw new Usage(`--reduce is given with --${other}; their keys land a bone through a scaled parent or an ankle's lever, which the reduction's tolerance does not bound (rig-c/pose#32 round 1)`);
+  }
+  return f.has('reduce-hip') ? { reduce, reduceHip: num(f, 'reduce-hip', 0, (n) => n > 0, 'rig units > 0') } : { reduce };
+}
+
 function compareArgs(argv: string[]): CompareArgs {
   const f = parseFlags(argv, ['reference', 'render', 'map', 'retarget-report', 'reference-hands', 'render-hands', 'cloth-reference', 'cloth-render', 'cloth-windows', 'report', 'sheet'], []);
   const pair = (x: string, y: string) => {

package/package.json

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

package/src/idle.ts

@@ -0,0 +1,421 @@
+/**
+ * The tracks a retarget drops, and the two ways to put them back (rig-c/pose#43
+ * item 2): the rig's idle read against the new animation, its dropped tracks
+ * looped into it with `--carry-idle`, and a timed fragment merged with `--merge`.
+ *
+ * Pure: the motion spec's own track objects in, track objects out. What a
+ * merged or carried track means (its bone, its property, its values) is rig-c's
+ * to judge, and its gate judges it with the animation in.
+ *
+ * A key's `ease` or `curve` describes the segment from that key to the next
+ * (rig-c docs/AUTHORING.md §4.5), so a loop is built key by key: where one
+ * cycle meets the next, the key that ends a cycle and the one that starts the
+ * next must not share a time, and the segment into the seam must ease toward
+ * the value the loop shows there. A raw `curve` states absolute times, so a
+ * repeated one is shifted with its key. The last key of the whole track carries
+ * neither.
+ */
+import { isObject, Problems, typeName, type Problem } from './problems.ts';
+
+/** A rigc-motion track as the motion spec states it: one target field, a property, keys, and whatever else it carries. */
+export type RigcTrack = Record<string, unknown> & { property: string; keys: RigcKey[] };
+export type RigcKey = Record<string, unknown> & { t: number; v: unknown; ease?: string; curve?: number[] };
+
+/** The six target fields of a track (AUTHORING §4.4). */
+const TARGET_FIELDS = ['bone', 'slot', 'group', 'physics', 'path', 'slider'] as const;
+type TargetKind = (typeof TARGET_FIELDS)[number];
+
+/** What each bone and slot property poses, channel by channel: two tracks that share a channel key the same thing. */
+const BONE_CHANNELS: Readonly<Record<string, readonly string[]>> = {
+  translate: ['translatex', 'translatey'], translatex: ['translatex'], translatey: ['translatey'],
+  scale: ['scalex', 'scaley'], scalex: ['scalex'], scaley: ['scaley'],
+  shear: ['shearx', 'sheary'], shearx: ['shearx'], sheary: ['sheary'],
+  rotate: ['rotate'], inherit: ['inherit'],
+};
+const SLOT_CHANNELS: Readonly<Record<string, readonly string[]>> = {
+  attachment: ['attachment'], rgba: ['rgb', 'alpha'], rgb: ['rgb'], alpha: ['alpha'], rgba2: ['rgb', 'alpha', 'dark'], rgb2: ['rgb', 'dark'],
+};
+/** A bone property whose setup value, as a key states it, is known without reading the rig: translate and shear add to setup (0), scale multiplies it (1). */
+const BONE_IDENTITY: Readonly<Record<string, number>> = {
+  translate: 0, translatex: 0, translatey: 0, shear: 0, shearx: 0, sheary: 0, rotate: 0, scale: 1, scalex: 1, scaley: 1,
+};
+/** The bone properties that only move a bone: a child's angle is unchanged, so one on a bone above a mapped bone is carried. */
+const TRANSLATES = new Set(['translate', 'translatex', 'translatey']);
+/** Timelines stepped by the format: a key carries no ease and no curve, and no value lies between two keys. */
+const STEPPED_BY_NATURE = new Set(['attachment', 'inherit', 'reset']);
+
+/** A target and its name: `bone "neck"`, `group "eyes"`. */
+export interface Target {
+  kind: TargetKind;
+  name: string;
+}
+
+export function targetOf(track: Record<string, unknown>): Target | null {
+  const found = TARGET_FIELDS.filter((f) => typeof track[f] === 'string');
+  return found.length === 1 ? { kind: found[0]!, name: track[found[0]!] as string } : null;
+}
+
+/** `group "eyes" (eye_r, eye_l) scaley`, `bone "chest_ctl" translatey`. */
+export function trackLabel(track: RigcTrack, groups: Readonly<Record<string, readonly string[]>>): string {
+  const t = targetOf(track);
+  if (t === null) return `a track with no single target, property ${JSON.stringify(track.property)}`;
+  const members = t.kind === 'group' && groups[t.name] !== undefined ? ` (${groups[t.name]!.join(', ')})` : '';
+  return `${t.kind} "${t.name}"${members} ${track.property}`;
+}
+
+/**
+ * Every channel a track poses, as `family:name:channel`: a group's members are
+ * bones, slots or physics constraints by its property (AUTHORING §4.3), so a
+ * group track collides with a bone track on one of its members.
+ */
+function cellsOf(track: RigcTrack, groups: Readonly<Record<string, readonly string[]>>): string[] {
+  const t = targetOf(track);
+  if (t === null) return [];
+  const p = track.property;
+  const family = (kind: TargetKind): 'bone' | 'slot' | 'physics' | 'path' | 'slider' => {
+    if (kind !== 'group') return kind;
+    if (p in BONE_CHANNELS) return 'bone';
+    if (p in SLOT_CHANNELS) return 'slot';
+    return 'physics';
+  };
+  const fam = family(t.kind);
+  const channels = fam === 'bone' ? BONE_CHANNELS[p] ?? [p] : fam === 'slot' ? SLOT_CHANNELS[p] ?? [p] : [p];
+  const names = t.kind === 'group' ? groups[t.name] ?? [] : [t.name];
+  return names.flatMap((n) => channels.map((c) => `${fam}:${n}:${c}`));
+}
+
+/** Which channels the tracks pose, each with the label of the track posing it. */
+export function keyedBy(tracks: readonly RigcTrack[], groups: Readonly<Record<string, readonly string[]>>): Map<string, string> {
+  const out = new Map<string, string>();
+  for (const tr of tracks) for (const c of cellsOf(tr, groups)) if (!out.has(c)) out.set(c, trackLabel(tr, groups));
+  return out;
+}
+
+/** The labels of the tracks in `keyed` that pose a channel `track` poses. */
+function collisions(track: RigcTrack, keyed: ReadonlyMap<string, string>, groups: Readonly<Record<string, readonly string[]>>): string[] {
+  return [...new Set(cellsOf(track, groups).flatMap((c) => (keyed.has(c) ? [keyed.get(c)!] : [])))];
+}
+
+export interface IdleDropped {
+  target: Target;
+  /** A group's members, as the motion spec's `groups` names them. */
+  members: string[] | null;
+  property: string;
+  /** The track's keys in the idle. */
+  keys: number;
+  /** The idle's duration, seconds. */
+  duration: number;
+  /** With --carry-idle: the looped track's keys, the cycles they span, and where a seam jumps. */
+  carried: { keys: number; cycles: number; seams: string | null } | null;
+  /** With --carry-idle: why this track was not carried. */
+  notCarried: string | null;
+}
+
+export interface IdleKeptOut {
+  target: Target;
+  property: string;
+  reason: string;
+}
+
+export interface IdleReading {
+  animation: string;
+  duration: number;
+  tracks: number;
+  dropped: IdleDropped[];
+  keptOut: IdleKeptOut[];
+  /** The idle's timelines that are not tracks (drawOrder, events, ik, transform, deform, sequence): never compared, never carried. */
+  notTracks: string[];
+  /** With --carry-idle: the looped tracks, in the idle's order. */
+  carriedTracks: RigcTrack[];
+}
+
+const NOT_TRACKS = ['drawOrder', 'events', 'ik', 'transform', 'deform', 'sequence'] as const;
+
+/**
+ * The idle against the new animation: every idle track the new one does not
+ * key on any channel is dropped (and, with `carry`, looped into it); every one
+ * it keys is kept out, naming the track that keys it.
+ */
+export function readIdle(
+  name: string,
+  /** The new animation's name. */
+  into: string,
+  idle: Record<string, unknown>,
+  newTracks: readonly RigcTrack[],
+  duration: number,
+  motion: { groups: Readonly<Record<string, readonly string[]>>; easings: Readonly<Record<string, readonly number[]>> },
+  /** The setup value a key on this target and property states (`sample` is one of its keys' values), or undefined when it is not read. */
+  setupOf: (target: Target, property: string, sample: unknown) => unknown,
+  carry: boolean,
+  /** The mapped bones (chains and the translated bone) under a bone, in map order. */
+  mappedBelow: (bone: string) => readonly string[] = () => [],
+  /** The translated bone (the hip) when it lies under this bone, else null: a translate above it moves the origin the retarget places. */
+  translatedBelow: (bone: string) => string | null = () => null,
+): IdleReading {
+  const D = idle.duration as number;
+  const tracks = (Array.isArray(idle.tracks) ? idle.tracks : []) as RigcTrack[];
+  const keyed = keyedBy(newTracks, motion.groups);
+  const dropped: IdleDropped[] = [];
+  const keptOut: IdleKeptOut[] = [];
+  const carriedTracks: RigcTrack[] = [];
+  for (const tr of tracks) {
+    const target = targetOf(tr);
+    if (target === null) continue;
+    const hit = collisions(tr, keyed, motion.groups);
+    if (hit.length > 0) {
+      keptOut.push({ target, property: tr.property, reason: `"${into}"'s own ${hit.join(', ')} keys it` });
+      continue;
+    }
+    // A rotate, scale or shear above a mapped bone turns it off the angle its keys assume (the key formula holds unmapped bones at setup).
+    const bones = target.kind === 'bone' ? [target.name] : target.kind === 'group' && tr.property in BONE_CHANNELS ? [...(motion.groups[target.name] ?? [])] : [];
+    const under = TRANSLATES.has(tr.property) ? [] : [...new Set(bones.flatMap((b) => mappedBelow(b)))];
+    const hipBelow = TRANSLATES.has(tr.property) ? bones.map((b) => translatedBelow(b)).find((h) => h !== null) ?? null : null;
+    if (hipBelow !== null) {
+      keptOut.push({ target, property: tr.property, reason: `moves the translated bone "${hipBelow}" below it; the retarget places its origin` });
+      continue;
+    }
+    if (under.length > 0) {
+      keptOut.push({ target, property: tr.property, reason: `moves mapped bone(s) ${under.map((b) => `"${b}"`).join(', ')} below it; the retarget's keys assume it at setup` });
+      continue;
+    }
+    const entry: IdleDropped = { target, members: target.kind === 'group' ? [...(motion.groups[target.name] ?? [])] : null, property: tr.property, keys: tr.keys.length, duration: D, carried: null, notCarried: null };
+    if (carry) {
+      const c = loopTrack(tr, D, duration, motion.easings, () => setupOf(target, tr.property, tr.keys[0]?.v));
+      if ('reason' in c) entry.notCarried = c.reason;
+      else {
+        entry.carried = { keys: c.track.keys.length, cycles: c.cycles, seams: c.seams };
+        carriedTracks.push(c.track);
+      }
+    }
+    dropped.push(entry);
+  }
+  const notTracks = NOT_TRACKS.filter((k) => idle[k] !== undefined);
+  return { animation: name, duration: D, tracks: tracks.length, dropped, keptOut, notTracks, carriedTracks };
+}
+
+const r6 = (v: number): number => Math.round(v * 1e6) / 1e6;
+/** Two times this close are one time (key times are written to 1e-6 s). */
+const EPS = 1e-7;
+
+const numeric = (v: unknown): v is number[] => Array.isArray(v) && v.length > 0 && v.every((x) => typeof x === 'number' && Number.isFinite(x));
+
+/**
+ * One idle track looped to `T` seconds: its keys repeated every `D` seconds and
+ * cut at `T`, with the value interpolated there.
+ *
+ * - Where the idle's last key is at `D` and its first at 0 (a closed loop), the
+ *   two are one key at each seam: the next cycle's first. A last key that
+ *   differs from the first is a jump in the idle as a player loops it (at `D`
+ *   it shows the first key), and the seam keys the first; `seams` says so.
+ * - Where the last key is before `D`, the player holds it to `D`: it is keyed
+ *   `stepped` (a timeline stepped by the format holds anyway).
+ * - Where the first key is after 0, the player shows the setup value from each
+ *   cycle's start to that key: a stepped setup key opens each later cycle. That
+ *   needs the setup value as a key states it, which this reads only for a bone's
+ *   translate, scale, shear and rotate (0, 1, 0, 0) and a slot's attachment.
+ */
+export function loopTrack(
+  track: RigcTrack,
+  D: number,
+  T: number,
+  easings: Readonly<Record<string, readonly number[]>>,
+  setup: () => unknown,
+): { track: RigcTrack; cycles: number; seams: string | null } | { reason: string } {
+  if (track.lag !== undefined || track.stagger !== undefined) return { reason: `it carries ${track.lag !== undefined ? '"lag"' : '"stagger"'}, which shifts its keys per track or per member; a loop is cut by key time, so it is not carried` };
+  const keys = track.keys;
+  if (keys.length === 0) return { reason: 'it has no keys' };
+  const nature = STEPPED_BY_NATURE.has(track.property);
+  if (!nature && !keys.every((k) => numeric(k.v))) return { reason: 'a key\'s value is not a list of numbers (a per-member map or a model), and a cut needs the value between two keys' };
+  if (!(D > 0)) return { reason: `the idle's duration is ${D}` };
+  const first = keys[0]!.t;
+  const last = keys[keys.length - 1]!.t;
+  let setupKey: unknown;
+  if (first > EPS) {
+    setupKey = setup();
+    if (setupKey === undefined) return { reason: `its first key is at t=${first}s, so a loop shows the setup value of ${track.property} before it in every cycle, and this package does not read that value for this target` };
+  }
+
+  const shift = (k: RigcKey, off: number): RigcKey => {
+    const out: RigcKey = { ...k, t: r6(off + k.t) };
+    if (Array.isArray(k.curve)) out.curve = k.curve.map((x, i) => (i % 2 === 0 ? r6(off + x) : x));
+    return out;
+  };
+  const hold = (k: RigcKey): void => {
+    if (nature) return;
+    delete k.curve;
+    k.ease = 'stepped';
+  };
+  const same = (a: unknown, b: unknown) => JSON.stringify(a) === JSON.stringify(b);
+  const out: RigcKey[] = [];
+  const jumps: number[] = [];
+  let cycles = 0;
+  for (let k = 0; k * D <= T + EPS; k++) {
+    const off = k * D;
+    if (k > 0) {
+      const prev = out[out.length - 1]!;
+      const opens: unknown = first > EPS ? setupKey : keys[0]!.v;
+      if (prev.t >= r6(off) - EPS) {
+        // The key that ends the last cycle sits on the seam: the loop shows the next cycle's start there.
+        out.pop();
+        if (!same(prev.v, opens)) jumps.push(r6(off));
+      } else hold(prev);
+      if (first > EPS) {
+        const s: RigcKey = { t: r6(off), v: setupKey };
+        if (!nature) s.ease = 'stepped';
+        out.push(s);
+      }
+    }
+    for (const key of keys) out.push(shift(key, off));
+    cycles++;
+    if (out[out.length - 1]!.t > T + EPS) break;
+  }
+
+  // The cut at T.
+  const kept = out.filter((x) => x.t <= T + EPS);
+  if (kept.length === 0) return { reason: `its first key, at t=${first}s, is past the new animation's ${T}s` };
+  for (const x of kept) if (Math.abs(x.t - T) <= EPS) x.t = T;
+  const after = out[kept.length];
+  const end = kept[kept.length - 1]!;
+  if (after !== undefined && end.t < T - EPS && !nature) {
+    const c = cutAt(end, after, T, easings);
+    if ('reason' in c) return c;
+    kept.push({ t: T, v: c.v });
+  }
+  const tail = kept[kept.length - 1]!;
+  delete tail.ease;
+  delete tail.curve;
+  const seams = jumps.length === 0 ? null : `the idle's last key (t=${last}s, ${JSON.stringify(keys[keys.length - 1]!.v)}) is not what it shows at its start (${JSON.stringify(first > EPS ? setupKey : keys[0]!.v)}); the loop keys the start at each seam, so it jumps at t=${jumps.map((t) => t.toFixed(3)).join(', ')}s`;
+  return { track: { ...track, keys: kept }, cycles, seams };
+}
+
+/**
+ * The value at `T` inside the segment from `a` to `b`, and `a`'s segment cut
+ * there: stepped holds `a`; linear interpolates; a Bézier (a raw `curve`, or a
+ * named easing turned into one as rigc turns it, AUTHORING §4.1) is split at
+ * `T` by de Casteljau, so the part kept is the same curve.
+ */
+function cutAt(a: RigcKey, b: RigcKey, T: number, easings: Readonly<Record<string, readonly number[]>>): { v: number[] } | { reason: string } {
+  const va = a.v as number[];
+  const vb = b.v as number[];
+  if (a.ease === 'stepped') return { v: [...va] };
+  let curve: number[] | null = null;
+  if (Array.isArray(a.curve)) curve = a.curve;
+  else if (typeof a.ease === 'string') {
+    const h = easings[a.ease];
+    if (h === undefined || h.length !== 4) return { reason: `its easing "${a.ease}" is not in the motion spec's easings` };
+    curve = va.flatMap((v0, c) => [a.t + (b.t - a.t) * h[0]!, v0 + (vb[c]! - v0) * h[1]!, a.t + (b.t - a.t) * h[2]!, v0 + (vb[c]! - v0) * h[3]!]);
+  }
+  if (curve === null) return { v: va.map((v0, c) => r6(v0 + ((T - a.t) / (b.t - a.t)) * (vb[c]! - v0))) };
+  const kept: number[] = [];
+  const v: number[] = [];
+  va.forEach((v0, c) => {
+    const [x1, y1, x2, y2] = curve.slice(c * 4, c * 4 + 4) as [number, number, number, number];
+    const bez = (p0: number, p1: number, p2: number, p3: number, s: number) => {
+      const u = 1 - s;
+      return u * u * u * p0 + 3 * u * u * s * p1 + 3 * u * s * s * p2 + s * s * s * p3;
+    };
+    let lo = 0;
+    let hi = 1;
+    for (let i = 0; i < 60; i++) {
+      const mid = (lo + hi) / 2;
+      if (bez(a.t, x1, x2, b.t, mid) < T) lo = mid;
+      else hi = mid;
+    }
+    const s = (lo + hi) / 2;
+    const lerp = (p: number, q: number) => p + (q - p) * s;
+    const split = (p0: number, p1: number, p2: number, p3: number): [number, number, number] => {
+      const p01 = lerp(p0, p1);
+      const p12 = lerp(p1, p2);
+      const p23 = lerp(p2, p3);
+      const p012 = lerp(p01, p12);
+      return [p01, p012, lerp(p012, lerp(p12, p23))];
+    };
+    const xs = split(a.t, x1, x2, b.t);
+    const ys = split(v0, y1, y2, vb[c]!);
+    kept.push(r6(xs[0]), r6(ys[0]), r6(xs[1]), r6(ys[1]));
+    v.push(r6(ys[2]));
+  });
+  delete a.ease;
+  a.curve = kept;
+  return { v };
+}
+
+/** The setup value a key states for a bone's translate, scale, shear and rotate (`numbers` channels), or undefined. */
+export function boneIdentity(property: string, channels: number): number[] | undefined {
+  const v = BONE_IDENTITY[property];
+  return v === undefined ? undefined : Array.from({ length: channels }, () => v);
+}
+
+// --- the fragment ------------------------------------------------------------
+
+export const FRAGMENT_SPEC = 'rig-pose-tracks/1';
+
+/**
+ * A `rig-pose-tracks/1` fragment: `{ "spec": "rig-pose-tracks/1", "tracks": [ … ] }`,
+ * each a rigc-motion track at absolute times from the animation's start. The
+ * shape is read here (one target, a property, keys with a time); what a track
+ * means is rigc's gate's to judge.
+ */
+export function readFragment(doc: unknown, where: string): RigcTrack[] {
+  const p = new Problems();
+  if (!isObject(doc) || doc.spec !== FRAGMENT_SPEC || !Array.isArray(doc.tracks)) {
+    p.add('MERGE_SPEC', `${where}: "spec" is ${isObject(doc) ? typeName(doc.spec) : typeName(doc)} and "tracks" ${isObject(doc) ? typeName(doc.tracks) : '-'}; a fragment is { "spec": "${FRAGMENT_SPEC}", "tracks": [ <rigc-motion track> … ] }`);
+    p.throwIfAny();
+  }
+  const tracks = (doc as { tracks: unknown[] }).tracks;
+  if (tracks.length === 0) p.add('MERGE_SPEC', `${where}: "tracks" is empty; a fragment adds at least one track`);
+  tracks.forEach((tr, i) => {
+    const at = `${where} tracks[${i}]`;
+    if (!isObject(tr)) {
+      p.add('MERGE_SPEC', `${at} is ${typeName(tr)}; a track is an object`);
+      return;
+    }
+    const fields = TARGET_FIELDS.filter((f) => tr[f] !== undefined);
+    if (fields.length !== 1 || typeof tr[fields[0]!] !== 'string') p.add('MERGE_SPEC', `${at} names ${fields.length === 0 ? 'no target' : fields.map((f) => `"${f}" (${typeName(tr[f])})`).join(' and ')}; a track names exactly one of ${TARGET_FIELDS.join(', ')}, as a string`);
+    if (typeof tr.property !== 'string') p.add('MERGE_SPEC', `${at} "property" is ${typeName(tr.property)}; it is the timeline's name, a string`);
+    if (!Array.isArray(tr.keys) || tr.keys.length === 0) {
+      p.add('MERGE_SPEC', `${at} "keys" is ${typeName(tr.keys)}; it is a non-empty array of { "t": <seconds>, "v": … }`);
+      return;
+    }
+    tr.keys.forEach((k, j) => {
+      if (!isObject(k) || typeof k.t !== 'number' || !Number.isFinite(k.t)) p.add('MERGE_SPEC', `${at} keys[${j}] ${isObject(k) ? `"t" is ${typeName(k.t)}` : `is ${typeName(k)}`}; a key states its time "t" in seconds`);
+    });
+  });
+  p.throwIfAny();
+  return tracks as RigcTrack[];
+}
+
+/**
+ * A fragment against the new animation: a track posing a channel the animation
+ * (or an earlier fragment track) already keys is MERGE_CONFLICT, and a key
+ * before 0 or past the duration is MERGE_TIME — each named.
+ */
+export function mergeProblems(fragment: readonly RigcTrack[], where: string, animation: string, tracks: readonly RigcTrack[], duration: number, groups: Readonly<Record<string, readonly string[]>>): Problem[] {
+  const out: Problem[] = [];
+  const keyed = keyedBy(tracks, groups);
+  fragment.forEach((tr, i) => {
+    const label = trackLabel(tr, groups);
+    const hit = collisions(tr, keyed, groups);
+    if (hit.length > 0) out.push({ code: 'MERGE_CONFLICT', text: `${where} tracks[${i}] (${label}) — "${animation}" already keys it: ${hit.join(', ')}; a fragment adds a track where nothing keys that target and property, it never replaces one` });
+    for (const c of cellsOf(tr, groups)) if (!keyed.has(c)) keyed.set(c, `${where} tracks[${i}] (${label})`);
+    tr.keys.forEach((k, j) => {
+      if (k.t < 0 || k.t > duration) out.push({ code: 'MERGE_TIME', text: `${where} tracks[${i}] (${label}) keys[${j}] at t=${k.t}s is ${k.t < 0 ? 'before 0' : `past "${animation}"'s duration ${duration}s`}; a fragment's times are absolute, from the animation's start, within [0, ${duration}]` });
+    });
+  });
+  return out;
+}
+
+// --- lines ---------------------------------------------------------------
+
+const targetText = (t: Target, members: readonly string[] | null) => `${t.kind} "${t.name}"${members !== null && members.length > 0 ? ` (${members.join(', ')})` : ''}`;
+
+export function droppedLine(d: IdleDropped, animation: string, carry: boolean, duration: number): string {
+  const head = `${targetText(d.target, d.members)} ${d.property}: ${d.keys} key(s) over the idle's ${d.duration.toFixed(3)}s; "${animation}" does not key it`;
+  if (!carry) return `${head} — not carried (no --carry-idle)`;
+  if (d.carried !== null) return `${head} — carried: ${d.carried.keys} key(s), ${d.carried.cycles} cycle(s), cut at ${duration.toFixed(3)}s${d.carried.seams === null ? '' : `; ${d.carried.seams}`}`;
+  return `${head} — not carried: ${d.notCarried}`;
+}
+
+export function keptOutLine(k: IdleKeptOut): string {
+  return `${targetText(k.target, null)} ${k.property}: ${k.reason}, so the idle's track is not carried`;
+}

package/src/reduce.ts

@@ -0,0 +1,361 @@
+/**
+ * The dense keys thinned to few keys with curves, within a stated tolerance
+ * (rig-c/pose#32, `--reduce`): one key per pose frame on every mapped bone's
+ * `rotate` track and on the hip's `translate`, in; the keys a curve needs to
+ * stay within the tolerance on every frame, out.
+ *
+ * Pure: numbers in, keys out. The method was fixed on the issue before any
+ * measurement. Keys sit on the pose's own frame times; between two kept keys a
+ * span is linear when every frame inside is within the tolerance, else it
+ * carries one raw Bézier `curve` whose handle times sit at the span's thirds and
+ * whose handle values are a least-squares fit; a span still over the tolerance
+ * takes a key at its worst frame and both halves are fitted again.
+ *
+ * Top-down along the tree. A child's `rotate` key adds to the turn of the
+ * mapped bone above it, so the reduced above's error turns the child's world
+ * aim too. A bone is fitted against its dense key minus the error its above
+ * carries (`target = dense − e_above`), and its own residual against that
+ * target is its world error: errors do not pile up down a chain. A knot's value
+ * is the target's, not the dense key's.
+ *
+ * Every error is read after the numbers are rounded as written and evaluated as
+ * rig-c's poser evaluates them (`curveAt`): the curve is the poser's ten-piece
+ * polyline, not the cubic. The poser is the judge — run.ts measures the landing
+ * of the gated build against the dense targets with the tolerance added.
+ */
+import { f32 } from 'rig-c/compile';
+
+/** 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 {
+  t: number;
+  v: number[];
+  curve?: number[];
+}
+
+export interface ReduceBone {
+  bone: string;
+  /** The nearest mapped bone above it (whose rotate track it adds to), or null. Always one of the other bones given, or null. */
+  above: string | null;
+  /** The dense key value on every frame (degrees, unwrapped, already rounded to 0.001). */
+  dense: number[];
+  /** Frame indices that must keep a key regardless (the first and last always do). */
+  keep: ReadonlySet<number>;
+}
+export interface ReduceHip {
+  bone: string;
+  /** Dense translate key on every frame, parent-local units, rounded to 0.001. */
+  dense: Array<[number, number]>;
+  keep: ReadonlySet<number>;
+  /** The hip's parent world matrix [a, b, c, d] at setup (wx = a·lx + b·ly, wy = c·lx + d·ly); null when it has none (identity). The tolerance is a world distance. */
+  parent: [number, number, number, number] | null;
+  tolerance: number;
+}
+export interface ReduceRow {
+  bone: string;
+  kind: 'angle' | 'origin';
+  /** Dense key count. */
+  before: number;
+  /** Reduced key count. */
+  after: number;
+  /** The largest error over all frames: degrees of world aim for a bone, world units for the hip. */
+  worst: number;
+  /** The first frame where it is. */
+  frame: number;
+}
+export interface Reduced {
+  rotate: Map<string, ReducedKey[]>;
+  hip: ReducedKey[] | null;
+  /** The bones in the order given, then the hip. */
+  rows: ReduceRow[];
+}
+
+// ---------------------------------------------------------------------------
+// rig-c's evaluation
+// ---------------------------------------------------------------------------
+
+/** rig-c's `BEZIER_SIXTH` (node_modules/rig-c/src/core/animation.ts). */
+const BEZIER_SIXTH = 0.16666667;
+/** Pieces of the poser's polyline per Bézier segment — rig-c's `BEZIER_PIECES`. */
+export const REDUCE_PIECES = 10;
+
+/**
+ * Copied verbatim from rig-c `src/core/animation.ts` (`bezierPolyline`, not
+ * exported by `rig-c/core`): the nine interior points of one channel's Bézier
+ * segment, `[t1, v1, …, t9, v9]`, each float32, by forward differences. The
+ * poser is the judge; this copy only lets the fit see what it will see.
+ */
+export function bezierPolyline(t0: number, v0: number, cx1: number, cy1: number, cx2: number, cy2: number, t3: number, v3: number): number[] {
+  const walk = (p0: number, p1: number, p2: number, p3: number): number[] => {
+    const second = (p0 - 2 * p1 + p2) * 0.03;
+    const third = ((p1 - p2) * 3 - p0 + p3) * 0.006;
+    let first = (p1 - p0) * 0.3 + second + third * BEZIER_SIXTH;
+    let d2 = second * 2 + third;
+    let at = p0;
+    const out: number[] = [];
+    for (let i = 1; i < REDUCE_PIECES; i++) {
+      at += first;
+      first += d2;
+      d2 += third;
+      out.push(Math.fround(at));
+    }
+    return out;
+  };
+  const ts = walk(t0, cx1, cx2, t3);
+  const vs = walk(v0, cy1, cy2, v3);
+  const out: number[] = [];
+  for (let i = 0; i < ts.length; i++) out.push(ts[i]!, vs[i]!);
+  return out;
+}
+
+const F32 = new Float32Array(1);
+const F32_BITS = new Uint32Array(F32.buffer);
+
+/** A key time as the built model states it — rig-c's `keyTime`: its own float32 name, else the float32 at or below it, named. */
+function statedTime(t: number): number {
+  const named = f32(t);
+  if (named === t) return named;
+  let f = Math.fround(t);
+  if (f > t) {
+    F32[0] = f;
+    if (f > 0) F32_BITS[0]! -= 1;
+    else if (f < 0) F32_BITS[0]! += 1;
+    else F32_BITS[0] = 0x80000001;
+    f = F32[0]!;
+  }
+  return f32(f);
+}
+/** A key time as the poser compares it: the float32 of the stated time. */
+const storedTime = (t: number): number => Math.fround(statedTime(t));
+
+/**
+ * One channel of one segment, as the poser holds it: null for a linear
+ * segment, else the polyline `[t0, v0, …nine points…, t3, v3]`. The recurrence
+ * runs on the numbers the built model states (rig-c's `f32` of each, a key
+ * time by `keyTime`); the two ends are the keys as stored, float32.
+ */
+function segmentPoints(a: ReducedKey, b: ReducedKey, channel: number): number[] | null {
+  if (a.curve === undefined) return null;
+  const c = a.curve.slice(channel * 4, channel * 4 + 4).map(f32);
+  const ta = statedTime(a.t);
+  const tb = statedTime(b.t);
+  const va = f32(a.v[channel]!);
+  const vb = f32(b.v[channel]!);
+  const inner = bezierPolyline(ta, va, c[0]!, c[1]!, c[2]!, c[3]!, tb, vb);
+  return [Math.fround(ta), Math.fround(va), ...inner, Math.fround(tb), Math.fround(vb)];
+}
+
+/** `segmentPoints`' segment at `t` — rig-c's `channelAt` past the key search. */
+function pointsAt(a: ReducedKey, b: ReducedKey, channel: number, points: readonly number[] | null, t: number): number {
+  if (points === null) {
+    const ta = storedTime(a.t);
+    const va = Math.fround(a.v[channel]!);
+    return va + ((t - ta) / (storedTime(b.t) - ta)) * (Math.fround(b.v[channel]!) - va);
+  }
+  let i = 2;
+  while (i < points.length - 2 && points[i]! < t) i += 2;
+  const x0 = points[i - 2]!;
+  const y0 = points[i - 1]!;
+  return y0 + ((t - x0) / (points[i]! - x0)) * (points[i + 1]! - y0);
+}
+
+/** Channel `channel` of the segment from key `a` to key `b` (`a.curve` shapes it) at `t`, as rig-c's poser evaluates it. */
+export function curveAt(a: ReducedKey, b: ReducedKey, channel: number, t: number): number {
+  return pointsAt(a, b, channel, segmentPoints(a, b, channel), t);
+}
+
+/** Every channel of a whole track at each sample time: the key search (last key stored at or before `t`), then the segment. */
+function trackAt(keys: readonly ReducedKey[], samples: readonly number[], channels: number): number[][] {
+  const stored = keys.map((k) => storedTime(k.t));
+  const points = keys.map((k, j) => (j + 1 < keys.length ? Array.from({ length: channels }, (_, c) => segmentPoints(k, keys[j + 1]!, c)) : []));
+  let j = 0;
+  return samples.map((t) => {
+    while (j + 1 < keys.length && stored[j + 1]! <= t) j++;
+    const a = keys[j]!;
+    const b = keys[j + 1];
+    // Before the first key the track does not pose; the first key is on frame 0, stored at or below it.
+    if (b === undefined || t < stored[j]!) return a.v.map((v) => Math.fround(v));
+    return Array.from({ length: channels }, (_, c) => pointsAt(a, b, c, points[j]![c]!, t));
+  });
+}
+
+// ---------------------------------------------------------------------------
+// the fit
+// ---------------------------------------------------------------------------
+
+const r3 = (v: number): number => {
+  const r = Math.round(v * 1000) / 1000;
+  return Object.is(r, -0) ? 0 : r;
+};
+
+/** One track to reduce: its targets per frame (one array per frame, a value per channel) and how a frame's error is read. */
+interface Fit {
+  targets: readonly (readonly number[])[];
+  keep: ReadonlySet<number>;
+  tolerance: number;
+  /** The error at frame `i` of `values` against the target. */
+  error: (i: number, values: readonly number[]) => number;
+}
+
+/** The frame with the largest error over `frames` (the first, on a tie), or null when there is none. */
+function worstOf(frames: readonly number[], errorAt: (i: number) => number): { worst: number; frame: number } | null {
+  let best: { worst: number; frame: number } | null = null;
+  for (const i of frames) {
+    const e = errorAt(i);
+    if (best === null || e > best.worst) best = { worst: e, frame: i };
+  }
+  return best;
+}
+
+/** The least-squares handle values of one channel, or null when the normal equations are singular. */
+function solveHandles(a: ReducedKey, b: ReducedKey, channel: number, hx1: number, hx2: number, interior: readonly number[], samples: readonly number[], target: (i: number) => number): [number, number] | null {
+  const model = (cy1: number, cy2: number): number[] => {
+    const c = new Array<number>(a.v.length * 4).fill(0);
+    c.splice(channel * 4, 4, hx1, cy1, hx2, cy2);
+    const k: ReducedKey = { t: a.t, v: a.v, curve: c };
+    const points = segmentPoints(k, b, channel);
+    return interior.map((i) => pointsAt(k, b, channel, points, samples[i]!));
+  };
+  const f00 = model(0, 0);
+  const f10 = model(1, 0);
+  const f01 = model(0, 1);
+  let s11 = 0;
+  let s12 = 0;
+  let s22 = 0;
+  let r1 = 0;
+  let r2 = 0;
+  interior.forEach((i, j) => {
+    const g1 = f10[j]! - f00[j]!;
+    const g2 = f01[j]! - f00[j]!;
+    const r = target(i) - f00[j]!;
+    s11 += g1 * g1;
+    s12 += g1 * g2;
+    s22 += g2 * g2;
+    r1 += g1 * r;
+    r2 += g2 * r;
+  });
+  const det = s11 * s22 - s12 * s12;
+  if (!(s11 > 0 && s22 > 0) || !(det > 1e-12 * s11 * s22)) return null;
+  return [(r1 * s22 - r2 * s12) / det, (r2 * s11 - r1 * s12) / det];
+}
+
+/** A track's keys: the kept frames, then a knot at the worst frame of every span over the tolerance, until none is. */
+function fitTrack(times: readonly number[], samples: readonly number[], fit: Fit): ReducedKey[] {
+  const n = times.length;
+  const channels = fit.targets[0]!.length;
+  const keyOn = (i: number): ReducedKey => ({ t: times[i]!, v: fit.targets[i]!.map(r3) });
+  const knots = [...new Set([0, n - 1, ...fit.keep])].sort((x, y) => x - y);
+  const curves = new Map<number, number[]>();
+  const done: number[] = [];
+  const spans: Array<[number, number]> = [];
+  for (let j = knots.length - 1; j > 0; j--) spans.push([knots[j - 1]!, knots[j]!]);
+  done.push(...knots);
+  while (spans.length > 0) {
+    const [k0, k1] = spans.pop()!;
+    if (k1 - k0 <= 1) continue;
+    const a = keyOn(k0);
+    const b = keyOn(k1);
+    const interior = Array.from({ length: k1 - k0 - 1 }, (_, j) => k0 + 1 + j);
+    const errorWith = (k: ReducedKey) => {
+      const points = Array.from({ length: channels }, (_, c) => segmentPoints(k, b, c));
+      return worstOf(interior, (i) => fit.error(i, points.map((p, c) => pointsAt(k, b, c, p, samples[i]!))))!;
+    };
+    const linear = errorWith(a);
+    if (linear.worst <= fit.tolerance) continue;
+    let split = linear.frame;
+    const hx1 = times[k0]! + (times[k1]! - times[k0]!) / 3;
+    const hx2 = times[k0]! + (2 * (times[k1]! - times[k0]!)) / 3;
+    const handles = Array.from({ length: channels }, (_, c) => solveHandles(a, b, c, hx1, hx2, interior, samples, (i) => fit.targets[i]![c]!));
+    if (handles.every((h) => h !== null)) {
+      const curve = handles.flatMap(([cy1, cy2]) => [hx1, r3(cy1), hx2, r3(cy2)]);
+      const bent = errorWith({ ...a, curve });
+      if (bent.worst <= fit.tolerance) {
+        curves.set(k0, curve);
+        continue;
+      }
+      split = bent.frame;
+    }
+    done.push(split);
+    spans.push([split, k1], [k0, split]);
+  }
+  return [...new Set(done)].sort((x, y) => x - y).map((i) => {
+    const k = keyOn(i);
+    const curve = curves.get(i);
+    return curve === undefined ? k : { ...k, curve };
+  });
+}
+
+/** The frame indices `keep` names, each checked against the frame count. */
+function keptFrames(keep: ReadonlySet<number>, n: number, label: string): Set<number> {
+  for (const i of keep) {
+    if (!Number.isInteger(i) || i < 0 || i >= n) throw new Error(`reduce: ${label} keeps frame ${i}, outside the ${n} frame(s) 0–${n - 1}`);
+  }
+  return new Set(keep);
+}
+
+/**
+ * Every bone's rotate track (and the hip's translate) reduced within the
+ * tolerance, top-down along `above`; the rows say each track's key counts and
+ * its worst world error, measured on the reduced keys as the poser evaluates
+ * them.
+ */
+export function reduceKeys(times: readonly number[], bones: readonly ReduceBone[], tolerance: number, hip: ReduceHip | null): Reduced {
+  const n = times.length;
+  if (n === 0) throw new Error('reduce: no frames to reduce');
+  if (!(Number.isFinite(tolerance) && tolerance > 0)) throw new Error(`reduce: the tolerance is ${tolerance}°, not a positive number`);
+  if (hip !== null && !(Number.isFinite(hip.tolerance) && hip.tolerance > 0)) throw new Error(`reduce: the hip's tolerance is ${hip.tolerance} units, not a positive number`);
+  // The poser samples at the running sum of the frame steps (verify.ts `poseFrames`).
+  const samples: number[] = [times[0]!];
+  for (let i = 1; i < n; i++) samples.push(samples[i - 1]! + (times[i]! - times[i - 1]!));
+
+  const byName = new Map<string, ReduceBone>();
+  for (const b of bones) {
+    if (byName.has(b.bone)) throw new Error(`reduce: bone "${b.bone}" is given twice`);
+    if (b.dense.length !== n) throw new Error(`reduce: bone "${b.bone}" has ${b.dense.length} dense key(s) for ${n} frame(s)`);
+    byName.set(b.bone, b);
+  }
+  for (const b of bones) {
+    if (b.above !== null && !byName.has(b.above)) throw new Error(`reduce: bone "${b.bone}" adds to bone "${b.above}", which is not among the bones reduced`);
+  }
+
+  // Top-down: a bone once its above is done, in the order given otherwise.
+  const errors = new Map<string, number[]>();
+  const rotate = new Map<string, ReducedKey[]>();
+  const rowOf = new Map<string, ReduceRow>();
+  const pending = [...bones];
+  while (pending.length > 0) {
+    const at = pending.findIndex((b) => b.above === null || errors.has(b.above));
+    if (at < 0) throw new Error(`reduce: bones ${pending.map((b) => `"${b.bone}"`).join(', ')} each add to another of them — a loop, not a tree`);
+    const b = pending.splice(at, 1)[0]!;
+    const eAbove = b.above === null ? null : errors.get(b.above)!;
+    const targets = b.dense.map((d, i) => [eAbove === null ? d : d - eAbove[i]!]);
+    const keys = fitTrack(times, samples, {
+      targets,
+      keep: keptFrames(b.keep, n, `bone "${b.bone}"`),
+      tolerance,
+      error: (i, v) => Math.abs(v[0]! - targets[i]![0]!),
+    });
+    const e = trackAt(keys, samples, 1).map((v, i) => v[0]! - targets[i]![0]!);
+    errors.set(b.bone, e);
+    rotate.set(b.bone, keys);
+    const worst = worstOf(e.map((_, i) => i), (i) => Math.abs(e[i]!))!;
+    rowOf.set(b.bone, { bone: b.bone, kind: 'angle', before: n, after: keys.length, worst: worst.worst, frame: worst.frame });
+  }
+  const rows = bones.map((b) => rowOf.get(b.bone)!);
+  const ordered = new Map(bones.map((b) => [b.bone, rotate.get(b.bone)!]));
+
+  let hipKeys: ReducedKey[] | null = null;
+  if (hip !== null) {
+    if (hip.dense.length !== n) throw new Error(`reduce: hip "${hip.bone}" has ${hip.dense.length} dense key(s) for ${n} frame(s)`);
+    const [ma, mb, mc, md] = hip.parent ?? [1, 0, 0, 1];
+    const world = (i: number, v: readonly number[]): number => {
+      const dx = v[0]! - hip.dense[i]![0];
+      const dy = v[1]! - hip.dense[i]![1];
+      return Math.hypot(ma * dx + mb * dy, mc * dx + md * dy);
+    };
+    hipKeys = fitTrack(times, samples, { targets: hip.dense, keep: keptFrames(hip.keep, n, `hip "${hip.bone}"`), tolerance: hip.tolerance, error: world });
+    const at = trackAt(hipKeys, samples, 2);
+    const worst = worstOf(at.map((_, i) => i), (i) => world(i, at[i]!))!;
+    rows.push({ bone: hip.bone, kind: 'origin', before: n, after: hipKeys.length, worst: worst.worst, frame: worst.frame });
+  }
+  return { rotate: ordered, hip: hipKeys, rows };
+}

package/src/retarget.ts

@@ -173,6 +173,8 @@ export interface MotionKey {
   v: number[];
   /** `stepped`: the value holds until the next key (the offsets' translate keys). */
   ease?: 'stepped';
+  /** A raw Bézier to the next key: four absolute (time, value) numbers per channel (`--reduce`, #32). */
+  curve?: number[];
 }
 export interface MotionTrack {
   bone: string;

package/src/run.ts

@@ -7,14 +7,16 @@
 import { cpSync, existsSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
-import { readMap, resolveMap, type JointMap } from './map.ts';
+import { readMap, resolveMap, type JointMap, type Rest } from './map.ts';
 import { convertCoco17, personTrack, readPoseSequence } from './pose.ts';
-import { lineOf, Problems, Refusal, type Problem } from './problems.ts';
-import { bendLine, endOnLine, flipLine, holdLine, rangeLine, retarget, shortLine, turnLine, type RetargetOptions } from './retarget.ts';
+import { isObject, lineOf, parseJson, Problems, Refusal, type Problem } from './problems.ts';
+import { boneIdentity, droppedLine, keptOutLine, mergeProblems, readFragment, readIdle, targetOf, trackLabel, type IdleReading, type RigcTrack, type Target } from './idle.ts';
+import { bendLine, endOnLine, flipLine, holdLine, rangeLine, retarget, shortLine, turnLine, type MotionTrack, type RetargetOptions } from './retarget.ts';
 import { attachmentBones, baseMotionOf, buildInto, rigcVersion, folds, gate, readBuild, resolveRig, restOf, slotsOf } from './rigc.ts';
 import { artRangeLine, chainsMoving, switchLine, uncoveredFolds } from './switch.ts';
 import { landed, measureFeet, measureLanding, measurePosture, measureShear, poseFrames, postureLines } from './verify.ts';
 import { legsOf } from './legs.ts';
+import { reduceKeys, type ReduceBone, type Reduced } from './reduce.ts';
 import type { LegScale } from './legs.ts';
 
 export interface RetargetArgs extends RetargetOptions {
@@ -35,6 +37,16 @@ export interface RetargetArgs extends RetargetOptions {
   render?: string;
   /** Write the run's measurements as JSON here. */
   report?: 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). */
+  carryIdle?: boolean;
+  /** A rig-pose-tracks/1 fragment merged into the new animation. */
+  merge?: string;
+  /** Thin the mapped bones' rotate keys within this many degrees (#32). */
+  reduce?: number;
+  /** With reduce: thin the hip's translate keys within this many rig units. */
+  reduceHip?: number;
 }
 
 export interface RunResult {
@@ -52,8 +64,8 @@ export function runRetarget(a: RetargetArgs, log: (line: string) => void): RunRe
     throw new Refusal(problems);
   };
   const args = new Problems();
-  for (const [flag, path] of [['--map', a.map], ['--pose', a.pose]] as const) {
-    if (!existsSync(path)) args.add('ARG_PATH', `${flag} ${path} does not exist`);
+  for (const [flag, path] of [['--map', a.map], ['--pose', a.pose], ['--merge', a.merge]] as const) {
+    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) {
@@ -67,6 +79,11 @@ export function runRetarget(a: RetargetArgs, log: (line: string) => void): RunRe
   const base = baseMotionOf(input);
   const animations = base.animations as Record<string, unknown>;
   if (a.name in animations) refuse([{ code: 'MOTION_NAME_FREE', text: `the rig's motion spec already has an animation "${a.name}" (it has ${Object.keys(animations).join(', ')}); name this one with --name` }]);
+  const idleName = a.idle ?? 'idle';
+  if (!(idleName in animations) && (a.idle !== undefined || a.carryIdle === true)) {
+    refuse([{ code: 'IDLE_NAME', text: `${a.idle !== undefined ? `--idle "${idleName}"` : '--carry-idle reads the animation "idle", and'} the rig's motion spec ${input.motion === null ? '— there is none, so it has no animations' : `${input.motion} has no animation "${idleName}" (it has ${Object.keys(animations).join(', ') || 'none'})`}; name the rig's idle with --idle` }]);
+  }
+  const fragment = a.merge === undefined ? [] : readFragment(parseJson(readFileSync(a.merge, 'utf8'), a.merge, 'MERGE_JSON'), a.merge);
   const map = readMap(readFileSync(a.map, 'utf8'), a.map);
   const poseText = readFileSync(a.pose, 'utf8');
   const seq = a.coco ? convertCoco17(poseText, a.pose) : readPoseSequence(poseText, a.pose);
@@ -87,7 +104,7 @@ export function runRetarget(a: RetargetArgs, log: (line: string) => void): RunRe
     resolveMap(map, rest, a.map, slots);
 
     const r = retarget(rest, map, frames, times, a, slots);
-    say(`rig-pose retarget: ${seq.frames.length} frame(s), ${r.animation.duration.toFixed(3)}s, onto "${input.name}" as "${a.name}" — ${r.animation.tracks.length} track(s); min-score ${a.minScore}, smooth ${a.smooth}, flip ${a.flip === 'off' ? 'off' : `${a.flip}°`}, short ${a.short}, bends ${a.bends} (tolerance ${a.bendTolerance}°)${a.legScale !== undefined && a.legScale !== 'off' ? `, leg-scale ${a.legScale[0]}–${a.legScale[1]}` : ''}${a.plantFeet === true ? ', plant-feet' : ''}`);
+    say(`rig-pose retarget: ${seq.frames.length} frame(s), ${r.animation.duration.toFixed(3)}s, onto "${input.name}" as "${a.name}" — ${r.animation.tracks.length} track(s); min-score ${a.minScore}, smooth ${a.smooth}, flip ${a.flip === 'off' ? 'off' : `${a.flip}°`}, short ${a.short}, bends ${a.bends} (tolerance ${a.bendTolerance}°)${a.legScale !== undefined && a.legScale !== 'off' ? `, leg-scale ${a.legScale[0]}–${a.legScale[1]}` : ''}${a.plantFeet === true ? ', plant-feet' : ''}${a.carryIdle === true ? ', carry-idle' : ''}${a.merge !== undefined ? `, merge ${a.merge}` : ''}${a.reduce !== undefined ? `, reduce ${a.reduce}°${a.reduceHip !== undefined ? ` (hip ${a.reduceHip} units)` : ''}` : ''}`);
     say(`  RIGC   rig-c ${rigc.version} (${rigc.entry}) gates and poses this run`);
     if (r.scale !== null) say(`  SCALE  ${r.scale.factor.toFixed(5)} rig units per picture px (rig ${r.scale.rig.toFixed(2)} / pose median ${r.scale.pose.toFixed(2)})`);
     for (const h of r.holds) say(`  HOLD   ${holdLine(h, r.times)}`);
@@ -117,7 +134,56 @@ export function runRetarget(a: RetargetArgs, log: (line: string) => void): RunRe
       say(`  FEET   steps (the supporting ankle > 0.03 leg lengths a frame; re-planted after 2 frames < 0.01): ${f.steps.map((x) => `${x.side} ${span(x.frames)} → ${x.to === null ? 'the pose\'s travel' : `${x.to} supports`}, ${x.replant === null ? 'never re-planted' : `re-planted at ${x.replant}`}`).join('; ') || 'none'}`);
     }
 
-    const motion = { ...base, animations: { ...animations, [a.name]: r.animation } };
+    // --reduce (#32): the dense keys thinned top-down, before anything reads the tracks.
+    const reduced = a.reduce === undefined ? null : reduceTracks(r, map, rest, a.reduce, a.reduceHip);
+    if (reduced !== null) {
+      for (const row of reduced.rows) say(`  REDUCE ${row.kind === 'angle' ? 'bone' : 'hip'} "${row.bone}" ${row.kind === 'angle' ? 'rotate' : 'translate'}: ${row.before} → ${row.after} key(s); worst ${row.kind === 'angle' ? 'aim' : 'origin'} error ${row.worst.toPrecision(3)}${row.kind === 'angle' ? '°' : ' units'} at frame ${row.frame} (t=${r.times[row.frame]!.toFixed(3)}s)`);
+      const sum = (k: 'before' | 'after') => reduced.rows.filter((x) => x.kind === 'angle').reduce((t, x) => t + x[k], 0);
+      say(`  REDUCE rotate keys ${sum('before')} → ${sum('after')} (${(sum('before') / sum('after')).toFixed(2)}×) within ${a.reduce}°${a.reduceHip === undefined ? '; the hip stays dense (no --reduce-hip)' : ''}`);
+    }
+
+    // The idle against the new animation (#43 item 2): what it drops, and with --carry-idle, looped back in.
+    const groups = (isObject(base.groups) ? base.groups : {}) as Record<string, string[]>;
+    const easings = (isObject(base.easings) ? base.easings : {}) as Record<string, number[]>;
+    const own = r.animation.tracks as unknown as RigcTrack[];
+    const T = r.animation.duration;
+    let idle: IdleReading | null = null;
+    if (!(idleName in animations)) say(`  IDLE   ${input.motion === null ? 'the rig has no motion spec' : `the rig's motion spec has no animation "idle" (it has ${Object.keys(animations).join(', ') || 'none'})`}; no idle read (--idle names another)`);
+    else {
+      const setupOf = (t: Target, property: string, sample: unknown): unknown => {
+        if (t.kind === 'slot' && property === 'attachment') return slots.get(t.name)?.setup;
+        if ((t.kind === 'bone' || t.kind === 'group') && Array.isArray(sample)) return boneIdentity(property, sample.length);
+        return undefined;
+      };
+      const mapped = [...map.chains.flatMap((c) => c.bones), ...(map.translate === null ? [] : [map.translate.bone])];
+      const below = new Map<string, string[]>();
+      for (const m of new Set(mapped)) {
+        for (let b = rest.get(m)?.parent ?? null; b !== null; b = rest.get(b)?.parent ?? null) {
+          const list = below.get(b) ?? [];
+          if (!list.includes(m)) list.push(m);
+          below.set(b, list);
+        }
+      }
+      idle = readIdle(idleName, a.name, animations[idleName] as Record<string, unknown>, own, T, { groups, easings }, setupOf, a.carryIdle === true, (bone) => below.get(bone) ?? [], (bone) => {
+        const hip = map.translate?.bone;
+        if (hip === undefined) return null;
+        for (let b = rest.get(hip)?.parent ?? null; b !== null; b = rest.get(b)?.parent ?? null) if (b === bone) return hip;
+        return null;
+      });
+      say(`  IDLE   animation "${idleName}" (${idle.duration.toFixed(3)}s, ${idle.tracks} track(s)) against "${a.name}": ${idle.dropped.length} dropped (${a.carryIdle === true ? `${idle.carriedTracks.length} carried, looped to ${T.toFixed(3)}s` : 'not carried; --carry-idle loops them in'}), ${idle.keptOut.length} kept out`);
+      for (const d of idle.dropped) say(`  IDLE-DROPPED ${droppedLine(d, a.name, a.carryIdle === true, T)}`);
+      for (const k of idle.keptOut) say(`  IDLE-KEPT-OUT ${keptOutLine(k)}`);
+      for (const n of idle.notTracks) say(`  IDLE-KEPT-OUT "${idleName}"'s ${n} timeline(s): not a track; neither compared nor carried`);
+    }
+    const carried = idle?.carriedTracks ?? [];
+    if (fragment.length > 0) {
+      const problems = mergeProblems(fragment, a.merge!, a.name, [...own, ...carried], T, groups);
+      if (problems.length > 0) refuse(problems);
+      for (const tr of fragment) say(`  MERGE  ${a.merge}: ${trackLabel(tr, groups)}, ${tr.keys.length} key(s) at t=${tr.keys[0]!.t}${tr.keys.length > 1 ? `–${tr.keys[tr.keys.length - 1]!.t}` : ''}s`);
+    }
+    const added = [...carried, ...fragment];
+    const animation = added.length === 0 ? r.animation : { ...r.animation, tracks: [...own, ...added] };
+    const motion = { ...base, animations: { ...animations, [a.name]: animation } };
     const g1 = gate(input.rig, motion, join(scratch, 'with'), a.profile, a.images);
     if (!g1.green) {
       refuse([{ code: 'RIG_GATE', text: `rigc build --profile ${a.profile} is red with "${a.name}" in (exit ${g1.run.status}); nothing written` }, ...g1.fails.map((f) => ({ code: 'RIGC', text: f }))]);
@@ -126,15 +192,26 @@ export function runRetarget(a: RetargetArgs, log: (line: string) => void): RunRe
 
     const doc = readBuild(g1.build);
     const posed = poseFrames(doc, a.name, r.times);
-    const landings = measureLanding(doc, a.name, map, r, posed);
+    // A reduced track is held to the dense target plus its tolerance (#32).
+    const landings = measureLanding(doc, a.name, map, r, posed).map((l) => (l.kind === 'angle' && a.reduce !== undefined ? { ...l, tolerance: l.tolerance + a.reduce } : l.kind === 'origin' && a.reduceHip !== undefined ? { ...l, tolerance: l.tolerance + a.reduceHip } : l));
     const p = new Problems();
+    // A carried idle track on a bone above a mapped one moves it where the keys did not ask (the key formula holds unmapped bones at setup).
+    const carriedAbove = (bone: string): string => {
+      const above = new Set<string>();
+      for (let b = rest.get(bone)?.parent ?? null; b !== null; b = rest.get(b)?.parent ?? null) above.add(b);
+      const hits = carried.filter((tr) => {
+        const t = targetOf(tr);
+        return t !== null && (t.kind === 'bone' ? above.has(t.name) : t.kind === 'group' && (groups[t.name] ?? []).some((m) => above.has(m)));
+      });
+      return hits.length === 0 ? '' : `; --carry-idle carried ${hits.map((tr) => trackLabel(tr, groups)).join(', ')} onto bones above it`;
+    };
     for (const l of landings) {
       const unit = l.kind === 'angle' ? '°' : l.kind === 'scale' ? ' of its setup length' : ' units';
       const what = l.kind === 'angle' ? 'aim' : l.kind === 'scale' ? 'scale' : l.kind === 'foot' ? 'ankle' : 'origin';
       const tol = l.kind === 'foot' ? Number(l.tolerance.toPrecision(3)) : l.tolerance;
       const line = `bone "${l.bone}" ${what} — worst |reached − asked| ${l.worst.toPrecision(3)}${unit} at frame ${l.frame} (t=${r.times[l.frame]!.toFixed(3)}s); the tolerance is ${tol}${unit}`;
       if (landed(l)) say(`  LAND   ${line}`);
-      else p.add('POSE_LANDS', `${line} — the rig does not turn the way the key formula assumes (a constraint, a scaled or sheared parent, a non-normal inherit mode)`);
+      else p.add('POSE_LANDS', `${line} — the rig does not turn the way the key formula assumes (a constraint, a scaled or sheared parent, a non-normal inherit mode)${carriedAbove(l.bone)}`);
     }
     p.throwIfAny();
 
@@ -186,7 +263,7 @@ export function runRetarget(a: RetargetArgs, log: (line: string) => void): RunRe
         animation: a.name,
         frames: seq.frames.length,
         duration: r.animation.duration,
-        options: { minScore: a.minScore, smooth: a.smooth, flip: a.flip, short: a.short, bends: a.bends, bendTolerance: a.bendTolerance, switchTolerance: a.switchTolerance, switchMin: a.switchMin, switchAt: a.switchAt, profile: a.profile, legScale: a.legScale ?? 'off', plantFeet: a.plantFeet === true },
+        options: { minScore: a.minScore, smooth: a.smooth, flip: a.flip, short: a.short, bends: a.bends, bendTolerance: a.bendTolerance, switchTolerance: a.switchTolerance, switchMin: a.switchMin, switchAt: a.switchAt, profile: a.profile, legScale: a.legScale ?? 'off', plantFeet: a.plantFeet === true, idle: idleName, carryIdle: a.carryIdle === true, merge: a.merge ?? null, reduce: a.reduce ?? 'off', reduceHip: a.reduceHip ?? 'off' },
         scale: r.scale,
         holds: r.holds,
         short: r.short,
@@ -206,6 +283,10 @@ export function runRetarget(a: RetargetArgs, log: (line: string) => void): RunRe
         pivot: r.pivot,
         feet: r.feet === null ? null : { planted: r.planted, legLength: r.feet.legLength, supports: r.feet.supports, jumps: r.feet.jumps, steps: r.feet.steps, changes: r.feet.changes, reading: feetReading },
         shear,
+        idleDropped: idle === null ? null : idle.dropped,
+        idleKeptOut: idle === null ? null : idle.keptOut,
+        merged: fragment.map((tr) => ({ track: trackLabel(tr, groups), keys: tr.keys.length })),
+        reduce: reduced === null ? null : { tolerance: a.reduce, hipTolerance: a.reduceHip ?? null, rows: reduced.rows },
       }, null, 2)}\n`);
     }
     say(`  wrote ${a.out} — animations: ${Object.keys(motion.animations).join(', ')}`);
@@ -215,6 +296,47 @@ export function runRetarget(a: RetargetArgs, log: (line: string) => void): RunRe
   }
 }
 
+/**
+ * The retarget's rotate tracks (and with a hip tolerance, its translate) thinned
+ * in place (#32). Kept regardless, per bone: the frames either side of each
+ * switch boundary on the chains it changes, and the edges of every FLIP spread,
+ * SHORT span and RANGE run on it (the first and last frame the reducer keeps).
+ */
+function reduceTracks(r: ReturnType<typeof retarget>, map: JointMap, rest: Rest, tolerance: number, hipTolerance: number | undefined): Reduced {
+  const n = r.times.length;
+  const keep = new Map<string, Set<number>>();
+  const add = (bone: string, ...frames: number[]) => {
+    const s = keep.get(bone) ?? new Set<number>();
+    for (const f of frames) if (f >= 0 && f < n) s.add(f);
+    keep.set(bone, s);
+  };
+  for (const sw of r.switches) {
+    for (const c of map.chains.filter((x) => sw.chains.includes(x.name))) for (const b of c.bones) add(b, sw.frames[0] - 1, sw.frames[0], sw.frames[1], sw.frames[1] + 1);
+  }
+  for (const x of [...r.flips, ...r.short, ...r.range]) add(x.bone, x.frames[0], x.frames[1]);
+  const mapped = new Set(r.targets.keys());
+  const above = (b: string): string | null => {
+    for (let p = rest.get(b)!.parent; p !== null; p = rest.get(p)!.parent) if (mapped.has(p)) return p;
+    return null;
+  };
+  const rotate = new Map<string, MotionTrack>();
+  for (const tr of r.animation.tracks) if ('bone' in tr && tr.property === 'rotate') rotate.set(tr.bone, tr);
+  const bones: ReduceBone[] = [...rotate.values()].map((tr) => ({ bone: tr.bone, above: above(tr.bone), dense: tr.keys.map((k) => k.v[0]!), keep: keep.get(tr.bone) ?? new Set<number>() }));
+  const hipTrack = r.origin === null || hipTolerance === undefined ? undefined : r.animation.tracks.find((tr): tr is MotionTrack => 'bone' in tr && tr.property === 'translate' && tr.bone === r.origin!.bone && tr.keys.every((k) => k.ease === undefined));
+  const parent = hipTrack === undefined ? null : rest.get(hipTrack.bone)!.parent;
+  const pm = parent === null ? null : rest.get(parent)!;
+  const out = reduceKeys(r.times, bones, tolerance, hipTrack === undefined ? null : {
+    bone: hipTrack.bone,
+    dense: hipTrack.keys.map((k) => [k.v[0]!, k.v[1]!]),
+    keep: new Set<number>(),
+    parent: pm === null ? null : [pm.a, pm.b, pm.c, pm.d],
+    tolerance: hipTolerance!,
+  });
+  for (const [bone, keys] of out.rotate) rotate.get(bone)!.keys = keys;
+  if (hipTrack !== undefined && out.hip !== null) hipTrack.keys = out.hip;
+  return out;
+}
+
 function spans(ts: number[], step: number): string {
   const out: string[] = [];
   let s = ts[0]!;