@rig-c/pose 0.2.0 → 0.3.0

package/README.md

@@ -8,6 +8,16 @@ Part of the rig-c toolchain: [core](https://github.com/rig-c/core) compiles and
 
 <!-- demo -->
 
+## Try it
+
+[`examples/wave`](examples/wave) runs with nothing else: a bones-only stick rig (no art), a 3-second wave made from joint angles (`make-pose.ts` writes it), and the map that joins them.
+
+```sh
+rig-pose retarget --rig examples/wave/rig --map examples/wave/map.json --pose examples/wave/pose.json --out wave.motion.json --build wave-build
+```
+
+It prints the gate's verdict and where every mapped bone landed, then writes `wave.motion.json` and the gated build. `rigc preview --candidate wave-build` plays it in the Spine Web Player. A rig with no art shows only its bones.
+
 ## What it does
 
 ```sh
@@ -29,6 +39,8 @@ Nothing is written until every check passes:
 and what the run cannot decide for you it lists:
 
 - `HOLD` — a joint missing, or scored under `--min-score`, holds its last good value; one line per span, with the frames and the reason.
+- `SHORT` — a segment shorter in the picture than `--short` of its median length (with `--short <fraction>`; off by default) has its angle there interpolated, not read; one line per span, with the chain, the segment, the frames and the lowest fraction. Below.
+- `END-ON` — a `SHORT` run lasting at least 0.15 s: the limb points at the camera, a pose the rig cannot draw.
 - `FLIP` — a segment that turns more than `--flip` degrees in one frame (with `--flip <deg>`; off by default) is spread over the frames around the jump; one line per spread, with the chain, the segment, the jump, the frames and h. Below.
 - `BEND` — with `--bends clamp`, a hinge bent the wrong way is straightened on that frame instead of refusing.
 - `FOLD` — `rigc render --folds` over the new animation: every mesh that folds, and when. A reading, not a gate.
@@ -44,6 +56,17 @@ The threshold was fixed by measuring first ([#15](https://github.com/rig-c/pose/
 
 Re-measured with the guard on, against the guarded unsmoothed run, on #11's criteria (power above 6 Hz down ≥ 2× on every point, timing lag 0, p95 speed ≥ 0.85×): no window passes. `--smooth 7` comes closest — the left wrist's power drops 1.99× and the hip's p95 speed is 0.847× — so `--smooth` stays off by default, and so does the guard: the rule posted before the run made a default for either one depend on a window passing. **Use `--flip 90`**: with it, no bone of the gated build turns more than 90° in one frame (without it, 148.6°), and every bone still lands.
 
+**The short hold.** A segment pointing at the camera is short in the picture, and its picture direction is then detector noise: the rig turns the bone to follow it. So after holds and smoothing, and before the flip guard, every limb segment the map aims is measured on every frame (not a `reach`, and not a line across the body from a left joint to its right twin, such as the hip line or the eye line: those shorten when the body or head turns, which is a different thing, and the cutoff below was measured on limbs only) — its picture length, between the same two points its angle is read from, over its own median length across the pose. On a frame under `--short <fraction>` its angle is not read from the pose: it is interpolated, the short way round, from the last frame at or above the cutoff to the next one, and held flat at the first or last frame of the pose. The flip guard, the hinge check and the keys all see the held angle. `--short off` (the default) reads every frame. The report lists each span under `short` (chain, bone, segment, first and last frame, the lowest fraction).
+
+The cutoff was fixed by measuring first ([#22](https://github.com/rig-c/pose/issues/22)), over both upper arms, forearms, thighs and shins. On the 13 s dance (24 fps, 2,504 segment-frames) the fraction's 0.5th percentile is 0.51, its 5th 0.82, and 7 segment-frames (0.28%) are under 0.35; on a 16 s second sequence (30 fps, 3,936) they are 0.27 and 0.75, and 34 (0.86%). Every frame under 0.35 was looked at, and was one of two kinds:
+
+- **end-on, lasting several frames** — the limb really points at the camera: on the second sequence the right upper arm folded across the chest (frames 395–401, 0.09–0.25), and the right thigh and shin of a knee raised at the camera (365–370, 0.16–0.34); on the dance the left upper arm with the elbow at the camera (frames 30–37, 0.27–0.35, S2 below);
+- **blur collapse, lasting 1–3 frames** — a fast forearm whose elbow and wrist the detector both puts on the blurred hand (eleven spans on the second sequence).
+
+Both have a meaningless direction; only the first is a pose the rig cannot draw. **0.35** is the smallest round value that takes in every end-on frame (the highest is 0.35, on the dance) without reaching normal motion (the 5th percentiles are 0.75 and 0.82). A run under the cutoff — spans merged across a gap of one frame — lasting **≥ 0.15 s** (3.6 frames at 24 fps, 4.5 at 30) is the end-on kind: it excludes every blur collapse above (at most 3 frames, 0.10 s at 30 fps) and keeps every end-on span (6–8 frames). The run prints it as `END-ON` and the report lists it under `endOn` (chain, bone, segment, frames, seconds, the lowest fraction): it is the list of moments that need an alternate drawing ([#6](https://github.com/rig-c/pose/issues/6)).
+
+Re-checked on the exam01 test rig with `--short 0.35 --flip 90 --bends clamp`. On the second sequence the three spreads the flip guard made out of end-on segments are SHORT holds now, not FLIPs: right upper arm 399–400, right thigh 368–369, right shin 368–371. Of the flip guard's other spreads only one is left, the left forearm at 322–323; every other one fell on frames under the cutoff and is a SHORT hold instead. No guarded bone of the gated build turns more than 81.4° in one frame (85.1° with `--flip 90` alone), and every bone lands. `endOn` there lists the right upper arm (395–401) and the right shin (365–370). It does not list the right thigh, which is under 0.35 on one frame only (369, 0.16). The plan before the run expected the thigh too, and that expectation was wrong. On the dance `endOn` lists exactly S2's left upper arm (30–37); the three FLIPs are #15's, the largest one-frame turn is 78.2°, and every bone lands. A first implementation also held the lines across the body. It listed the eye line (head in profile) and the hip line (body side-on) as end-on, and holding the hip line narrowed the rig's hip tilt range to 39.3° against the pose's 125.2°. The cutoff was never measured on those lines, so they are excluded; with them out the rig reads 125.2° again. The default stays off: a default needs its own criterion and a third sequence.
+
 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

@@ -38,13 +38,18 @@ retarget
   --flip <deg>|off      a segment that turns more than <deg> degrees in one frame of the pose is
                         spread over the frames around the jump, centred on it, and listed as FLIP
                         (default: off, every turn kept as the pose gives it; 90 is the measured setting)
+  --short <f>|off       a segment whose picture length on a frame is under <f> of its median length
+                        (seen end-on, or collapsed by blur) has its angle there interpolated from the
+                        frames either side, before the flip guard, and listed as SHORT; a run under <f>
+                        lasting ≥ 0.15 s is also listed as END-ON (default: off; 0.35 is the measured
+                        setting, f in (0, 1))
   --bends refuse|clamp  a hinge (elbow, knee: any joint inside a chain) bent the wrong way refuses
                         the run (default), or is straightened on that frame and listed
   --bend-tolerance <d>  degrees past straight a hinge may bend the wrong way before it counts (default: 0)
   --profile spine|spine-html  rigc's gate profile (default: spine, rigc's own default)
   --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, flips, bends, landings, folds) as JSON
+  --report <file>       write the run's measurements (holds, short, endOn, flips, bends, landings, folds) 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.
@@ -104,8 +109,13 @@ function flipOf(f: Map<string, string>): number | 'off' {
   return num(f, 'flip', 90, (v) => v > 0 && v < 180, 'off, or degrees in (0, 180) — a one-frame turn is never more than 180°');
 }
 
+function shortOf(f: Map<string, string>): number | 'off' {
+  if (!f.has('short') || f.get('short') === 'off') return 'off';
+  return num(f, 'short', 0.35, (v) => v > 0 && v < 1, 'off, or a fraction in (0, 1) of the segment\'s median picture length');
+}
+
 function retargetArgs(argv: string[]): RetargetArgs {
-  const f = parseFlags(argv, ['rig', 'map', 'pose', 'out', 'name', 'person', 'base-motion', 'min-score', 'smooth', 'flip', 'bends', 'bend-tolerance', 'profile', 'build', 'render', 'report'], ['coco']);
+  const f = parseFlags(argv, ['rig', 'map', 'pose', 'out', 'name', 'person', 'base-motion', 'min-score', 'smooth', 'flip', 'short', 'bends', 'bend-tolerance', 'profile', 'build', 'render', 'report'], ['coco']);
   const bends = f.get('bends') ?? 'refuse';
   if (bends !== 'refuse' && bends !== 'clamp') throw new Usage(`--bends is "${bends}"; it must be refuse or clamp`);
   const profile = f.get('profile') ?? 'spine';
@@ -124,6 +134,7 @@ function retargetArgs(argv: string[]): RetargetArgs {
     minScore: num(f, 'min-score', 0.3, (n) => n >= 0, 'a number ≥ 0'),
     smooth: smoothOf(f),
     flip: flipOf(f),
+    short: shortOf(f),
     bends,
     bendTolerance: num(f, 'bend-tolerance', 0, (n) => n >= 0 && n < 180, 'degrees in [0, 180)'),
     profile,

package/package.json

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

@@ -23,11 +23,21 @@
  * evaluated at the frame, on each joint's positions after its holds. Centred,
  * it moves no motion in time; a cubic keeps a peak a moving average flattens.
  *
+ * The short hold (rig-c/pose#22) comes next: a segment whose picture length on
+ * a frame is under `short` of its own median length over the sequence is seen
+ * end-on, or collapsed by blur, and its picture direction there is noise. Its
+ * angle on those frames is not read from the pose but interpolated, the short
+ * way round, between the frames either side at or above the cutoff (flat at the
+ * ends: `holdShort`). A run under the cutoff lasting ≥ `END_ON_SECONDS` (spans
+ * merged across a gap of `END_ON_GAP` frame) is listed as `endOn`: a pose the
+ * rig cannot draw, the demand for an alternate drawing (#6).
+ *
  * The flip guard (rig-c/pose#15) then spreads a segment's turn greater than
  * `flip` degrees in one frame over the frames around it, linearly and centred on
  * the jump (`spreadFlips`). It reads the mapped segments' target angles after
- * holds and smoothing and before the hinge check. A reach's target is aimed
- * later, from posed positions, and is not guarded.
+ * holds, smoothing and the short hold, and before the hinge check. A reach's
+ * target is aimed later, from posed positions, and is neither held short nor
+ * guarded.
  *
  * What this cannot know is held to account afterwards: `verify.ts` poses the
  * gated build with rig-c's poser and measures where each bone landed.
@@ -53,6 +63,8 @@ export interface RetargetOptions {
   bendTolerance: number;
   /** A segment turning more than this many degrees in one frame is spread (`spreadFlips`); 'off' keeps every turn. */
   flip: number | 'off';
+  /** A segment shorter in the picture than this fraction of its median length has its angle held there (`holdShort`); 'off' reads every frame. */
+  short: number | 'off';
 }
 
 export interface Hold {
@@ -97,6 +109,39 @@ export interface Flip {
   clipped: 'start' | 'end' | 'both' | null;
 }
 
+/** One span of frames under the short cutoff: the segment's angle there was interpolated, not read (`holdShort`). */
+export interface Short {
+  chain: string;
+  bone: string;
+  /** The segment the bone carries: from joint, to joint. */
+  joints: [string, string];
+  /** First and last frame under the cutoff; every one of them had its angle replaced, and the frames either side keep the input's. */
+  frames: [number, number];
+  /** The lowest picture length on those frames, as a fraction of the segment's median picture length. */
+  minFraction: number;
+}
+
+/**
+ * A segment under the short cutoff long enough to be a pose (the limb pointing
+ * at the camera), not a blur: short spans merged across a gap of `END_ON_GAP`
+ * frame, lasting ≥ `END_ON_SECONDS`. The demand for an alternate drawing (#6).
+ */
+export interface EndOn {
+  chain: string;
+  bone: string;
+  joints: [string, string];
+  /** First and last frame of the merged run (a gap frame inside it is at or above the cutoff). */
+  frames: [number, number];
+  /** How long it lasts: from the first frame's key time to the end of the last frame (the next frame's key time; for the pose's last frame, one frame on). */
+  seconds: number;
+  minFraction: number;
+}
+
+/** A run under the short cutoff lasting at least this long, in seconds, is listed as `endOn` (rig-c/pose#22). */
+export const END_ON_SECONDS = 0.15;
+/** Short spans this many frames apart or fewer merge into one `endOn` run. */
+export const END_ON_GAP = 1;
+
 export interface MotionKey {
   t: number;
   v: number[];
@@ -121,6 +166,10 @@ export interface Retarget {
   origin: { bone: string; at: Array<[number, number]> } | null;
   holds: Hold[];
   bends: BendEvent[];
+  /** The short hold's spans, per segment in map order. */
+  short: Short[];
+  /** The short runs long enough to be a pose seen end-on. */
+  endOn: EndOn[];
   flips: Flip[];
   /** The figure scale, rig units per picture pixel, and the lengths it came from. */
   scale: { factor: number; pose: number; rig: number } | null;
@@ -358,6 +407,41 @@ export function retarget(rest: Rest, map: JointMap, frames: ReadonlyArray<Partia
   }
   p.throwIfAny();
 
+  // The short hold, on every limb segment the pose aims directly (not a reach, and
+  // not a line across the body from a left joint to its right twin — the hip line,
+  // the eye line — whose shortening is the body or head turning, not a limb seen
+  // end-on; #22's cutoff was measured on limb segments only): its picture length
+  // against its own median, on the points the angle was read from.
+  const short: Short[] = [];
+  const endOn: EndOn[] = [];
+  if (opts.short !== 'off') {
+    const cutoff = opts.short;
+    /** The end of frame i: the next frame's key time; the last frame lasts as long as the one before it. */
+    const endOf = (i: number): number => (i + 1 < n ? keyTimes[i + 1]! : n > 1 ? 2 * keyTimes[i]! - keyTimes[i - 1]! : keyTimes[i]!);
+    for (const c of map.chains) {
+      if (c.reach) continue;
+      c.bones.forEach((b, k) => {
+        const joints: [string, string] = [c.joints[k]!, c.joints[k + 1]!];
+        if (isAcross(joints[0], joints[1])) return;
+        const from = series.get(joints[0])!;
+        const to = series.get(joints[1])!;
+        const lengths = from.map((f, i) => Math.hypot(to[i]![0] - f[0], to[i]![1] - f[1]));
+        const med = median(lengths);
+        if (med < 1e-6) {
+          p.add('POSE_SHORT_MEDIAN', `chain "${c.name}" — bone "${b}"'s segment ${joints[0]} → ${joints[1]} has median picture length ${med}px over the ${n} frames; --short measures a frame's length against that median, and there is none to measure against`);
+          return;
+        }
+        const spans = holdShort(targets.get(b)!, lengths.map((l) => l / med), cutoff);
+        for (const s of spans) short.push({ chain: c.name, bone: b, joints, ...s });
+        for (const run of mergeRuns(spans, END_ON_GAP)) {
+          const seconds = Math.round((endOf(run.frames[1]) - keyTimes[run.frames[0]]!) * 1e6) / 1e6;
+          if (seconds >= END_ON_SECONDS - 1e-9) endOn.push({ chain: c.name, bone: b, joints, frames: run.frames, seconds, minFraction: run.minFraction });
+        }
+      });
+    }
+  }
+  p.throwIfAny();
+
   // The flip guard, on every segment the pose aims directly (not a reach).
   const flips: Flip[] = [];
   if (opts.flip !== 'off') {
@@ -452,7 +536,78 @@ export function retarget(rest: Rest, map: JointMap, frames: ReadonlyArray<Partia
   }
   if (translateTrack !== null) tracks.push(translateTrack);
 
-  return { animation: { duration: keyTimes[n - 1]!, tracks }, times: keyTimes, targets, origin, holds, bends, flips, scale };
+  return { animation: { duration: keyTimes[n - 1]!, tracks }, times: keyTimes, targets, origin, holds, bends, short, endOn, flips, scale };
+}
+
+type ShortSpan = Omit<Short, 'chain' | 'bone' | 'joints'>;
+
+/**
+ * The short hold on one angle series (degrees), in place. `fraction` is the
+ * segment's picture length on each frame over its median. Each run of frames
+ * under `cutoff` has its angles replaced by the line from the last frame before
+ * it at or above the cutoff to the first one after it, the short way round; a
+ * run at the start or the end of the series holds the one reliable end flat.
+ * With the fraction against the median and a cutoff under 1, half the frames
+ * at least are at or above it, so every run has a reliable end. Returns the runs.
+ */
+/** A line across the body: a left joint and its right twin (r_hip → l_hip, r_eye → l_eye). */
+export function isAcross(a: string, b: string): boolean {
+  const twin = (x: string): string | null => (x.startsWith('r_') ? `l_${x.slice(2)}` : x.startsWith('l_') ? `r_${x.slice(2)}` : null);
+  return twin(a) === b;
+}
+
+export function holdShort(angles: number[], fraction: readonly number[], cutoff: number): ShortSpan[] {
+  const n = angles.length;
+  const out: ShortSpan[] = [];
+  for (let i = 0; i < n; i++) {
+    if (!(fraction[i]! < cutoff)) continue;
+    let j = i;
+    while (j + 1 < n && fraction[j + 1]! < cutoff) j++;
+    const lo = i - 1;
+    const hi = j + 1;
+    let minFraction = fraction[i]!;
+    for (let k = i + 1; k <= j; k++) minFraction = Math.min(minFraction, fraction[k]!);
+    if (lo >= 0 || hi < n) {
+      const a = lo >= 0 ? angles[lo]! : angles[hi]!;
+      const b = hi < n ? angles[hi]! : a;
+      const turn = wrap(b - a);
+      for (let k = i; k <= j; k++) angles[k] = lo < 0 ? b : wrap(a + (turn * (k - lo)) / (hi - lo));
+    }
+    out.push({ frames: [i, j], minFraction });
+    i = j;
+  }
+  return out;
+}
+
+/** Short spans `gap` frames apart or fewer, as one run each: its first and last frame, and the lowest fraction. */
+export function mergeRuns(spans: readonly ShortSpan[], gap: number): ShortSpan[] {
+  const out: ShortSpan[] = [];
+  for (const s of spans) {
+    const last = out[out.length - 1];
+    if (last !== undefined && s.frames[0] - last.frames[1] - 1 <= gap) {
+      last.frames = [last.frames[0], s.frames[1]];
+      last.minFraction = Math.min(last.minFraction, s.minFraction);
+    } else out.push({ frames: [s.frames[0], s.frames[1]], minFraction: s.minFraction });
+  }
+  return out;
+}
+
+const spanOf = (frames: [number, number], times: readonly number[]): string =>
+  frames[0] === frames[1] ? `frame ${frames[0]} (t=${times[frames[0]]!.toFixed(3)}s)` : `frames ${frames[0]}–${frames[1]} (t=${times[frames[0]]!.toFixed(3)}–${times[frames[1]]!.toFixed(3)}s)`;
+
+export function shortLine(s: Short, times: readonly number[], cutoff: number): string {
+  const lo = s.frames[0] - 1;
+  const hi = s.frames[1] + 1;
+  const held = lo < 0 && hi >= times.length
+    ? 'no frame of the pose is at or above it, so nothing was held'
+    : lo < 0 ? `held flat at frame ${hi}'s angle (the pose starts short)`
+      : hi >= times.length ? `held flat at frame ${lo}'s angle (the pose ends short)`
+        : `interpolated from frame ${lo}'s angle to frame ${hi}'s, the short way round`;
+  return `chain "${s.chain}" bone "${s.bone}" (${s.joints[0]} → ${s.joints[1]}) ${spanOf(s.frames, times)}: picture length down to ${s.minFraction.toFixed(2)} of its median, under ${cutoff}; its direction is not read — ${held}`;
+}
+
+export function endOnLine(e: EndOn, times: readonly number[], cutoff: number): string {
+  return `chain "${e.chain}" bone "${e.bone}" (${e.joints[0]} → ${e.joints[1]}) ${spanOf(e.frames, times)}: ${e.seconds.toFixed(3)}s under ${cutoff} of its median picture length (down to ${e.minFraction.toFixed(2)}), ≥ ${END_ON_SECONDS}s — seen end-on, a pose the rig cannot draw`;
 }
 
 type Spread = Omit<Flip, 'chain' | 'bone' | 'joints'>;

package/src/rigc.ts

@@ -100,18 +100,27 @@ export function gate(rig: string, motion: Record<string, unknown>, dir: string,
   mkdirSync(dir, { recursive: true });
   const motionPath = join(dir, 'motion.json');
   writeFileSync(motionPath, `${JSON.stringify(motion, null, 2)}\n`);
-  const build = join(dir, 'build');
-  // --copy-images: a build's page paths are relative to its directory, and the
-  // gated build is copied out of the scratch directory for `--build`, so its
-  // pages travel with it (rigc refuses to draw a moved build otherwise).
-  const run = runRigc(['build', '--rig', rig, '--motion', motionPath, '--out', build, '--profile', profile, '--copy-images', '--report', join(dir, 'build-report.json')]);
+  return buildInto(rig, motionPath, join(dir, 'build'), profile, join(dir, 'build-report.json'));
+}
+
+/**
+ * `rigc build` of `rig` with the motion spec at `motionPath` into `out`, under
+ * rigc's gate (it writes nothing when red). rigc records each source image's
+ * path relative to `out` (`images[].page` in the model document), so a build is
+ * only right where it was built: the run gates in a scratch directory, and the
+ * build `--build` keeps is built again, by rigc, where it will live (#18) —
+ * never copied out, which would carry a path climbing from the scratch
+ * directory to the filesystem root. --copy-images puts the pages beside it.
+ */
+export function buildInto(rig: string, motionPath: string, out: string, profile: string, report?: string): Gate {
+  const run = runRigc(['build', '--rig', rig, '--motion', motionPath, '--out', out, '--profile', profile, '--copy-images', ...(report === undefined ? [] : ['--report', report])]);
   const lines = run.out.split('\n');
   return {
     run,
     green: run.status === 0,
     summary: lines.find((l) => /assertions: \d+ measured/.test(l))?.replace(/^[\s.]+/, '') ?? null,
     fails: lines.filter((l) => /^\s*FAIL\s/.test(l) || l.startsWith('rigc compile error')).map((l) => l.trim()),
-    build,
+    build: out,
   };
 }
 

package/src/run.ts

@@ -5,12 +5,12 @@
  */
 import { cpSync, existsSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
-import { dirname, join } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
 import { readMap, resolveMap } from './map.ts';
 import { convertCoco17, personTrack, readPoseSequence } from './pose.ts';
 import { lineOf, Problems, Refusal, type Problem } from './problems.ts';
-import { bendLine, flipLine, holdLine, retarget, type RetargetOptions } from './retarget.ts';
-import { baseMotionOf, folds, gate, readBuild, resolveRig, restOf } from './rigc.ts';
+import { bendLine, endOnLine, flipLine, holdLine, retarget, shortLine, type RetargetOptions } from './retarget.ts';
+import { baseMotionOf, buildInto, folds, gate, readBuild, resolveRig, restOf } from './rigc.ts';
 import { landed, measureLanding, measurePosture, poseFrames, postureLines, ANGLE_TOLERANCE, ORIGIN_TOLERANCE } from './verify.ts';
 
 export interface RetargetArgs extends RetargetOptions {
@@ -78,9 +78,13 @@ export function runRetarget(a: RetargetArgs, log: (line: string) => void): RunRe
     resolveMap(map, rest, a.map);
 
     const r = retarget(rest, map, frames, times, a);
-    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}°`}, bends ${a.bends} (tolerance ${a.bendTolerance}°)`);
+    say(`rig-pose retarget: ${seq.frames.length} frame(s), ${r.animation.duration.toFixed(3)}s, onto "${input.name}" as "${a.name}" — ${r.animation.tracks.length} track(s); min-score ${a.minScore}, smooth ${a.smooth}, flip ${a.flip === 'off' ? 'off' : `${a.flip}°`}, short ${a.short}, bends ${a.bends} (tolerance ${a.bendTolerance}°)`);
     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)}`);
+    if (a.short !== 'off') {
+      for (const s of r.short) say(`  SHORT  ${shortLine(s, r.times, a.short)}`);
+      for (const e of r.endOn) say(`  END-ON ${endOnLine(e, r.times, a.short)}`);
+    }
     if (a.flip !== 'off') for (const fl of r.flips) say(`  FLIP   ${flipLine(fl, r.times, a.flip)}`);
     for (const e of r.bends) say(`  BEND   ${bendLine(e)} — clamped straight`);
 
@@ -109,17 +113,21 @@ export function runRetarget(a: RetargetArgs, log: (line: string) => void): RunRe
 
     const dts = r.times.slice(1).map((t, i) => t - r.times[i]!).sort((x, y) => x - y);
     const fps = dts.length === 0 ? 12 : Math.max(1, Math.min(60, Math.round(1 / dts[dts.length >> 1]!)));
-    const f = folds(g1.build, a.name, join(scratch, 'folds'), fps);
-    if (f.meshes === null) say(`  FOLD   rigc render --folds did not read (exit ${f.run.status}); folds not measured`);
+    // A rig that draws nothing (bones only) has nothing to fold, and rigc's render refuses it.
+    const f = doc.slots.length === 0 ? { run: { args: [], status: 0, out: '' }, meshes: [], frames: '' } : folds(g1.build, a.name, join(scratch, 'folds'), fps);
+    if (doc.slots.length === 0) say('  FOLD   the rig has no slots, so it draws nothing to fold; not measured');
+    else if (f.meshes === null) say(`  FOLD   rigc render --folds did not read (exit ${f.run.status}); folds not measured`);
     else if (f.meshes.length === 0) say(`  FOLD   rigc render --folds at ${fps} fps: no mesh folds`);
     else for (const m of f.meshes) say(`  FOLD   mesh "${m.attachment}" (slot "${m.slot}") folds on ${m.times.length} frame(s) at ${fps} fps: t=${spans(m.times, 1 / fps)}`);
 
-    writeFileSync(a.out, `${JSON.stringify(motion, null, 2)}\n`);
     if (a.build !== undefined) {
+      // Built again where it will live, not copied: rigc's page paths are relative to the build (#18).
       rmSync(a.build, { recursive: true, force: true });
-      cpSync(g1.build, a.build, { recursive: true });
+      const kept = buildInto(input.rig, join(scratch, 'with', 'motion.json'), resolve(a.build), a.profile);
+      if (!kept.green) refuse([{ code: 'RIG_GATE', text: `rigc build into --build ${a.build} is red where the same build was green in scratch (exit ${kept.run.status}); nothing written` }, ...kept.fails.map((x) => ({ code: 'RIGC', text: x }))]);
     }
-    if (a.render !== undefined && f.meshes !== null) {
+    writeFileSync(a.out, `${JSON.stringify(motion, null, 2)}\n`);
+    if (a.render !== undefined && f.meshes !== null && f.frames !== '') {
       rmSync(a.render, { recursive: true, force: true });
       cpSync(f.frames, a.render, { recursive: true });
     }
@@ -130,9 +138,11 @@ 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, bends: a.bends, bendTolerance: a.bendTolerance, profile: a.profile },
+        options: { minScore: a.minScore, smooth: a.smooth, flip: a.flip, short: a.short, bends: a.bends, bendTolerance: a.bendTolerance, profile: a.profile },
         scale: r.scale,
         holds: r.holds,
+        short: r.short,
+        endOn: r.endOn,
         bends: r.bends,
         flips: r.flips,
         gate: g1.summary,