@rig-c/pose 0.24.0 → 0.25.0

package/README.md

@@ -182,7 +182,7 @@ 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 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 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 before the flip guard, every mapped segment is measured on every frame (not a `reach`) — 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. A horizontal line across the body from a left joint to its right twin (`a>b`, such as the hip line or the eye line) also holds its last confident angle and interpolates across the span whenever its picture length falls under `--short` or its 2D reading reverses sign within one frame past `--flip` (when the left and right joints cross in 2D during a full side turn, [#184](https://github.com/rig-c/pose/issues/184)); its hold is printed as `HOLD chain "..."` and is not counted toward limb `END-ON` runs. The flip guard, the hinge check and the keys all see the held angle. `--short off` (the default) reads every frame unless an across-body line reverses past `--flip`. The report lists each span under `short` (chain, bone, segment, first and last frame, the lowest fraction, and `across` / `reversed` when across-body).
 
 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:
 
@@ -191,7 +191,7 @@ The cutoff was fixed by measuring first ([#22](https://github.com/rig-c/pose/iss
 
 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.
+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. When the second sequence's pelvis is mapped (`r_hip → l_hip`), its side-on turn (frames 463–491, body yaw +79.5°) foreshortens the hip line to 0.17 of standing and crosses `r_hip.x` past `l_hip.x` on frames 482–484 (+177.4° / −179.4°); `holdAcross` ([#184](https://github.com/rig-c/pose/issues/184)) holds `hip.rotate` across the unconfident span (`[−2.2°, +2.6°]` over 463–491, `0` `FLIP`s) without listing horizontal lines as limb `END-ON`. The default stays off: a default needs its own criterion and a third sequence.
 
 ### The legs: foreshortening and planted feet
 

package/package.json

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

@@ -182,6 +182,10 @@ export interface Short {
   /** Present when a foreshortened segment (< `SHORT_STEP_FRACTION`) had its per-frame step capped (#110): the one-frame step after capping and the largest step asked, degrees, signed. */
   step?: number;
   asked?: number;
+  /** Present when a horizontal chain across the body (`isAcross`) held its last confident angle (#184). */
+  across?: boolean;
+  /** Largest one-frame turn (degrees, signed) inside a held horizontal-chain span when it reversed beyond `--flip` (#184). */
+  reversed?: number;
 }
 
 /** A limb segment shorter than this fraction of its median picture length has its per-frame angle step capped at `SHORT_STEP_CAP` degrees (rig-c/pose#110). */
@@ -610,30 +614,40 @@ 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.
+  // The short hold, on every segment the pose aims directly (not a reach): its
+  // picture length against its own median, on the points the angle was read from.
+  // A horizontal line across the body (`isAcross`: pelvis, shoulders, head line)
+  // holds and interpolates across spans under `--short` or reversed within a frame
+  // beyond `--flip` (#184), without listing the run as `endOn` (`TURN` reads turned
+  // body/head lines).
   const short: Short[] = [];
   const endOn: EndOn[] = [];
   const fractions = new Map<string, { chain: string; joints: [string, string]; fraction: number[] }>();
-  if (opts.short !== 'off') {
-    const cutoff = opts.short;
+  if (opts.short !== 'off' || opts.flip !== 'off') {
     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 across = isAcross(joints[0], joints[1]);
+        if (!across && opts.short === 'off') 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`);
+          if (opts.short !== 'off') {
+            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 fraction = lengths.map((l) => l / med);
+        if (across) {
+          const restDir = joints[0].startsWith('r_') ? 0 : 180;
+          const spans = holdAcross(targets.get(b)!, fraction, opts.short, opts.flip, restDir);
+          for (const s of spans) short.push({ chain: c.name, bone: b, joints, ...s });
+          return;
+        }
+        const cutoff = opts.short as number;
         fractions.set(b, { chain: c.name, joints, fraction });
         const spans = holdShort(targets.get(b)!, fraction, cutoff);
         for (const s of spans) short.push({ chain: c.name, bone: b, joints, ...s });
@@ -1366,6 +1380,7 @@ export function retarget(rest: Rest, map: JointMap, frames: ReadonlyArray<Partia
       const set = map.alternates.find((a) => a.name === s.set)!;
       const art: ArtRange[] = [];
       for (const cn of s.chains) {
+        if (sw.chainHolds?.some((h) => h.chain === cn && h.set !== s.set && h.frames[0] <= s.frames[0] && h.frames[1] >= s.frames[1]) === true) continue;
         const c = map.chains.find((x) => x.name === cn)!;
         const drawn = set.drawn[c.bones[0]!];
         const up = isChainHeadPlaced(set, c, drawn);
@@ -1619,6 +1634,45 @@ export function retarget(rest: Rest, map: JointMap, frames: ReadonlyArray<Partia
     if (job.anchor.kind === 'head') raised.push({ set, chain, frames, seconds, eyes: unit, ...body });
     else byHip.push({ set, chain, frames, seconds, hips: unit, ...body });
   }
+  if (opts.short !== 'off') {
+    for (const s of short) {
+      if (s.step === undefined || s.across === true) continue;
+      const cov = covered.get(s.chain);
+      const [lo, hi] = s.frames;
+      if (lo <= 0 || hi + 1 >= n) continue;
+      if (cov?.[lo - 1] !== true && cov?.[hi + 1] !== true) continue;
+      const tg = targets.get(s.bone)!;
+      const startA = tg[lo - 1]!;
+      const total = wrap(tg[hi + 1]! - startA);
+      const steps = hi - lo + 2;
+      for (let k = lo; k <= hi; k++) {
+        tg[k] = wrap(startA + ((k - lo + 1) / steps) * total);
+      }
+      s.step = r3(total / steps);
+    }
+    const holds = sw.chainHolds ?? [];
+    for (const h of holds) {
+      const swParent = sw.switches.find((s) => s.set === h.set && s.frames[0] === h.frames[0] && s.frames[1] > h.frames[1]);
+      if (!swParent) continue;
+      const nextH = holds.find((nh) => nh.chain === h.chain && nh.frames[0] > h.frames[1] && nh.frames[0] - h.frames[1] <= 10);
+      if (!nextH) continue;
+      const lo = h.frames[1] + 1;
+      const hi = nextH.frames[0] - 1;
+      if (lo > hi || lo <= 0 || hi + 1 >= n) continue;
+      const ch = map.chains.find((c) => c.name === h.chain);
+      if (!ch) continue;
+      const steps = hi - lo + 2;
+      for (const b of ch.bones) {
+        const tg = targets.get(b);
+        if (!tg) continue;
+        const startA = tg[lo - 1]!;
+        const total = wrap(tg[hi + 1]! - startA);
+        for (let k = lo; k <= hi; k++) {
+          tg[k] = wrap(startA + ((k - lo + 1) / steps) * total);
+        }
+      }
+    }
+  }
 
   // The legs on their final targets: a bone under a scaled bone is keyed through
   // its parent's posed matrix (legs.ts), and each ankle's world position is read.
@@ -1912,6 +1966,79 @@ export function holdShort(angles: number[], fraction: readonly number[], cutoff:
   return out;
 }
 
+/**
+ * Hold and interpolate across unconfident spans on a horizontal chain (`isAcross`,
+ * e.g. `r_hip → l_hip`, `r_eye → l_eye`, `r_shoulder → l_shoulder`, rig-c/pose#184),
+ * in place. A frame is unconfident when its picture length over its median is under
+ * `shortCutoff` (with `--short`) or when its angle turns more than `flipThreshold`
+ * from the last confident angle or reverses more than 90° from the line's rest
+ * direction `restDir` (with `--flip`). Each contiguous unconfident run has its
+ * angles interpolated between the confident frames either side (flat at the ends),
+ * the short way round, exactly as `holdShort` does on limb chains.
+ */
+export function holdAcross(
+  angles: number[],
+  fraction: readonly number[],
+  shortCutoff: number | 'off',
+  flipThreshold: number | 'off',
+  restDir = 0,
+): ShortSpan[] {
+  const n = angles.length;
+  if (n === 0 || (shortCutoff === 'off' && flipThreshold === 'off')) return [];
+  const raw = [...angles];
+  const unconf = new Array<boolean>(n).fill(false);
+  let lastConfident = raw[0]!;
+  for (let i = 0; i < n; i++) {
+    const s = shortCutoff !== 'off' && fraction[i]! < shortCutoff;
+    const rev = Math.abs(wrap(raw[i]! - restDir)) > 90;
+    if (!s && !rev) {
+      lastConfident = raw[i]!;
+      break;
+    }
+  }
+  for (let i = 0; i < n; i++) {
+    const isShort = shortCutoff !== 'off' && fraction[i]! < shortCutoff;
+    const isFlipped =
+      flipThreshold !== 'off' &&
+      (Math.abs(wrap(raw[i]! - lastConfident)) > flipThreshold || Math.abs(wrap(raw[i]! - restDir)) > 90);
+    if (isShort || isFlipped) {
+      unconf[i] = true;
+    } else {
+      lastConfident = raw[i]!;
+    }
+  }
+  const out: ShortSpan[] = [];
+  for (let i = 0; i < n; i++) {
+    if (!unconf[i]) continue;
+    let j = i;
+    while (j + 1 < n && unconf[j + 1]) 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]!);
+    let maxTurn = 0;
+    for (let k = Math.max(1, i); k <= Math.min(n - 1, j + 1); k++) {
+      const jmp = wrap(raw[k]! - raw[k - 1]!);
+      if (Math.abs(jmp) > Math.abs(maxTurn)) maxTurn = jmp;
+    }
+    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));
+    }
+    const revThreshold = flipThreshold !== 'off' ? flipThreshold : 90;
+    out.push({
+      frames: [i, j],
+      minFraction,
+      across: true,
+      ...(Math.abs(maxTurn) > revThreshold ? { reversed: r3(maxTurn) } : {}),
+    });
+    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[] = [];
@@ -1951,24 +2078,26 @@ export function capShortSteps(
     }
     let segEnd = segStart;
     while (segEnd + 1 < n && covered?.[segEnd + 1] !== true) segEnd++;
-    if (segEnd - segStart >= 1) {
+    const loBound = Math.max(0, segStart - 1);
+    const hiBound = Math.min(n - 1, segEnd + 1);
+    if (hiBound - loBound >= 2) {
       const u: number[] = new Array<number>(n).fill(0);
-      u[segStart] = angles[segStart]!;
-      for (let i = segStart + 1; i <= segEnd; i++) u[i] = u[i - 1]! + wrap(angles[i]! - angles[i - 1]!);
+      u[loBound] = angles[loBound]!;
+      for (let i = loBound + 1; i <= hiBound; i++) u[i] = u[i - 1]! + wrap(angles[i]! - angles[i - 1]!);
       const fits = (lo: number, hi: number) => Math.abs(u[hi]! - u[lo]!) <= stepCap * (hi - lo);
       interface Win { lo: number; hi: number; asked: number }
       const wins: Win[] = [];
-      for (let k = segStart + 1; k <= segEnd; k++) {
+      for (let k = loBound + 1; k <= hiBound; k++) {
         if (!(Math.min(fraction[k - 1]!, fraction[k]!) < fractionCutoff)) continue;
         const jump = u[k]! - u[k - 1]!;
         if (Math.abs(jump) <= stepCap) continue;
         let h = 1;
-        let lo = Math.max(segStart, k - h - 1);
-        let hi = Math.min(segEnd, k + h);
-        while (!fits(lo, hi) && (lo > segStart || hi < segEnd)) {
+        let lo = Math.max(loBound, k - h - 1);
+        let hi = Math.min(hiBound, k + h);
+        while (!fits(lo, hi) && (lo > loBound || hi < hiBound)) {
           h++;
-          lo = Math.max(segStart, k - h - 1);
-          hi = Math.min(segEnd, k + h);
+          lo = Math.max(loBound, k - h - 1);
+          hi = Math.min(hiBound, k + h);
         }
         wins.push({ lo, hi, asked: jump });
       }
@@ -1985,9 +2114,9 @@ export function capShortSteps(
         }
         if (changed) continue;
         for (const w of wins) {
-          if (fits(w.lo, w.hi) || (w.lo === segStart && w.hi === segEnd)) continue;
-          w.lo = Math.max(segStart, w.lo - 1);
-          w.hi = Math.min(segEnd, w.hi + 1);
+          if (fits(w.lo, w.hi) || (w.lo === loBound && w.hi === hiBound)) continue;
+          w.lo = Math.max(loBound, w.lo - 1);
+          w.hi = Math.min(hiBound, w.hi + 1);
           changed = true;
         }
       }
@@ -2011,9 +2140,9 @@ export function capShortSteps(
 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 {
+export function shortLine(s: Short, times: readonly number[], cutoff: number | 'off'): string {
+  const sg = (v: number) => `${v >= 0 ? '+' : '−'}${Math.abs(v).toFixed(1)}°`;
   if (s.step !== undefined && s.asked !== undefined) {
-    const sg = (v: number) => `${v >= 0 ? '+' : '−'}${Math.abs(v).toFixed(1)}°`;
     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 ${SHORT_STEP_FRACTION.toFixed(2)}, turned ${sg(s.asked)} in one frame (over ${SHORT_STEP_CAP}°); spread to ${sg(s.step)} per frame`;
   }
   const lo = s.frames[0] - 1;
@@ -2023,6 +2152,12 @@ export function shortLine(s: Short, times: readonly number[], cutoff: number): s
     : 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`;
+  if (s.across === true) {
+    const shortWhy = cutoff !== 'off' && s.minFraction < cutoff ? `picture length down to ${s.minFraction.toFixed(2)} of its median, under ${cutoff}` : null;
+    const revWhy = s.reversed !== undefined ? `reversed ${sg(s.reversed)} in one frame` : null;
+    const why = shortWhy !== null && revWhy !== null ? `${shortWhy}, ${revWhy}` : shortWhy ?? `${revWhy ?? 'reversed'} (picture length down to ${s.minFraction.toFixed(2)} of its median)`;
+    return `chain "${s.chain}" bone "${s.bone}" (${s.joints[0]} → ${s.joints[1]}) ${spanOf(s.frames, times)}: ${why}; its direction is not read — ${held}`;
+  }
   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}`;
 }
 

package/src/run.ts

@@ -135,8 +135,8 @@ export function runRetarget(a: RetargetArgs, log: (line: string) => void): RunRe
     else if (a.plantFeet === true) say('  CAMERA none in the sequence: --plant-feet reads the picture as a fixed camera, so a zoom or a pan in the video moves the floor with it and the floor may step with the picture (tools/scan.py reads the camera, rig-c/pose#63)');
     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)}`);
+    for (const s of r.short) say(`  ${s.across === true ? 'HOLD  ' : 'SHORT '} ${shortLine(s, r.times, a.short)}`);
     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)}`);

package/src/switch.ts

@@ -322,6 +322,7 @@ function groupLayering(group: readonly AlternateSet[], map: JointMap, slots: Rig
     const setupSlots = hiddenSetup.filter((s) => slotChain.get(s) === cn && slots.get(s)?.bone !== torsoSlot);
     const setSlots = Object.keys(a.slots).filter((s) => slotChain.get(s) === cn && rank.has(s));
     if (setupSlots.length === 0 || setSlots.length === 0) return false;
+    if (setupSlots.every((s) => a.slots[s] !== undefined && a.slots[s] !== slots.get(s)?.setup)) return true;
     const boneSetup = setupSlots.filter((s) => boneOwner.has(slots.get(s)?.bone ?? ''));
     const refSetup = boneSetup.length > 0 ? boneSetup : setupSlots;
     return setupSlots.every((s) => a.hides.includes(s)) && Math.max(...setSlots.map((s) => rank.get(s)!)) < Math.min(...refSetup.map((s) => rank.get(s)!));
@@ -626,8 +627,9 @@ export function selectSwitches(map: JointMap, targets: ReadonlyMap<string, reado
       for (let i = sw.frames[0]; i <= sw.frames[1]; i++) row[i] = o;
     }
   }
-  // #136/#139/#162/#180: between two sets that draw an arm behind the base front setup (at least one behind the torso),
-  // a frame that belongs to neither set stays on the nearer set's layer (chosen by hand position when available, #180).
+  // #136/#139/#162/#180/#187: between two gesture sets, switch both arms on one frame t_switch
+  // where the measured path crosses halfway between their drawn poses without dropping to the base arm,
+  // and in a one-sided gesture set keep an arm whose wrist stays behind the torso on its previous behind set.
   const chainHolds: Array<{ set: string; chain: string; frames: [number, number] }> = [];
   for (const group of groups) {
     const layer = groupLayering(group, map, slots);
@@ -645,6 +647,56 @@ export function selectSwitches(map: JointMap, targets: ReadonlyMap<string, reado
       }
       cClamp.set(cn, arr);
     }
+    for (const s of layer.touched) {
+      if (!shown.has(s)) shown.set(s, Array.from({ length: n }, () => slots.get(s)!.setup));
+    }
+    // #187 Rule 3: in a one-sided gesture set (one chain raised with drawn > 0 while another chain has all
+    // bones drawn < 0 within switchTolerance of the preceding behind-the-torso set), an arm whose wrist the
+    // scan places behind the torso keeps its previous behind-the-torso set and angles.
+    const heldBehindOnSwitch = new Map<number, Set<string>>();
+    for (let idx = 1; idx < gSwitches.length; idx++) {
+      const sw = gSwitches[idx]!;
+      const prevSw = gSwitches[idx - 1]!;
+      const set = group.find((a) => a.name === sw.set)!;
+      const prevSet = group.find((a) => a.name === prevSw.set)!;
+      if (!layer.isBehind(prevSet) || set === prevSet || set.chains.length < 2) continue;
+      const hasUpChain = set.chains.some((cn) => {
+        const c = map.chains.find((x) => x.name === cn);
+        return c !== undefined && c.bones.some((b) => (set.drawn[b] ?? -180) > 0);
+      });
+      if (!hasUpChain) continue;
+      for (const cn of set.chains) {
+        const c = map.chains.find((x) => x.name === cn);
+        if (c === undefined) continue;
+        const allDown = c.bones.every((b) => (set.drawn[b] ?? 0) < 0);
+        if (!allDown) continue;
+        const keyNearPrev =
+          c.bones.every((b) => set.drawn[b] !== undefined && prevSet.drawn[b] !== undefined) &&
+          c.bones.reduce((s, b) => s + Math.abs(wrap(set.drawn[b]! - prevSet.drawn[b]!)), 0) / c.bones.length <= opts.switchTolerance;
+        if (!keyNearPrev) continue;
+        const ho = opts.handOffsets?.get(cn);
+        if (ho === undefined) continue;
+        const slice = ho.slice(sw.frames[0], sw.frames[1] + 1);
+        const medDy = median(slice.map((p) => p[1]));
+        const medDx = median(slice.map((p) => p[0]));
+        const isRight = /(?:^|_)r(?:_|$)/.test(cn);
+        const inward = isRight ? medDx >= -0.05 : medDx <= 0.05;
+        if (!(medDy > 0.5 && inward)) continue;
+        let setHeld = heldBehindOnSwitch.get(idx);
+        if (setHeld === undefined) {
+          setHeld = new Set();
+          heldBehindOnSwitch.set(idx, setHeld);
+        }
+        setHeld.add(cn);
+        const cArr = cClamp.get(cn)!;
+        for (let i = sw.frames[0]; i <= sw.frames[1]; i++) {
+          cArr[i] = prevSet;
+          for (const [s, sc] of layer.slotChain) {
+            if (sc === cn && shown.has(s)) shown.get(s)![i] = prevSet.slots[s] ?? null;
+          }
+        }
+      }
+    }
     for (let m = 0; m + 1 < gSwitches.length; m++) {
       const sw0 = gSwitches[m]!;
       const sw1 = gSwitches[m + 1]!;
@@ -656,6 +708,14 @@ export function selectSwitches(map: JointMap, targets: ReadonlyMap<string, reado
       if (g0 > g1) continue;
       const chains = [...new Set([...set0.chains, ...set1.chains])].filter((cn) => layer.isChainBehindBase(set0, cn) && layer.isChainBehindBase(set1, cn));
       if (chains.length === 0) continue;
+      const heldOn0 = heldBehindOnSwitch.get(m);
+      const heldOn1 = heldBehindOnSwitch.get(m + 1);
+      const heldSetFor = (cn: string): AlternateSet | null => {
+        if (heldOn1?.has(cn)) return set0;
+        if (heldOn0?.has(cn) && m > 0 && set1 === group.find((a) => a.name === gSwitches[m - 1]!.set)) return set1;
+        return null;
+      };
+      const switchingChains = chains.filter((cn) => heldSetFor(cn) === null);
       for (const cn of chains) {
         if (!layer.isBehind(set0)) for (let i = sw0.frames[0]; i <= sw0.frames[1]; i++) cClamp.get(cn)![i] = set0;
         if (!layer.isBehind(set1)) for (let i = sw1.frames[0]; i <= sw1.frames[1]; i++) cClamp.get(cn)![i] = set1;
@@ -673,11 +733,29 @@ export function selectSwitches(map: JointMap, targets: ReadonlyMap<string, reado
         }
         return d0 <= d1 ? set0 : set1;
       };
+      const rawChainMax = (a: AlternateSet, cn: string, i: number): number => {
+        const c = map.chains.find((x) => x.name === cn);
+        if (c === undefined) return Infinity;
+        return Math.max(...c.bones.map((b) => (a.drawn[b] !== undefined ? Math.abs(wrap(targets.get(b)![i]! - a.drawn[b]!)) : 0)));
+      };
+      const isTightSet = (a: AlternateSet, cn: string): boolean => {
+        const c = map.chains.find((x) => x.name === cn);
+        return c !== undefined && c.bones.some((b) => a.turn[b] !== undefined && a.turn[b]![1] - a.turn[b]![0] <= 10);
+      };
       const cPick = new Map<string, Array<AlternateSet | null>>();
       for (const cn of chains) {
+        const heldSet = heldSetFor(cn);
         const arr: Array<AlternateSet | null> = Array.from({ length: n }, () => null);
-        for (let i = sw0.frames[0]; i <= sw0.frames[1]; i++) arr[i] = set0;
-        for (let i = sw1.frames[0]; i <= sw1.frames[1]; i++) arr[i] = set1;
+        for (let i = sw0.frames[0]; i <= sw0.frames[1]; i++) arr[i] = heldSet ?? set0;
+        for (let i = sw1.frames[0]; i <= sw1.frames[1]; i++) arr[i] = heldSet ?? set1;
+        if (heldSet !== null) {
+          for (let i = g0; i <= g1; i++) {
+            arr[i] = heldSet;
+            cClamp.get(cn)![i] = heldSet;
+          }
+          cPick.set(cn, arr);
+          continue;
+        }
         const d0s = byChain.get(set0.name)?.get(cn);
         const d1s = byChain.get(set1.name)?.get(cn);
         for (let i = g0; i <= g1; i++) {
@@ -706,24 +784,142 @@ export function selectSwitches(map: JointMap, targets: ReadonlyMap<string, reado
           }
           i = j + 1;
         }
-        for (let i = g0; i <= g1; i++) {
-          if (arr[i] !== null) cClamp.get(cn)![i] = arr[i]!;
+        const tight0 = isTightSet(set0, cn);
+        const tight1 = isTightSet(set1, cn);
+        if (tight0 && set0 !== set1) {
+          let i = g0;
+          while (i <= g1 && rawChainMax(set0, cn, i) <= opts.switchTolerance + hyst) {
+            cClamp.get(cn)![i] = set0;
+            i++;
+          }
+        }
+        if (tight1 && set0 !== set1) {
+          let enter1 = g1 + 1;
+          for (let i = g0; i <= g1; i++) {
+            if (rawChainMax(set1, cn, i) <= opts.switchTolerance) {
+              enter1 = i;
+              break;
+            }
+          }
+          for (let i = enter1; i <= g1; i++) cClamp.get(cn)![i] = set1;
+        }
+        if (!tight0 && !tight1) {
+          for (let i = g0; i <= g1; i++) {
+            if (arr[i] !== null) cClamp.get(cn)![i] = arr[i]!;
+          }
+        }
+        if (!tight0 && set0 !== set1) {
+          const c = map.chains.find((x) => x.name === cn);
+          if (c !== undefined) {
+            let k = sw0.frames[1];
+            while (
+              k >= sw0.frames[0] &&
+              c.bones.some((b) => {
+                const lim = set0.turn[b];
+                const dr = set0.drawn[b];
+                const ndr = set1.drawn[b];
+                if (lim === undefined || dr === undefined || ndr === undefined) return false;
+                const t = wrap(targets.get(b)![k]! - dr);
+                return overflow(t, lim) > RANGE_SLACK && Math.abs(wrap(targets.get(b)![k + 1]! - ndr)) < Math.abs(wrap(targets.get(b)![k]! - ndr));
+              })
+            ) {
+              cClamp.get(cn)![k] = null;
+              k--;
+            }
+          }
         }
         cPick.set(cn, arr);
       }
-      const anyHeldBehind = chains.some((cn) => {
+      // #187 Rule 1 & Rule 2: when two gesture sets are adjacent (gap <= 10 frames, or the arm is moving
+      // toward the next set's pose), unwrap any bone that turned the long way (> 180° through inverted angles)
+      // onto the short arc and pick one shared switch frame t_switch where the measured path crosses halfway
+      // between set0.drawn and set1.drawn.
+      const movingTowardNext =
+        set0 !== set1 &&
+        distances.get(set1.name)![g1]! < distances.get(set1.name)![g0]! &&
+        distances.get(set0.name)![g1]! > distances.get(set0.name)![g0]!;
+      const bridgeDirect = set0 !== set1 && (g1 - g0 + 1 <= 10 || movingTowardNext);
+      let tSwitch = g1 + 1;
+      if (bridgeDirect && switchingChains.length > 0) {
+        const swBones = switchingChains.flatMap((cn) => map.chains.find((c) => c.name === cn)?.bones ?? []);
+        for (const b of swBones) {
+          const tg = targets.get(b) as number[] | undefined;
+          const d0 = set0.drawn[b];
+          const d1 = set1.drawn[b];
+          if (tg === undefined || d0 === undefined || d1 === undefined) continue;
+          const i0 = sw0.frames[1];
+          const i1 = sw1.frames[0];
+          const startA = tg[i0]!;
+          const endA = tg[i1]!;
+          const unwrapped: number[] = [startA];
+          for (let i = i0 + 1; i <= i1; i++) {
+            unwrapped.push(unwrapped[unwrapped.length - 1]! + wrap(tg[i]! - tg[i - 1]!));
+          }
+          const totalTurn = unwrapped[unwrapped.length - 1]! - startA;
+          const shortTurn = wrap(endA - startA);
+          const invertsBetween = Array.from({ length: g1 - g0 + 1 }, (_, k) => {
+            const a = tg[g0 + k]!;
+            return Math.abs(wrap(a - d0)) > 90 && Math.abs(wrap(a - d1)) > 90;
+          }).some(Boolean);
+          if (Math.abs(totalTurn) > 180 && Math.abs(totalTurn - shortTurn) > 1e-6 && invertsBetween && Math.abs(shortTurn) <= 150) {
+            for (let i = g0; i <= g1; i++) {
+              const p = (unwrapped[i - i0]! - startA) / totalTurn;
+              tg[i] = wrap(startA + p * shortTurn);
+            }
+          }
+        }
+        let clampEnd0 = g0 - 1;
+        while (clampEnd0 + 1 <= g1 && switchingChains.every((cn) => cClamp.get(cn)![clampEnd0 + 1] === set0)) {
+          clampEnd0++;
+        }
+        const effAngle = (b: string, i: number): number => {
+          const raw = targets.get(b)![i]!;
+          if (clampEnd0 >= g0 && i > clampEnd0) {
+            const frac = opts.shortInfo?.fractions.get(b)?.[i] ?? 1;
+            const d0 = set0.drawn[b];
+            const d1 = set1.drawn[b];
+            if (frac < 0.6 && d0 !== undefined && d1 !== undefined) {
+              const steps = g1 + 1 - clampEnd0;
+              return wrap(d0 + ((i - clampEnd0) / steps) * wrap(d1 - d0));
+            }
+          }
+          return raw;
+        };
+        const pairs = swBones.filter((b) => set0.drawn[b] !== undefined && set1.drawn[b] !== undefined);
+        const span = pairs.length > 0
+          ? pairs.reduce((s, b) => s + Math.abs(wrap(set1.drawn[b]! - set0.drawn[b]!)), 0) / pairs.length
+          : 0;
+        for (let i = Math.max(g0, clampEnd0 + 1); i <= g1; i++) {
+          const d0 = pairs.length > 0
+            ? pairs.reduce((s, b) => s + Math.abs(wrap(effAngle(b, i) - set0.drawn[b]!)), 0) / pairs.length
+            : (distances.get(set0.name)?.[i] ?? Infinity);
+          const d1 = pairs.length > 0
+            ? pairs.reduce((s, b) => s + Math.abs(wrap(effAngle(b, i) - set1.drawn[b]!)), 0) / pairs.length
+            : (distances.get(set1.name)?.[i] ?? Infinity);
+          if (d1 <= d0 || (span > 1e-6 && d0 >= 0.5 * span)) {
+            tSwitch = i;
+            break;
+          }
+        }
+      }
+      const anyHeldBehind = switchingChains.some((cn) => {
         const arr = cPick.get(cn)!;
         for (let i = g0; i <= g1; i++) if (arr[i] === null) return false;
         return true;
       });
-      if (!anyHeldBehind && set0 !== set1) {
-        const frontNear = group.filter((a) => layer.isFront(a)).some((a) => {
+      if (!anyHeldBehind) {
+        const frontNear = group.filter((a) => layer.isFront(a) && a !== set0 && a !== set1).some((a) => {
           for (let i = g0; i <= g1; i++) if (distances.get(a.name)![i]! <= opts.switchTolerance) return true;
           return false;
         });
-        if (!frontNear) for (const cn of chains) for (let i = g0; i <= g1; i++) cPick.get(cn)![i] = set0;
+        if (bridgeDirect) {
+          for (const cn of switchingChains) {
+            for (let i = g0; i <= g1; i++) cPick.get(cn)![i] = i < tSwitch ? set0 : set1;
+          }
+        } else if (!frontNear) for (const cn of chains) for (let i = g0; i <= g1; i++) cPick.get(cn)![i] = set0;
       } else {
         for (const cn of chains) {
+          if (heldSetFor(cn) !== null) continue;
           const arr = cPick.get(cn)!;
           const frontSets = group.filter((a) => layer.isFront(a) && a.chains.includes(cn) && a !== set0 && a !== set1);
           const d0s = byChain.get(set0.name)?.get(cn);
@@ -771,21 +967,20 @@ export function selectSwitches(map: JointMap, targets: ReadonlyMap<string, reado
             }
             i = j + 1;
           }
-          for (let i = g0; i <= g1; i++) {
-            if (arr[i] !== null) cClamp.get(cn)![i] = arr[i]!;
+        }
+        if (bridgeDirect) {
+          for (const cn of switchingChains) {
+            for (let i = g0; i <= g1; i++) cPick.get(cn)![i] = i < tSwitch ? set0 : set1;
           }
         }
       }
-      for (const s of layer.touched) {
-        if (!shown.has(s)) shown.set(s, Array.from({ length: n }, () => slots.get(s)!.setup));
-      }
       for (let i = g0; i <= g1; i++) {
         for (const [s, cn] of layer.slotChain) {
           const a = cPick.get(cn)?.[i] ?? null;
           if (a !== null) shown.get(s)![i] = a.slots[s] ?? null;
         }
-        if (layer.torsoSlot !== null && shown.has(layer.torsoSlot) && layer.isBehind(set0) && layer.isBehind(set1)) {
-          const picked = chains.map((cn) => cPick.get(cn)![i]);
+        if (layer.torsoSlot !== null && shown.has(layer.torsoSlot)) {
+          const picked = (switchingChains.length > 0 ? switchingChains : chains).map((cn) => cPick.get(cn)![i]);
           if (picked.every((a) => a !== null)) shown.get(layer.torsoSlot)![i] = picked[0]!.slots[layer.torsoSlot] ?? slots.get(layer.torsoSlot)!.setup;
         }
       }
@@ -834,8 +1029,10 @@ export function selectSwitches(map: JointMap, targets: ReadonlyMap<string, reado
 /** Per chain, the frames on which a switch of a set depicting it shows: its art was painted for that pose. */
 export function coveredChains(switches: readonly Switch[], n: number, chainHolds?: ReadonlyArray<{ set: string; chain: string; frames: [number, number] }>): Map<string, boolean[]> {
   const out = new Map<string, boolean[]>();
+  const held = new Set((chainHolds ?? []).map((h) => `${h.set}:${h.chain}`));
   for (const sw of switches) {
     for (const c of sw.chains) {
+      if (held.has(`${sw.set}:${c}`)) continue;
       if (!out.has(c)) out.set(c, Array.from({ length: n }, () => false));
       const row = out.get(c)!;
       for (let i = sw.frames[0]; i <= sw.frames[1]; i++) row[i] = true;
@@ -1017,7 +1214,7 @@ export const ART_EASE_STEP = 3;
 export function clampArt(switches: readonly Switch[], map: JointMap, targets: Map<string, number[]>, chainHolds?: ReadonlyArray<{ set: string; chain: string; frames: [number, number] }>): void {
   const boneChain = new Map<string, string>();
   for (const c of map.chains) for (const b of c.bones) boneChain.set(b, c.name);
-  const clampSpan = (set: AlternateSet, bone: string, [a, b]: [number, number]) => {
+  const clampSpan = (set: AlternateSet, bone: string, [a, b0]: [number, number]) => {
     const limits = set.turn[bone];
     if (limits === undefined) return;
     const drawn = set.drawn[bone]!;
@@ -1028,12 +1225,29 @@ export function clampArt(switches: readonly Switch[], map: JointMap, targets: Ma
       const c = Math.min(Math.max(t, limits[0]), limits[1]);
       return Math.abs(c - t) > RANGE_SLACK ? c - t : 0;
     };
+    const tightHold = limits[1] - limits[0] <= 10;
+    let b = b0;
+    let trimmedExit = false;
+    if (!tightHold && b + 1 < n && delta(b) !== 0) {
+      const nextSw = switches.find((s) => s.frames[0] > b && s.frames[0] - b <= 10 && s.set !== set.name);
+      const nextDrawn = nextSw !== undefined ? map.alternates.find((x) => x.name === nextSw.set)?.drawn[bone] : undefined;
+      if (nextDrawn !== undefined) {
+        const distNext = (i: number) => Math.abs(wrap(target[i]! - nextDrawn));
+        if (distNext(b + 1) < distNext(b)) {
+          while (b >= a && delta(b) !== 0 && (b === a || distNext(b) < distNext(b - 1))) {
+            b--;
+            trimmedExit = true;
+          }
+        }
+      }
+    }
+    if (a > b) return;
     const da = delta(a);
     const db = delta(b);
-    const easeIn = a > 0 && da !== 0 && Math.sign(delta(a - 1)) === Math.sign(da)
+    const easeIn = a > 0 && da !== 0 && Math.sign(delta(a - 1)) === Math.sign(da) && !tightHold
       ? Math.max(ART_EASE_FRAMES, Math.ceil(Math.abs(da) / ART_EASE_STEP) - 1)
       : 0;
-    const easeOut = b + 1 < n && db !== 0 && Math.sign(delta(b + 1)) === Math.sign(db)
+    const easeOut = b + 1 < n && db !== 0 && Math.sign(delta(b + 1)) === Math.sign(db) && !tightHold && !trimmedExit
       ? Math.max(ART_EASE_FRAMES, Math.ceil(Math.abs(db) / ART_EASE_STEP) - 1)
       : 0;
     for (let i = a; i <= b; i++) {