@rig-c/pose 0.39.0 → 0.40.0

package/src/reduce.ts

@@ -48,6 +48,8 @@ export interface ReduceBone {
   dense: number[];
   /** Frame indices that must keep a key regardless (the first and last always do). */
   keep: ReadonlySet<number>;
+  /** Its own world-aim tolerance in degrees, in place of the call's (rig-c/pose#283: its chain's). */
+  tolerance?: number;
 }
 export interface ReduceHip {
   bone: string;
@@ -328,6 +330,7 @@ export function reduceKeys(times: readonly number[], bones: readonly ReduceBone[
   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.tolerance !== undefined && !(Number.isFinite(b.tolerance) && b.tolerance > 0)) throw new Error(`reduce: bone "${b.bone}"'s tolerance is ${b.tolerance}°, not a positive number`);
     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);
   }
@@ -349,7 +352,7 @@ export function reduceKeys(times: readonly number[], bones: readonly ReduceBone[
     const keys = fitTrack(times, samples, {
       targets,
       keep: keptFrames(b.keep, n, `bone "${b.bone}"`),
-      tolerance,
+      tolerance: b.tolerance ?? 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]!);
@@ -617,11 +620,12 @@ export function smoothTrunk(
   if (n < 4 || trunkBones.size === 0) return;
   const samples = samplesOf(times);
   const byName = new Map(bones.map((b) => [b.bone, b]));
+  /** rig-c/pose#283: a bone's own tolerance (its chain's under a per-chain --reduce), else the call's. */
+  const tolOf = (b: string): number => byName.get(b)?.tolerance ?? tolerance;
   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);
@@ -646,8 +650,10 @@ export function smoothTrunk(
     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);
+    // #283: each bone's own tolerance (its chain's under a per-chain --reduce; the call's otherwise).
+    const rootInner = 0.985 * tolOf(root);
+    const rootLb = targetRoot.map((t) => t - rootInner);
+    const rootUb = targetRoot.map((t) => t + rootInner);
     let smRoot = optimizeBasis(basisOf.get(root)!, rootLb, rootUb);
     let eRoot = smRoot.y.map((v, i) => v - targetRoot[i]!);
 
@@ -667,14 +673,15 @@ export function smoothTrunk(
       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));
+        const hInner = 0.985 * tolOf(h);
+        const smH = optimizeBasis(basisOf.get(h)!, targetH.map((t) => t - hInner), targetH.map((t) => t + hInner));
         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 cap = Math.min(0.98 * tolOf(b0), wOld + 0.035 * tolOf(b0));
         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);
@@ -685,7 +692,7 @@ export function smoothTrunk(
         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 cap = Math.min(0.98 * tolOf(b1), wOld + 0.035 * tolOf(b1));
         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);
@@ -699,17 +706,17 @@ export function smoothTrunk(
       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);
+          if (Math.abs(eh) > 0.99 * tolOf(h)) {
+            tightenAround(i, Math.abs(eh) - 0.975 * tolOf(h));
             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 cap = Math.min(0.985 * tolOf(b), wOld + 0.04 * tolOf(b));
           const eb = eSub.get(b)![i]!;
           if (Math.abs(eb) > cap) {
-            tightenAround(i, Math.abs(eb) - (cap - 0.01 * tolerance));
+            tightenAround(i, Math.abs(eb) - (cap - 0.01 * tolOf(b)));
             anyTightened = true;
           }
         }
@@ -827,6 +834,8 @@ export interface UnderBone {
   /** The dense rotate keys (unwrapped, as written). */
   dense: readonly number[];
   keep: ReadonlySet<number>;
+  /** Its own world-aim tolerance in degrees, in place of the call's (rig-c/pose#283). */
+  tolerance?: number;
 }
 
 /**
@@ -879,7 +888,7 @@ export function reduceUnderScale(times: readonly number[], bones: readonly Under
       return Math.abs(wrap180(Math.atan2(w[1], w[0]) * DEG - b.target[i]!));
     };
     const keep = keptFrames(b.keep, n, `bone "${b.bone}"`);
-    const rk = fitTrack(times, samples, { targets: solved.map((k) => [k]), keep, tolerance, error: (i, v) => aimError(i, v[0]!) });
+    const rk = fitTrack(times, samples, { targets: solved.map((k) => [k]), keep, tolerance: b.tolerance ?? tolerance, error: (i, v) => aimError(i, v[0]!) });
     const kAt = trackAt(rk, samples, 1).map((v) => v[0]!);
     const ae = worstOf(kAt.map((_, i) => i), (i) => aimError(i, kAt[i]!))!;
     rows.push({ bone: b.bone, kind: 'angle', before: n, after: rk.length, worst: ae.worst, frame: ae.frame });

package/src/retarget.ts

@@ -79,7 +79,7 @@ import { aimAngle, aimEnds, bodyYawSets, descends, faceYawSets, knownSetsOf, par
 import type { Joint, Travel } from './pose.ts';
 import { TRAVEL_IN_PLACE } from './pose.ts';
 import { Problems, Refusal } from './problems.ts';
-import type { ArtRange, AttachmentKey, ByHip, Raised, ReachShort, SlotTrack, Switch, SwitchOptions } from './switch.ts';
+import type { ArtRange, AttachmentKey, ByHip, Raised, ReachShort, SetRuns, SlotTrack, Switch, SwitchOptions } from './switch.ts';
 import { clampArt, coveredChains, isRaised, measureArt, overflow, phaseGroupProblems, RAISED_WRIST_EYES, RANGE_SLACK, reachLimit, runsOf, selectSwitches, twoBone } from './switch.ts';
 import type { BlendHold, Closure, Feet, Floor, LegScale, LegSegmentRatio, PathPose, Posing, Side, Stance } from './legs.ts';
 import { figureScaleOf, freeAnkleShiftOf, holdBlend, isLegSegment, legScaleOf, legsOf, pathFrom, percentile, plantHip, posePath, rootOf, scaleSupport, shiftOver, SIDES, stanceOf, stanceRangeOf, STRAIGHT_PERCENTILE, supportsOf, tipOf, unshortenStanceShin } from './legs.ts';
@@ -369,6 +369,34 @@ export interface ReachReading {
   ratio: number | null;
 }
 
+/**
+ * rig-c/pose#282: where a `reach` chain's bone starts against the source joint
+ * it re-aims from. The pose's pair starts at the translated joint, which the
+ * rig puts at the translated bone's posed origin; the reach aims from its own
+ * bone's posed origin. The distance between the two, at setup and on the
+ * frames, is the lever #236 names — a reading, with a WARN past
+ * `REACH_ORIGIN_WARN` of the segment. One per reach chain, in map order.
+ */
+export interface ReachOrigin {
+  chain: string;
+  bone: string;
+  /** The pair: the chain's first joint (the translated joint) and its second. */
+  joints: [string, string];
+  /** The translated bone, whose posed origin is where the rig puts the source joint. */
+  anchor: string;
+  /** The distance at setup, world units. */
+  setup: number;
+  /** The largest distance as posed on the frames, world units, and its frame. */
+  posed: { max: number; frame: number };
+  /** The reached length: the pair's median picture length, scaled (world units). */
+  segment: number;
+  /** max(setup, posed.max) ÷ segment. */
+  ofSegment: number;
+  /** ofSegment > threshold. */
+  warn: boolean;
+  threshold: number;
+}
+
 /**
  * Mean |second difference| of a series of angles, degrees: |wrap(v[i+1] − v[i])
  * − wrap(v[i] − v[i−1])| over every i whose three frames `ok` admits (every
@@ -419,6 +447,8 @@ export interface Retarget {
   scaleFit: ScaleFit | null;
   /** The spans each alternate set shows, with their art turn. */
   switches: Switch[];
+  /** rig-c/pose#279: per set without a `phase`, the runs it was nearest on and the runs the minimum span suppressed. */
+  switchRuns: SetRuns[];
   /** Per switched or hidden slot, what it shows on each frame (null: nothing). */
   shown: Map<string, Array<string | null>>;
   /** Per set, its distance to the pose on each frame, degrees. */
@@ -475,6 +505,8 @@ export interface Retarget {
   nodSkipped: NodSkipped | null;
   /** Each `reach` chain hanging below a bone the animation turns or translates (#236): its aim's departure from the pose pair's angle. */
   reach: ReachReading[];
+  /** rig-c/pose#282: each `reach` chain's origin against the source joint it re-aims from; empty when the map has none. */
+  reachOrigin: ReachOrigin[];
   /** rig-c/pose#288: the pelvis bone's source; null when the map has no pelvis chain and the sequence no track. */
   pelvis: PelvisReading | null;
 }
@@ -1486,6 +1518,8 @@ export function retarget(rest: Rest, map: JointMap, frames: ReadonlyArray<Partia
   const reaches = map.chains.filter((c) => c.reach).sort((x, y) => depth(x.bones[0]!) - depth(y.bones[0]!));
   let aimReach: ((c: Chain) => void) | null = null;
   const reachAims = new Map<string, { aim: number[]; pair: number[]; length: number }>();
+  /** #282: per reach chain, the distance from its bone's posed origin to the anchor's on each frame (the last aim's). */
+  const reachGaps = new Map<string, number[]>();
   if (reaches.length > 0 && t !== null && scale !== null) {
     const s = scale.factor;
     const tb = rest.get(t.bone)!;
@@ -1494,8 +1528,10 @@ export function retarget(rest: Rest, map: JointMap, frames: ReadonlyArray<Partia
       const anchor = series.get(c.joints[0]!)!;
       const end = series.get(c.joints[1]!)!;
       const angles: number[] = [];
+      const gaps: number[] = [];
       for (let i = 0; i < n; i++) {
         const o = posedOrigin(b, i);
+        gaps.push(Math.hypot(o[0] - (tb.worldX + travel[i]![0]), o[1] - (tb.worldY + travel[i]![1])));
         const tx = tb.worldX + travel[i]![0] + (end[i]![0] - anchor[i]![0]) * s;
         const ty = tb.worldY + travel[i]![1] - (end[i]![1] - anchor[i]![1]) * s;
         const d = Math.hypot(tx - o[0], ty - o[1]);
@@ -1503,6 +1539,7 @@ export function retarget(rest: Rest, map: JointMap, frames: ReadonlyArray<Partia
       }
       fillLeading(angles, () => p.add('POSE_SEGMENT_ZERO', `chain "${c.name}" — bone "${b}" reaches for ${c.joints[1]}, which the pose puts on the bone's posed origin on every frame; it has no direction`));
       targets.set(b, angles);
+      reachGaps.set(c.name, gaps);
       // #236: the aim as reached, before its own range clamp, beside the pair's own angle (a reading).
       reachAims.set(c.name, { aim: [...angles], pair: Array.from({ length: n }, (_, i) => pictureAngle(anchor[i]!, end[i]!)), length: median(Array.from({ length: n }, (_, i) => Math.hypot(end[i]![0] - anchor[i]![0], end[i]![1] - anchor[i]![1]) * s)) });
     };
@@ -3087,6 +3124,7 @@ export function retarget(rest: Rest, map: JointMap, frames: ReadonlyArray<Partia
   if (headNodTrack !== null) tracks.push(headNodTrack);
   tracks.push(...sw.offsetTracks, ...sw.slotTracks);
   const reach = reachReadings(rest, map, tracks, reachAims, t?.bone ?? null);
+  const reachOrigin = reachOrigins(rest, map, reachAims, reachGaps, t?.bone ?? null);
 
   const pivot = pivotOf(rest, t?.bone ?? null, legs);
   const pelvis = pelvisReadingOf(pelvisChain, opts.pelvis, track, fromTrack, tracks);
@@ -3099,8 +3137,8 @@ export function retarget(rest: Rest, map: JointMap, frames: ReadonlyArray<Partia
   return {
     animation: { duration: keyTimes[n - 1]!, tracks },
     times: keyTimes, targets, origin, holds, bends, short, endOn, flips, scale, scaleFit,
-    switches: sw.switches, shown: sw.shown, distances: sw.distances, turns, turnsUnread, range, artRange,
-    legScale, segments, legStraight, rigLeg, scales, feet, planted: plantOn, stance, floor, blendHold, closure, openDrift, ankles, pivot, raised, byHip, face, body, figureScale, headNod: headNodReading, nodSkipped, reach, pelvis,
+    switches: sw.switches, switchRuns: sw.runs, shown: sw.shown, distances: sw.distances, turns, turnsUnread, range, artRange,
+    legScale, segments, legStraight, rigLeg, scales, feet, planted: plantOn, stance, floor, blendHold, closure, openDrift, ankles, pivot, raised, byHip, face, body, figureScale, headNod: headNodReading, nodSkipped, reach, reachOrigin, pelvis,
   };
 }
 
@@ -3209,6 +3247,47 @@ function reachReadings(rest: Rest, map: JointMap, tracks: ReadonlyArray<MotionTr
   return out;
 }
 
+/**
+ * #282: a reach bone whose origin sits more than this fraction of the segment
+ * from the source joint is warned. The aim from an origin a fraction f up the
+ * pair turns about 1 ÷ (1 − f) times the pair's turn (#236's lever: the example
+ * wave's trunk, f = 0.5, measured 2.00×); 0.2 is 1.25×, a quarter more turn
+ * than the pose has.
+ */
+export const REACH_ORIGIN_WARN = 0.2;
+
+/** #282: each reach chain's origin against the anchor's, at setup and as posed, in map order. */
+function reachOrigins(rest: Rest, map: JointMap, aims: ReadonlyMap<string, { length: number }>, gaps: ReadonlyMap<string, number[]>, anchor: string | null): ReachOrigin[] {
+  const out: ReachOrigin[] = [];
+  if (anchor === null) return out;
+  const a0 = rest.get(anchor)!;
+  for (const c of map.chains) {
+    const got = aims.get(c.name);
+    const g = gaps.get(c.name);
+    if (!c.reach || got === undefined || g === undefined) continue;
+    const b = c.bones[0]!;
+    const bo = rest.get(b)!;
+    const setup = r3(Math.hypot(bo.worldX - a0.worldX, bo.worldY - a0.worldY));
+    let frame = 0;
+    for (let i = 1; i < g.length; i++) if (g[i]! > g[frame]!) frame = i;
+    const max = r3(g[frame] ?? 0);
+    const segment = r3(got.length);
+    const ofSegment = got.length > 0 ? r3(Math.max(setup, max) / got.length) : 0;
+    out.push({ chain: c.name, bone: b, joints: [c.joints[0]!, c.joints[1]!], anchor, setup, posed: { max, frame }, segment, ofSegment, warn: ofSegment > REACH_ORIGIN_WARN, threshold: REACH_ORIGIN_WARN });
+  }
+  return out;
+}
+
+/** #282: the `REACH-ORIGIN` line, one per reach chain. */
+export function reachOriginLine(e: ReachOrigin, times: readonly number[]): string {
+  return `chain "${e.chain}" bone "${e.bone}" (${e.joints[0]} → ${e.joints[1]}): its origin ${e.setup.toFixed(2)} units from the source joint ${e.joints[0]} (bone "${e.anchor}"'s origin) at setup, up to ${e.posed.max.toFixed(2)} on the frames (frame ${e.posed.frame}, t=${times[e.posed.frame]!.toFixed(3)}s): ${e.ofSegment.toFixed(3)} of the ${e.segment.toFixed(2)}-unit segment`;
+}
+
+/** #282: the WARN of a reach chain whose origin sits past REACH_ORIGIN_WARN of the segment. */
+export function reachOriginWarn(e: ReachOrigin): string {
+  return `REACH_ORIGIN: chain "${e.chain}" bone "${e.bone}" starts ${e.ofSegment.toFixed(3)} of the segment from ${e.joints[0]}, past ${e.threshold.toFixed(2)}: re-aimed from there, it turns more than the pair (JITTER bone "${e.bone}"); "reach": false follows the measured angle`;
+}
+
 /** The `REACH` line of a reach chain whose aim departs from its pair (#236). */
 export function reachCostLine(e: ReachReading, times: readonly number[]): string {
   const f = (v: number | null) => (v === null ? 'not measured' : `${v.toFixed(4)}°/f²`);

package/src/run.ts

@@ -11,13 +11,14 @@ import { dirname, join, relative, resolve } from 'node:path';
 import { knownSetsOf, readMap, resolveMap, type JointMap, type Rest } from './map.ts';
 import { cleanLine, cleanSummaryLine, inferredSource } from './clean.ts';
 import { depthLine, layersOf, type FrameLayers } from './depth.ts';
+import { drawOrderFromDepth, drawOrderKeys, drawOrderLines, type DrawOrderReading } from './draworder.ts';
 import { convertCoco17, personTrack, readPoseSequence, TRAVEL_IN_PLACE, type CameraFrame } from './pose.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 { bendGroupLine, bendGroups, bendLine, endOnLine, flipLine, holdLine, nodLine, pelvisLine, rangeLine, reachCostLine, retarget, shortLine, turnLine, type MotionTrack, type RetargetOptions, type ScaleBand, type ScaleFit } from './retarget.ts';
+import { bendGroupLine, bendGroups, bendLine, endOnLine, flipLine, holdLine, nodLine, pelvisLine, rangeLine, reachCostLine, reachOriginLine, reachOriginWarn, retarget, shortLine, turnLine, type MotionTrack, type RetargetOptions, type ScaleBand, type ScaleFit } from './retarget.ts';
 import { attachmentBones, baseMotionOf, buildInto, rigcVersion, folds, gate, readBuild, resolveRig, restOf, seamRender, slotsOf } from './rigc.ts';
 import { partsPath, projectSeams, readSeamDoc, readSeamPairs, seamLines, type SeamPair } from './seams.ts';
-import { artRangeLine, chainsMoving, phaseLines, raisedLine, RAISED_WITHIN, reachLine, switchLine, uncoveredFolds } from './switch.ts';
+import { artRangeLine, chainsMoving, phaseLines, raisedLine, RAISED_WITHIN, reachLine, switchLine, switchMinLines, uncoveredFolds } from './switch.ts';
 import { jitterLine, landed, type FeetReading, type JitterRow, type Landing, measureFeet, measureJitter, measureLanding, measurePosture, measureShear, poseFrames, postureLines } from './verify.ts';
 import { FRONTAL_DISAGREE, legsOf, PLANT_SWITCH, STANCE_BOUNDS } from './legs.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';
@@ -64,6 +65,8 @@ export interface RetargetArgs extends RetargetOptions {
   merge?: string;
   /** Thin the mapped bones' rotate keys within this many degrees (#32). */
   reduce?: number;
+  /** With reduce: a map chain's own tolerance in degrees, by chain name, in place of `reduce` on its bones (#283). */
+  reduceChains?: Record<string, number>;
   /** With reduce: thin the hip's translate keys within this many rig units. */
   reduceHip?: number;
   /** With reduce and plantFeet: keep each support span's frames on the supporting leg at its dense keys (#251). */
@@ -76,6 +79,8 @@ export interface RetargetArgs extends RetargetOptions {
    * same in all three and the gate is the same gate.
    */
   output?: 'default' | 'verbose' | 'summary';
+  /** `--draw-order depth` (rig-c/pose#304): key the animation's draw order from the sequence's depth. Absent: no draw-order key, the output as before. */
+  drawOrder?: 'depth';
 }
 
 export interface RunResult {
@@ -128,9 +133,13 @@ export function runRetarget(a: RetargetArgs, log: (line: string) => void): RunRe
   const fragment = a.merge === undefined ? [] : readFragment(parseJson(readFileSync(a.merge, 'utf8'), a.merge, 'MERGE_JSON'), a.merge);
   const mapSnapshot = readReportInput(a.map), poseSnapshot = readReportInput(a.pose);
   const map = readMap(mapSnapshot.bytes.toString('utf8'), a.map);
+  // #283: each chain --reduce names must be the map's; a bone takes its chain's tolerance (the tighter, if two chains name it).
+  const reduceOf = a.reduce === undefined ? null : reduceTolerances(map, a.reduce, a.reduceChains, a.map);
   const poseText = poseSnapshot.bytes.toString('utf8');
   const seq = a.coco ? convertCoco17(poseText, a.pose) : readPoseSequence(poseText, a.pose);
   if (seq.cleaned === undefined) refuse([{ code: 'POSE_NOT_CLEANED', text: notCleaned(a.pose, a.coco) }]);
+  // #304: the draw order is read off the sequence's depth; asked for on a sequence without it, refused by name.
+  if (a.drawOrder === 'depth' && !seq.frames.some((x) => x.depth !== undefined)) refuse([{ code: 'DRAWORDER_NO_DEPTH', text: `--draw-order depth keys the draw order from the sequence's depth, and ${a.pose} carries none (rig-pose-sequence/${seq.cleaned!.params.depth === undefined ? '1 or 1.1, no "depth" on any frame' : '1.2 with no frame naming a segment'}); clean it with --depth walk|run, or retarget without --draw-order` }]);
   const frames = personTrack(seq, a.person, a.pose);
   const times = seq.frames.map((f) => f.t);
 
@@ -164,7 +173,7 @@ export function runRetarget(a: RetargetArgs, log: (line: string) => void): RunRe
         }
       }
     }
-    tell(`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}, 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.stance !== undefined && a.stance !== 'off' ? `, stance ${a.stance}` : ''}${a.raisedByHead === true ? ', raised-by-head' : ''}${a.carryIdle === true ? ', carry-idle' : ''}${a.merge !== undefined ? `, merge ${a.merge}` : ''}${a.reduce !== undefined ? `, reduce ${a.reduce}°${a.reduceHip !== undefined ? ` (hip ${a.reduceHip} units)` : ''}${a.reduceKeepPlanted === true ? ', planted legs kept dense' : ''}` : ''}`);
+    tell(`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}, 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.stance !== undefined && a.stance !== 'off' ? `, stance ${a.stance}` : ''}${a.raisedByHead === true ? ', raised-by-head' : ''}${a.carryIdle === true ? ', carry-idle' : ''}${a.merge !== undefined ? `, merge ${a.merge}` : ''}${a.reduce !== undefined ? `, reduce ${a.reduce}°${chainsText(a.reduceChains)}${a.reduceHip !== undefined ? ` (hip ${a.reduceHip} units)` : ''}${a.reduceKeepPlanted === true ? ', planted legs kept dense' : ''}` : ''}`);
     say(`  RIGC   rig-c ${rigc.version} (${rigc.entry}) gates and poses this run`);
     // #250: the gate was green without it, so nothing else would say the rig's own animations are not in --out.
     const unread = unreadMotionLine(a.rig, input.motion);
@@ -191,6 +200,8 @@ export function runRetarget(a: RetargetArgs, log: (line: string) => void): RunRe
     if (map.alternates.length > 0) {
       if (r.switches.length === 0) say(`  SWITCH none — no set within ${a.switchTolerance}° of the pose for ${a.switchMin}s`);
       for (const s of r.switches) say(`  SWITCH ${switchLine(s, r.times)}`);
+      // #279: only for a set the minimum span held back, so a run where nothing was suppressed prints what it always has.
+      for (const l of switchMinLines(r.switchRuns, a.switchMin)) say(`  SWITCH-MIN ${l}`);
       for (const l of windowLines(map, r.switches, r.distances, r.times, a.switchTolerance)) say(`  FRAMES ${l}`);
       for (const l of phaseLines(map, r.switches)) say(`  PHASE  ${l}`);
     }
@@ -202,6 +213,11 @@ export function runRetarget(a: RetargetArgs, log: (line: string) => void): RunRe
     for (const e of r.byHip) say(`  BY-HIP ${raisedLine(e, r.times)}`);
     for (const e of r.byHip) if (e.short.length > 0) say(`  REACH  ${reachLine(e, r.times)}`);
     for (const e of r.reach) say(`  REACH  ${reachCostLine(e, r.times)}`);
+    // rig-c/pose#282: each reach chain's origin against its source joint; a map without one prints none.
+    for (const e of r.reachOrigin) {
+      say(`  REACH-ORIGIN ${reachOriginLine(e, r.times)}`);
+      if (e.warn) say(`  WARN   ${reachOriginWarn(e)}`);
+    }
     for (const e of r.artRange) say(`  ART-RANGE ${artRangeLine(e, r.times)}`);
     // #287: a range that clamps no frame says so once, on the last segment's line (the line count stays one per segment).
     const noClamp = legScaleNoClamp(r.legScale);
@@ -211,6 +227,9 @@ export function runRetarget(a: RetargetArgs, log: (line: string) => void): RunRe
     // rig-c/pose#281: the limbs' front-to-back order from the sequence's depth, only when it carries depth.
     const layers: FrameLayers[] | null = seq.frames.some((x) => x.depth !== undefined) ? frames.map((j, i) => layersOf(j, seq.frames[i]!.depth ?? {})) : null;
     if (layers !== null) say(`  ${depthLine(layers, seq.frames, seq.cleaned!.params.depth?.gait ?? null)}`);
+    // rig-c/pose#304: with --draw-order depth, the legs' draw order keyed from those layers.
+    const drawOrder: DrawOrderReading | null = a.drawOrder === 'depth' && layers !== null ? drawOrderFromDepth(layers, frames, seq.frames.map((x) => x.depth), r.times, map, rest, doc0.slots, input.sets, seq.cleaned!.params.loop) : null;
+    if (drawOrder !== null) for (const l of drawOrderLines(drawOrder)) say(`  ${l}`);
     if (r.pivot !== null) say(`  PIVOT  bone "${r.pivot.bone}"'s origin is ${r.pivot.distance.toFixed(2)} units (${r.pivot.hipWidths.toFixed(3)} hip widths) from its thigh roots' midpoint (${r.pivot.roots.join(' + ')}): dx ${r.pivot.offset[0].toFixed(2)}, dy ${r.pivot.offset[1].toFixed(2)}, at setup — the pivot every hip turn swings the legs about`);
     if (r.feet !== null) {
       const f = r.feet;
@@ -238,15 +257,16 @@ export function runRetarget(a: RetargetArgs, log: (line: string) => void): RunRe
     if (r.body !== null) say(`  BODY   ${bodyLine(r.body)}`);
 
     // --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, a.reduceKeepPlanted === true);
+    const reduced = a.reduce === undefined ? null : a.reduceChains === undefined ? reduceTracks(r, map, rest, a.reduce, a.reduceHip, a.reduceKeepPlanted === true) : reduceTracks(r, map, rest, a.reduce, a.reduceHip, a.reduceKeepPlanted === true, reduceOf!);
     if (reduced !== null) {
       for (const row of reduced.rows) {
         const [who, track, what, unit] = row.kind === 'angle' ? ['bone', 'rotate', 'aim', '°'] : row.kind === 'origin' ? ['hip', 'translate', 'origin', ' units'] : ['bone', 'scalex', 'scale', ' of its setup length'];
-        say(`  REDUCE ${who} "${row.bone}" ${track}: ${row.before} → ${row.after} key(s); worst ${what} error ${row.worst.toPrecision(3)}${unit} at frame ${row.frame} (t=${r.times[row.frame]!.toFixed(3)}s)`);
+        const own = row.kind === 'angle' && reduceOf!(row.bone) !== a.reduce ? ` — within its chain's ${reduceOf!(row.bone)}°` : '';
+        say(`  REDUCE ${who} "${row.bone}" ${track}: ${row.before} → ${row.after} key(s); worst ${what} error ${row.worst.toPrecision(3)}${unit} at frame ${row.frame} (t=${r.times[row.frame]!.toFixed(3)}s)${own}`);
       }
       const sum = (kind: ReduceRow['kind'], k: 'before' | 'after') => reduced.rows.filter((x) => x.kind === kind).reduce((t, x) => t + x[k], 0);
       const scales = reduced.rows.some((x) => x.kind === 'scale') ? `; scalex keys ${sum('scale', 'before')} → ${sum('scale', 'after')} within ${SCALE_REDUCE} of the setup length` : '';
-      say(`  REDUCE rotate keys ${sum('angle', 'before')} → ${sum('angle', 'after')} (${(sum('angle', 'before') / sum('angle', 'after')).toFixed(2)}×) within ${a.reduce}°${scales}${a.reduceHip === undefined ? '; the hip stays dense (no --reduce-hip)' : ''}`);
+      say(`  REDUCE rotate keys ${sum('angle', 'before')} → ${sum('angle', 'after')} (${(sum('angle', 'before') / sum('angle', 'after')).toFixed(2)}×) within ${a.reduce}°${chainsText(a.reduceChains)}${scales}${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.
@@ -295,7 +315,9 @@ export function runRetarget(a: RetargetArgs, log: (line: string) => void): RunRe
       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 tracked = added.length === 0 ? r.animation : { ...r.animation, tracks: [...own, ...added] };
+    // #304: rig-c's one draw-order timeline sits on the animation beside its tracks; written only when keyed.
+    const animation = drawOrder === null || drawOrder.keys.length === 0 ? tracked : { ...tracked, drawOrder: drawOrderKeys(drawOrder) };
     const motion = { ...base, animations: { ...animations, [a.name]: animation } };
     const g1 = gate(input.rig, motion, join(scratch, 'with'), a.profile, a.images);
     if (!g1.green) {
@@ -314,11 +336,12 @@ export function runRetarget(a: RetargetArgs, log: (line: string) => void): RunRe
     const support = a.reduce !== undefined && a.reduceKeepPlanted === true && r.feet !== null ? supportFrames(r.feet.supports) : undefined;
     const landings = measureLanding(doc, a.name, map, r, posed, support).map((l) => {
       if (a.reduce === undefined) return l;
-      if (l.kind === 'angle') return { ...l, tolerance: l.tolerance + a.reduce };
+      // #283: a chain's own tolerance is added as the run's is; the sum is rounded only under a per-chain --reduce.
+      if (l.kind === 'angle') return { ...l, tolerance: a.reduceChains === undefined ? l.tolerance + a.reduce : Number((l.tolerance + reduceOf!(l.bone)).toPrecision(12)) };
       if (l.kind === 'origin' && a.reduceHip !== undefined) return { ...l, tolerance: l.tolerance + a.reduceHip };
       if (l.kind !== 'foot') return l;
       const ankle = l.bone.replace(/:tip$/, '');
-      const by = footReduce(rest, r, ankle, a.reduce, a.reduceHip);
+      const by = footReduce(rest, r, ankle, a.reduce, a.reduceHip, a.reduceChains === undefined ? undefined : reduceOf!);
       // #251: on its support frames every mapped bone from the hip down was kept at its target, so only the hip's tolerance moves it.
       const hip = a.reduceHip ?? 0;
       if (!drift.some((d) => d.bone === l.bone)) {
@@ -326,7 +349,9 @@ export function runRetarget(a: RetargetArgs, log: (line: string) => void): RunRe
         const side = lb?.r.ankle === ankle ? 'r' : lb?.l.ankle === ankle ? 'l' : null;
         const legs = (u: number) => (side === null || r.rigLeg === null ? null : u / r.rigLeg[side]);
         const held = support === undefined ? {} : { support: side === null || support[side].size === 0 ? null : { reduce: hip, units: l.tolerance + hip, legLengths: legs(l.tolerance + hip) } };
-        drift.push({ bone: l.bone, side, plant: l.tolerance, reduce: by, units: l.tolerance + by, legLengths: legs(l.tolerance + by), ...held });
+        // #283: under a per-chain --reduce, the tolerance its leg was reduced within.
+        const leg = a.reduceChains === undefined ? {} : { legTolerance: legTolerance(rest, r, ankle, reduceOf!) };
+        drift.push({ bone: l.bone, side, plant: l.tolerance, reduce: by, units: l.tolerance + by, legLengths: legs(l.tolerance + by), ...held, ...leg });
       }
       return { ...l, tolerance: l.tolerance + (l.on === 'support' ? hip : by) };
     });
@@ -389,7 +414,7 @@ export function runRetarget(a: RetargetArgs, log: (line: string) => void): RunRe
 
     assertReportInputs([rigSnapshot,mapSnapshot,poseSnapshot]);
     // Every retarget option as resolved: the report's `options`, and with the name the build record's `flags` (#270).
-    const options = { minScore: a.minScore, 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, stance: a.stance ?? 'off', floor: a.floor ?? null, raisedByHead: a.raisedByHead === true, idle: idleName, carryIdle: a.carryIdle === true, merge: a.merge ?? null, reduce: a.reduce ?? 'off', reduceHip: a.reduceHip ?? 'off', ...(a.reduceKeepPlanted === true ? { reduceKeepPlanted: true } : {}) };
+    const options = { minScore: a.minScore, 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, stance: a.stance ?? 'off', floor: a.floor ?? null, raisedByHead: a.raisedByHead === true, idle: idleName, carryIdle: a.carryIdle === true, merge: a.merge ?? null, reduce: a.reduce ?? 'off', ...(a.reduceChains === undefined ? {} : { reduceChains: a.reduceChains }), reduceHip: a.reduceHip ?? 'off', ...(a.reduceKeepPlanted === true ? { reduceKeepPlanted: true } : {}), ...(a.drawOrder !== undefined ? { drawOrder: a.drawOrder } : {}) };
     const reportText = writeReport({
         spec: 'rig-pose-report/1',
         rigc,
@@ -414,9 +439,12 @@ export function runRetarget(a: RetargetArgs, log: (line: string) => void): RunRe
         seams: seamRead.seams,
         seamPairs: seamRead.seamPairs,
         switches: r.switches,
+        switchRuns: r.switchRuns,
         uncovered,
         turns: r.turns,
         reach: r.reach,
+        // Only when the map has a reach chain (#282): a map without one writes the report it always has.
+        ...(r.reachOrigin.length > 0 ? { reachOrigin: r.reachOrigin } : {}),
         range: r.range,
         artRange: r.artRange,
         raised: r.raised,
@@ -448,13 +476,15 @@ export function runRetarget(a: RetargetArgs, log: (line: string) => void): RunRe
         pelvis: r.pelvis,
         // Only when the sequence carries depth (#281): a sequence without it writes the report it always has.
         ...(layers !== null ? { layers: layers.map((l, frame) => ({ frame, order: l.order, depth: l.depth })) } : {}),
+        // Only with --draw-order depth (#304).
+        ...(drawOrder !== null ? { drawOrder: { source: 'depth', pairs: drawOrder.pairs, keys: drawOrder.keys, spans: drawOrder.spans } } : {}),
         stance: r.stance === null ? null : { tolerance: r.stance.tolerance, release: r.stance.release, minSeconds: r.stance.minSeconds, bounds: r.stance.bounds, ...(r.stance.range === undefined ? {} : { range: r.stance.range }), runs: r.stance.runs, over: r.stance.over },
         feet: r.feet === null ? null : { planted: r.planted, legLength: r.feet.legLength, straight: r.legStraight, rigLeg: r.rigLeg, segments: r.segments, supports: r.feet.supports, jumps: r.feet.jumps, steps: r.feet.steps, changes: r.feet.changes, ...(r.feet.lowered === undefined ? {} : { lowered: r.feet.lowered }), ...(r.feet.tracked === undefined ? {} : { tracked: r.feet.tracked }), floor: r.floor?.y ?? null, shifts: r.floor?.shifts ?? [], blend: r.blendHold === null ? null : { bounds: r.blendHold.bounds, ...(r.blendHold.range === undefined ? {} : { range: r.blendHold.range }), runs: r.blendHold.runs, over: r.blendHold.over }, reading: feetReading, closure: r.closure },
         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, ankleDrift: drift },
+        reduce: reduced === null ? null : { tolerance: a.reduce, ...(a.reduceChains === undefined ? {} : { chains: a.reduceChains }), hipTolerance: a.reduceHip ?? null, rows: reduced.rows, ankleDrift: drift },
       }, map, { frameTimes: r.times }, f.meshes !== null && doc.slots.length > 0 ? reportRenderDomain(JSON.parse(readFileSync(join(f.frames, '..', 'frames.json'), 'utf8')), a.name) : seamRead.frames === null ? null : reportRenderDomain(seamRead.frames, a.name), {rig:rigSnapshot.identity,map:mapSnapshot.identity,pose:poseSnapshot.identity});
     if (a.build !== undefined) {
       // Built again where it will live, not copied: rigc's page paths are relative to the build (#18).
@@ -626,7 +656,7 @@ const spanText = (x: [number, number]) => (x[0] === x[1] ? `${x[0]}` : `${x[0]}
  * aim and length it lands on (`reduceUnderScale`). With none, this is #32's
  * reduction, unchanged.
  */
-function reduceTracks(r: ReturnType<typeof retarget>, map: JointMap, rest: Rest, tolerance: number, hipTolerance: number | undefined, keepPlanted: boolean): Reduced {
+function reduceTracks(r: ReturnType<typeof retarget>, map: JointMap, rest: Rest, tolerance: number, hipTolerance: number | undefined, keepPlanted: boolean, tolOf: (bone: string) => number = () => tolerance): Reduced {
   const n = r.times.length;
   const keep = new Map<string, Set<number>>();
   const add = (bone: string, ...frames: number[]) => {
@@ -665,7 +695,9 @@ function reduceTracks(r: ReturnType<typeof retarget>, map: JointMap, rest: Rest,
     return false;
   };
   const dense = new Map([...rotate].map(([b, tr]) => [b, tr.keys.map((k) => k.v[0]!)]));
-  const bones: ReduceBone[] = [...rotate.values()].filter((tr) => !under(tr.bone)).map((tr) => ({ bone: tr.bone, above: above(tr.bone), dense: dense.get(tr.bone)!, keep: keep.get(tr.bone) ?? new Set<number>() }));
+  // #283: a bone whose chain --reduce names carries its own tolerance; every other takes the run's.
+  const own = (b: string): { tolerance?: number } => (tolOf(b) === tolerance ? {} : { tolerance: tolOf(b) });
+  const bones: ReduceBone[] = [...rotate.values()].filter((tr) => !under(tr.bone)).map((tr) => ({ bone: tr.bone, above: above(tr.bone), dense: dense.get(tr.bone)!, keep: keep.get(tr.bone) ?? new Set<number>(), ...own(tr.bone) }));
   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)!;
@@ -758,6 +790,7 @@ function reduceTracks(r: ReturnType<typeof retarget>, map: JointMap, rest: Rest,
       asked: r.scales.get(b) ?? new Array<number>(n).fill(1),
       dense: dense.get(b)!,
       keep: keepOf(b),
+      ...own(b),
     };
   });
   const red = reduceUnderScale(r.times, given, tolerance, SCALE_REDUCE);
@@ -782,7 +815,7 @@ function reduceTracks(r: ReturnType<typeof retarget>, map: JointMap, rest: Rest,
  * world aim is within the angle tolerance of its dense one, top-down, so the
  * segments' errors are each bounded and the sum bounds the ankle's.
  */
-export function footReduce(rest: Rest, r: ReturnType<typeof retarget>, ankle: string, tolerance: number, hipTolerance: number | undefined): number {
+export function footReduce(rest: Rest, r: ReturnType<typeof retarget>, ankle: string, tolerance: number, hipTolerance: number | undefined, tolOf?: (bone: string) => number): number {
   const top = r.origin?.bone ?? null;
   let sMax = 1;
   for (const s of r.scales.values()) for (const v of s) sMax = Math.max(sMax, v);
@@ -794,7 +827,8 @@ export function footReduce(rest: Rest, r: ReturnType<typeof retarget>, ankle: st
     if (p === null) break;
     lever += Math.hypot(x.worldX - p.worldX, x.worldY - p.worldY);
   }
-  return (hipTolerance ?? 0) + lever * sMax * ((tolerance * Math.PI) / 180 + SCALE_REDUCE);
+  const deg = tolOf === undefined ? tolerance : legTolerance(rest, r, ankle, tolOf);
+  return (hipTolerance ?? 0) + lever * sMax * ((deg * Math.PI) / 180 + SCALE_REDUCE);
 }
 
 function spans(ts: number[], step: number): string {
@@ -1290,6 +1324,8 @@ export interface AnkleDrift {
    * Absent without the flag.
    */
   support?: { reduce: number; units: number; legLengths: number | null } | null;
+  /** rig-c/pose#283: under a per-chain --reduce, the largest tolerance a bone from the hip down to it was reduced within (degrees). */
+  legTolerance?: number;
 }
 
 /** #251: each side's support frames, from the spans --plant-feet read. */
@@ -1301,11 +1337,46 @@ function supportFrames(supports: ReadonlyArray<{ side: 'r' | 'l'; frames: [numbe
 
 /** The drift line: the allowance on one frame, and what it lets a planted ankle slide between two. */
 export function ankleDriftLine(d: AnkleDrift): string {
+  const chainDeg = d.legTolerance;
   const legs = (v: number) => (d.legLengths === null ? '' : ` = ${(d.legLengths * v / d.units).toPrecision(3)} leg lengths`);
   const line = `ankle drift allowed: bone "${d.bone}" ${d.units.toPrecision(3)} units${legs(d.units)} on any one frame (plant ${d.plant.toPrecision(3)} + reduce ${d.reduce.toPrecision(3)}); between two frames up to ${(2 * d.units).toPrecision(3)} units${legs(2 * d.units)}`;
-  if (d.support === undefined) return `${line} — a tighter slide bar needs a smaller --reduce`;
+  if (d.support === undefined) return `${line} — ${chainDeg === undefined ? 'a tighter slide bar needs a smaller --reduce' : `its leg reduced within ${chainDeg}° (--reduce <deg>,<chain>=<deg>); a tighter slide bar needs a smaller one on its chain`}`;
   if (d.support === null) return `${line}; its side never supports, so --reduce-keep-planted keeps no frame of it`;
   const s = d.support;
   const sLegs = (v: number) => (s.legLengths === null ? '' : ` = ${(s.legLengths * v / s.units).toPrecision(3)} leg lengths`);
   return `${line} off its support frames; on them, kept dense (--reduce-keep-planted), ${s.units.toPrecision(3)} units${sLegs(s.units)} (plant ${d.plant.toPrecision(3)} + hip ${s.reduce.toPrecision(3)}), between two frames of a support span up to ${(2 * s.units).toPrecision(3)} units${sLegs(2 * s.units)}`;
 }
+
+/** rig-c/pose#283: the largest tolerance any bone from `ankle` up to the legs' top was reduced within. */
+export function legTolerance(rest: Rest, r: ReturnType<typeof retarget>, ankle: string, tolOf: (bone: string) => number): number {
+  const top = r.origin?.bone ?? null;
+  let deg = tolOf(ankle);
+  for (let b: string | null = rest.get(ankle)!.parent; b !== null && b !== top; b = rest.get(b)!.parent) deg = Math.max(deg, tolOf(b));
+  return deg;
+}
+
+/**
+ * rig-c/pose#283: the reduction's tolerance per bone. Every bone takes `tolerance`
+ * but a bone of a chain `chains` names, which takes that chain's (the smallest,
+ * when two named chains list it). A name the map has no chain for is refused by
+ * name, beside the chains it has.
+ */
+export function reduceTolerances(map: JointMap, tolerance: number, chains: Record<string, number> | undefined, mapPath: string): (bone: string) => number {
+  if (chains === undefined) return () => tolerance;
+  const names = map.chains.map((c) => c.name);
+  const missing = Object.keys(chains).filter((c) => !names.includes(c));
+  if (missing.length > 0) throw new Refusal(missing.map((c) => ({ code: 'POSE_REDUCE', text: `--reduce names chain "${c}", which ${mapPath} does not have; its chains are ${names.map((x) => `"${x}"`).join(', ')}` })));
+  const by = new Map<string, number>();
+  for (const c of map.chains) {
+    const t = Object.hasOwn(chains, c.name) ? chains[c.name] : undefined;
+    if (t === undefined) continue;
+    for (const b of c.bones) by.set(b, Math.min(by.get(b) ?? t, t));
+  }
+  return (bone) => by.get(bone) ?? tolerance;
+}
+
+/** rig-c/pose#283: the per-chain tolerances as the run and REDUCE lines print them; empty without. */
+export function chainsText(chains: Record<string, number> | undefined): string {
+  if (chains === undefined) return '';
+  return ` (${Object.entries(chains).map(([c, t]) => `chain "${c}" ${t}°`).join(', ')})`;
+}