@rig-c/pose 0.24.1 → 0.26.0

package/README.md

@@ -349,10 +349,12 @@ Bone rotation cannot carry every pose: an arm behind the head, a forearm toward
 
 - `slots`: what each slot of the set shows while it shows; each attachment must be in that slot under some skin of the rig, as rig-c built it. `hides`: the slots that are empty while it shows. A slot's place in the draw order is the rig's own, so a drawing that must sit in front of the torso is an attachment in a slot that is: a switch is attachment keys only, and no draw-order key is written.
 - `chains`: the map's chains whose pose the set depicts; it is selected by them. `pose`: the key skeleton the art was painted from, body-18 (or `mid_hip`/`mid_shoulder`) in picture px, y down, any scale and place — only its directions are read; every joint the listed chains use must be in it.
-- `drawn` (optional): each bone's world angle (Spine degrees) as painted. It changes no key: while a set shows, a bone is keyed to the pose as always, and the art turns with it. What it gives is a figure: the art turn, how far each bone is from the angle its art was painted at (`artTurn`, and `ART-RANGE` past the bone's range).
+- `drawn` (optional): each bone's world angle (Spine degrees) as painted. It changes no key unless the set declares `symmetric` or `support` ([below](#alternate-drawings-alternates)): otherwise, while a set shows, a bone is keyed to the pose as always, and the art turns with it. What it gives is a figure: the art turn, how far each bone is from the angle its art was painted at (`artTurn`, and `ART-RANGE` past the bone's range).
 - `offsets` (optional): a translate per bone, in its parent's axes, held while the set shows and 0 elsewhere (stepped keys), so the joints as painted are the pivots. A bone `translate` already keys (the hip) cannot take one.
 - `place` (optional): `"by-hip"` places a hand that meets the body by its offset from the hip ([below](#alternate-drawings-alternates)).
-- Each name resolves against the built rig and the map, and a miss is refused by name, listing what exists: `MAP_ALT_SLOT`, `MAP_ALT_ATTACHMENT`, `MAP_ALT_HIDES`, `MAP_ALT_CHAIN`, `MAP_ALT_JOINT`, `MAP_ALT_POSE`, `MAP_ALT_DRAWN`, `MAP_ALT_OFFSET` (a bone that is not a bone of the set's chains) and `MAP_ALT_PLACE`.
+- `symmetric` (optional, [#188](https://github.com/rig-c/pose/issues/188)): `true` normalises a two-arm symmetric gesture set (such as hands behind the head) to its `drawn` symmetry centre so both elbows sit at the same world height and neither wrist extends past the head silhouette ([below](#alternate-drawings-alternates)). Requires two 2-bone chains with `drawn` angles on all four bones (`MAP_ALT_SYMMETRIC`).
+- `support` (optional, [#188](https://github.com/rig-c/pose/issues/188)): a chain name or non-empty list of chain names of the set (`"support": "arm_l"` or `["arm_l"]`) whose bones carry a stationary support arm (such as a waist-resting hand while the other arm gestures); while the set shows, each support chain's bones anchor to `drawn` within `±2.5°` (`≤ ±3°`) of the pose's delta relative to the set's reference pose, and an unplaced active raised arm in the same set clears the head/bun outward along the 2D shoulder→wrist direction (`MAP_ALT_SUPPORT`).
+- Each name resolves against the built rig and the map, and a miss is refused by name, listing what exists: `MAP_ALT_SLOT`, `MAP_ALT_ATTACHMENT`, `MAP_ALT_HIDES`, `MAP_ALT_CHAIN`, `MAP_ALT_JOINT`, `MAP_ALT_POSE`, `MAP_ALT_DRAWN`, `MAP_ALT_OFFSET` (a bone that is not a bone of the set's chains), `MAP_ALT_PLACE`, `MAP_ALT_SYMMETRIC` and `MAP_ALT_SUPPORT`.
 
 **When one shows.** Per frame and per set, the distance is the largest difference, in degrees, between a segment of its chains as the retarget asked for it (after holds, the short hold, the flip guard and the hinge check; before any range clamp) and the same segment in its key skeleton, with a foreshortened segment (`SHORT`) weighted at `0.5 ×` (`SHORT_SWITCH_WEIGHT`, [#180](https://github.com/rig-c/pose/issues/180)). On each frame the nearest set within `--switch-tolerance` (default 25°) shows, ties going to the map's order; once entered, a set stays active until its distance exceeds `--switch-tolerance + 15°` (`SWITCH_LEAVE_HYSTERESIS`, [#180](https://github.com/rig-c/pose/issues/180)) for at least `--switch-min` (default 0.25 s) or a competing set with a lower distance enters within `--switch-tolerance`; a run of one set shorter than `--switch-min` is dropped and the base art shows there. Sets compete only with those they share a slot (shown or hidden) or an offset bone with, so a drawing of each arm can show at once; two that compete never overlap.
 

package/package.json

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

@@ -100,6 +100,10 @@ export interface AlternateSet {
   frames: Array<[number, number]> | null;
   /** `place: "by-hip"` (rig-c/pose#93): the chains whose wrist `pose` puts within one hip width of the mid-hip, their wrists placed by the offset from the hip while the set shows. Absent or null: the pose's angles. */
   place?: { by: 'hip'; chains: string[] } | null;
+  /** `symmetric: true` (rig-c/pose#188): normalise the set's two two-bone arm chains to the drawn symmetry centre and keep their wrists inside the head silhouette while the set shows. */
+  symmetric?: boolean;
+  /** `support` (rig-c/pose#188): the set's chains whose bones anchor to the set's `drawn` local angles while the non-support chains track the active gesture. */
+  support?: string[];
 }
 export interface YawSet {
   set: string;
@@ -435,7 +439,7 @@ function readAlternates(p: Problems, where: string, raw: unknown, chains: readon
       p.add('MAP_ALT_SHAPE', `${aw} is ${typeName(a)}; a set is ${SET_SHAPE}`);
       return;
     }
-    refuseUnknownKeys(p, 'MAP_KEYS', aw, a, ['name', 'note', 'slots', 'hides', 'chains', 'pose', 'drawn', 'offsets', 'turn', 'frames', 'place']);
+    refuseUnknownKeys(p, 'MAP_KEYS', aw, a, ['name', 'note', 'slots', 'hides', 'chains', 'pose', 'drawn', 'offsets', 'turn', 'frames', 'place', 'symmetric', 'support']);
     const name = typeof a.name === 'string' && a.name !== '' ? a.name : null;
     if (name === null) p.add('MAP_ALT_NAME', `${aw} "name" is ${typeName(a.name)}; it must be a non-empty string`);
     else if (names.has(name)) p.add('MAP_ALT_NAME', `${aw} "name" "${name}" names two sets`);
@@ -553,7 +557,52 @@ function readAlternates(p: Problems, where: string, raw: unknown, chains: readon
         else place = { by: 'hip', chains: by.chains };
       }
     }
-    if (ok && name !== null && cs !== null) out.push({ name, slots, hides, chains: cs, pose, drawn, offsets, turn, frames, ...(place === null ? {} : { place }) });
+    let symmetric: boolean | undefined;
+    if ('symmetric' in a) {
+      if (a.symmetric !== true) {
+        p.add('MAP_ALT_SYMMETRIC', `${label} "symmetric" is ${JSON.stringify(a.symmetric)}; it must be true`);
+        ok = false;
+      } else if (own.length !== 2 || !own.every((c) => c.bones.length === 2)) {
+        p.add('MAP_ALT_SYMMETRIC', `${label} "symmetric" is true, and its chains are ${ownList}; a symmetric set normalises a pair of two-bone arm chains`);
+        ok = false;
+      } else {
+        const missing = ownBones.filter((b) => !(b in drawn));
+        if (missing.length > 0) {
+          p.add('MAP_ALT_SYMMETRIC', `${label} "symmetric" is true, and "drawn" has no ${missing.map((b) => `"${b}"`).join(', ')}; a symmetric set normalises both chains around their drawn angles`);
+          ok = false;
+        } else symmetric = true;
+      }
+    }
+    let support: string[] | undefined;
+    if ('support' in a) {
+      const sup = typeof a.support === 'string' && a.support !== '' ? [a.support] : strings(a.support);
+      if (sup === null || sup.length === 0 || sup.some((s) => s === '')) {
+        p.add('MAP_ALT_SUPPORT', `${label} "support" is ${JSON.stringify(a.support)}; it must name one or more of the set's chains (${(cs ?? []).join(', ') || 'none'})`);
+        ok = false;
+      } else {
+        if (new Set(sup).size !== sup.length) {
+          p.add('MAP_ALT_SUPPORT', `${label} "support" names a chain twice: ${sup.join(', ')}`);
+          ok = false;
+        }
+        const outside = sup.filter((c) => !(cs ?? []).includes(c));
+        if (outside.length > 0) {
+          p.add('MAP_ALT_SUPPORT', `${label} "support" names chain ${outside.map((c) => `"${c}"`).join(', ')}, which is not in the set's chains (${(cs ?? []).join(', ') || 'none'})`);
+          ok = false;
+        }
+        if (a.symmetric === true) {
+          p.add('MAP_ALT_SUPPORT', `${label} names both "symmetric" and "support"; a set either normalises both arms symmetrically or anchors a support arm`);
+          ok = false;
+        }
+        const supBones = own.filter((c) => sup.includes(c.name)).flatMap((c) => c.bones);
+        const missing = supBones.filter((b) => !(b in drawn));
+        if (missing.length > 0) {
+          p.add('MAP_ALT_SUPPORT', `${label} "support" chain has no "drawn" angle for ${missing.map((b) => `"${b}"`).join(', ')}; a support chain anchors to its drawn angles`);
+          ok = false;
+        }
+        if (ok) support = sup;
+      }
+    }
+    if (ok && name !== null && cs !== null) out.push({ name, slots, hides, chains: cs, pose, drawn, offsets, turn, frames, ...(place === null ? {} : { place }), ...(symmetric === undefined ? {} : { symmetric }), ...(support === undefined ? {} : { support }) });
   });
   return out;
 }

package/src/retarget.ts

@@ -1157,6 +1157,7 @@ export function retarget(rest: Rest, map: JointMap, frames: ReadonlyArray<Partia
       handOffsets.set(c.name, arr);
     }
   }
+  const rawTargets = new Map<string, number[]>([...targets].map(([b, arr]) => [b, [...arr]]));
   const sw = selectSwitches(map, targets, keyTimes, keyTimes[n - 1]!, slots, { ...opts, shortInfo, handOffsets });
 
   // The range clamp, outside the spans of a set depicting the bone's chain. Parents
@@ -1326,6 +1327,236 @@ export function retarget(rest: Rest, map: JointMap, frames: ReadonlyArray<Partia
   const raisedJobs: Array<{ anchor: Anchor; sw: Switch; chain: Chain; wrist: (i: number) => Pt; before: Pt[]; reference: Pt[]; placed: Pt[]; refEye: number; rigEye: number; short: Array<{ i: number; how: 'far' | 'near' | 'missed'; shortfall: number }>; upperHeld: number[]; l0: number; l1: number; farthest: number }> = [];
   const headOk: Anchor | null = head !== null && !('problem' in head) ? { kind: 'head', joints: head.joints, points: head.points } : null;
   const hipsOk: Anchor | null = hips !== null && !('problem' in hips) ? { kind: 'hip', joints: hips.joints, points: hips.points } : null;
+  const fallbackHead = headOf(map);
+  const gestureHead: Anchor | null = headOk ?? (!('problem' in fallbackHead) ? { kind: 'head', joints: fallbackHead.joints, points: fallbackHead.points } : null);
+  /**
+   * #188: For an active raised chain in a set that declares a `support` arm, compute the
+   * outward-cleared world angles `[a0, a1]` on frame `i` from the scan's 2D shoulder→wrist
+   * direction and the head/bun clearance.
+   */
+  const solveSupportActiveFrame = (set: (typeof map.alternates)[number], c: Chain, i: number): [number, number] | null => {
+    if (c.bones.length < 2 || c.joints.length < 3) return null;
+    const [b0, b1] = c.bones as [string, string];
+    const drawn0 = set.drawn[b0];
+    const drawn1 = set.drawn[b1];
+    if (drawn0 === undefined || drawn1 === undefined || !isRaised(drawn0)) return null;
+    const S0 = rigPoint(rest, b0);
+    const E0 = rigPoint(rest, b1);
+    const wSpec = c.aim[1] === 'x' ? `${b1}:tip` : c.aim[1]!;
+    const W0 = rigPoint(rest, wSpec);
+    if (S0 === null || E0 === null || W0 === null) return null;
+    const l0 = Math.hypot(E0[0] - S0[0], E0[1] - S0[1]);
+    const l1 = Math.hypot(W0[0] - E0[0], W0[1] - E0[1]);
+    let rigEye0 = 0.32 * l0;
+    let headX0 = 0;
+    if (gestureHead !== null) {
+      const ha0 = rigPoint(rest, gestureHead.points[0]);
+      const hb0 = rigPoint(rest, gestureHead.points[1]);
+      if (ha0 !== null && hb0 !== null) {
+        const d = Math.hypot(hb0[0] - ha0[0], hb0[1] - ha0[1]);
+        if (d > 1e-6) {
+          rigEye0 = d;
+          headX0 = (ha0[0] + hb0[0]) / 2;
+        }
+      }
+    }
+    const Ex = S0[0] + l0 * Math.cos(drawn0 / DEG);
+    const outSign: 1 | -1 = Ex <= headX0 ? 1 : -1;
+    const clear0 = Math.asin(Math.min(1, (0.55 * rigEye0) / Math.max(1e-6, l0))) * DEG;
+    const clear1 = Math.asin(Math.min(1, (0.90 * rigEye0) / Math.max(1e-6, l1))) * DEG;
+    let swMod = 0;
+    const j0 = c.joints[0]!;
+    const jLast = c.joints[c.joints.length - 1]!;
+    const kp0 = set.pose[j0];
+    const kpLast = set.pose[jLast];
+    const shS = series.get(j0);
+    const wrS = series.get(jLast);
+    if (kp0 !== undefined && kpLast !== undefined && shS !== undefined && wrS !== undefined) {
+      const keySW = pictureAngle(kp0, kpLast);
+      const scanSW = pictureAngle(shS[i]!, wrS[i]!);
+      swMod = Math.max(0, Math.min(6, outSign * wrap(scanSW - keySW)));
+    }
+    const lim0 = set.turn[b0];
+    const lim1 = set.turn[b1];
+    const off0 = outSign * (clear0 + 0.5 * swMod);
+    const off1 = outSign * (clear1 + 0.5 * swMod);
+    const cl0 = lim0 !== undefined ? Math.min(Math.max(off0, lim0[0]), lim0[1]) : off0;
+    const cl1 = lim1 !== undefined ? Math.min(Math.max(off1, lim1[0]), lim1[1]) : off1;
+    return [wrap(drawn0 + cl0), wrap(drawn1 + cl1)];
+  };
+  /**
+   * #188: For a support chain in `set.support`, anchor its bones on frame `i` to `set.drawn`
+   * within a ±2.5° (≤ ±3°) breathing tolerance from the pose's delta relative to the set's
+   * reference pose.
+   */
+  const solveSupportChainFrame = (set: (typeof map.alternates)[number], c: Chain, i: number): void => {
+    for (let k = 0; k < c.bones.length; k++) {
+      const b = c.bones[k]!;
+      const dr = set.drawn[b];
+      if (dr === undefined) continue;
+      const kp0 = c.joints[k] !== undefined ? set.pose[c.joints[k]!] : undefined;
+      const kp1 = c.joints[k + 1] !== undefined ? set.pose[c.joints[k + 1]!] : undefined;
+      const keyAng = kp0 !== undefined && kp1 !== undefined ? pictureAngle(kp0, kp1) : dr;
+      const raw = rawTargets.get(b)?.[i] ?? keyAng;
+      const diff = Math.max(-2.5, Math.min(2.5, 0.1 * wrap(raw - keyAng)));
+      targets.get(b)![i] = wrap(dr + diff);
+    }
+  };
+  /**
+   * #188: For a `set.symmetric === true` gesture set, normalise its two two-bone arm chains
+   * on frame `i` to the set's `drawn` symmetry centre so `|elbow_l.y - elbow_r.y| == 0` and
+   * clamp both forearms so the wrists stay inside the head silhouette.
+   */
+  const solveSymmetricFrame = (set: (typeof map.alternates)[number], i: number): { cR: Chain; cL: Chain; wR: Pt; wL: Pt; hc: Pt; ed: number } | null => {
+    if (set.chains.length !== 2) return null;
+    const c0 = map.chains.find((x) => x.name === set.chains[0]!);
+    const c1 = map.chains.find((x) => x.name === set.chains[1]!);
+    if (c0 === undefined || c1 === undefined || c0.bones.length !== 2 || c1.bones.length !== 2) return null;
+    const S0_0 = rigPoint(rest, c0.bones[0]!);
+    const S0_1 = rigPoint(rest, c1.bones[0]!);
+    if (S0_0 === null || S0_1 === null) return null;
+    const [cR, cL] = S0_0[0] <= S0_1[0] ? [c0, c1] : [c1, c0];
+    const [bR0, bR1] = cR.bones as [string, string];
+    const [bL0, bL1] = cL.bones as [string, string];
+    const wSpecR = cR.aim[1] === 'x' ? `${bR1}:tip` : cR.aim[1]!;
+    const wSpecL = cL.aim[1] === 'x' ? `${bL1}:tip` : cL.aim[1]!;
+    const SR0 = rigPoint(rest, bR0)!;
+    const ER0 = rigPoint(rest, bR1)!;
+    const WR0 = rigPoint(rest, wSpecR)!;
+    const SL0 = rigPoint(rest, bL0)!;
+    const EL0 = rigPoint(rest, bL1)!;
+    const WL0 = rigPoint(rest, wSpecL)!;
+    const lR0 = Math.hypot(ER0[0] - SR0[0], ER0[1] - SR0[1]);
+    const lR1 = Math.hypot(WR0[0] - ER0[0], WR0[1] - ER0[1]);
+    const lL0 = Math.hypot(EL0[0] - SL0[0], EL0[1] - SL0[1]);
+    const lL1 = Math.hypot(WL0[0] - EL0[0], WL0[1] - EL0[1]);
+    const dR0 = wrap(Math.atan2(ER0[1] - SR0[1], ER0[0] - SR0[0]) * DEG - restOf.get(bR0)!);
+    const dR1 = wrap(Math.atan2(WR0[1] - ER0[1], WR0[0] - ER0[0]) * DEG - restOf.get(bR1)!);
+    const dL0 = wrap(Math.atan2(EL0[1] - SL0[1], EL0[0] - SL0[0]) * DEG - restOf.get(bL0)!);
+    const dL1 = wrap(Math.atan2(WL0[1] - EL0[1], WL0[0] - EL0[0]) * DEG - restOf.get(bL1)!);
+    const sr = posedOrigin(bR0, i);
+    const sl = posedOrigin(bL0, i);
+    let hc: Pt = [(sr[0] + sl[0]) / 2, (sr[1] + sl[1]) / 2 + 0.85 * Math.hypot(sl[0] - sr[0], sl[1] - sr[1])];
+    let ed = Math.max(1e-3, 0.30 * Math.hypot(sl[0] - sr[0], sl[1] - sr[1]));
+    if (gestureHead !== null) {
+      const ha = posedPoint(gestureHead.points[0], i);
+      const hb = posedPoint(gestureHead.points[1], i);
+      const d = Math.hypot(hb[0] - ha[0], hb[1] - ha[1]);
+      if (d > 1e-6) {
+        hc = [(ha[0] + hb[0]) / 2, (ha[1] + hb[1]) / 2];
+        ed = d;
+      }
+    }
+    const drawnR0 = set.drawn[bR0]!;
+    const drawnR1 = set.drawn[bR1]!;
+    const drawnL0 = set.drawn[bL0]!;
+    const drawnL1 = set.drawn[bL1]!;
+    const turnR0 = set.turn[bR0] ?? [-20, 20];
+    const turnR1 = set.turn[bR1] ?? [-20, 20];
+    const turnL0 = set.turn[bL0] ?? [-20, 20];
+    const turnL1 = set.turn[bL1] ?? [-20, 20];
+    const rawR0 = rawTargets.get(bR0)?.[i] ?? drawnR0;
+    const rawL0 = rawTargets.get(bL0)?.[i] ?? drawnL0;
+    const offR0 = wrap(rawR0 - drawnR0);
+    const offL0 = wrap(rawL0 - drawnL0);
+    let cOpen = Math.max(-4, Math.min(2, 0.15 * 0.5 * (offR0 - offL0)));
+    const solveTilt = (open: number): { aR0: number; aL0: number; exR: number; eyR: number; exL: number; eyL: number } => {
+      const evalDiff = (deg: number) => {
+        const dR = deg < 0 ? 0.25 * deg : deg;
+        const dL = deg > 0 ? 0.25 * deg : deg;
+        const ar = drawnR0 + Math.min(Math.max(open + dR, turnR0[0]), turnR0[1]);
+        const al = drawnL0 + Math.min(Math.max(-open + dL, turnL0[0]), turnL0[1]);
+        const eyr = sr[1] + lR0 * Math.sin((ar + dR0) / DEG);
+        const eyl = sl[1] + lL0 * Math.sin((al + dL0) / DEG);
+        return eyl - eyr;
+      };
+      let lo = -45;
+      let hi = 45;
+      let fLo = evalDiff(lo);
+      const fHi = evalDiff(hi);
+      let deg: number;
+      if ((fLo <= 0 && fHi <= 0) || (fLo > 0 && fHi > 0)) {
+        deg = Math.abs(fLo) <= Math.abs(fHi) ? lo : hi;
+      } else {
+        for (let it = 0; it < 36; it++) {
+          const mid = 0.5 * (lo + hi);
+          const fMid = evalDiff(mid);
+          if ((fLo <= 0 && fMid <= 0) || (fLo > 0 && fMid > 0)) {
+            lo = mid;
+            fLo = fMid;
+          } else {
+            hi = mid;
+          }
+        }
+        deg = 0.5 * (lo + hi);
+      }
+      const dR = deg < 0 ? 0.25 * deg : deg;
+      const dL = deg > 0 ? 0.25 * deg : deg;
+      let aR0 = drawnR0 + Math.min(Math.max(open + dR, turnR0[0]), turnR0[1]);
+      let aL0 = drawnL0 + Math.min(Math.max(-open + dL, turnL0[0]), turnL0[1]);
+      const eyR0 = sr[1] + lR0 * Math.sin((aR0 + dR0) / DEG);
+      const eyL0 = sl[1] + lL0 * Math.sin((aL0 + dL0) / DEG);
+      if (Math.abs(eyL0 - eyR0) > 1e-4) {
+        const sL = Math.max(-1, Math.min(1, (eyR0 - sl[1]) / Math.max(1e-6, lL0)));
+        const candL = wrap(Math.asin(sL) * DEG - dL0);
+        const tL = wrap(candL - drawnL0);
+        if (tL >= turnL0[0] && tL <= turnL0[1]) aL0 = candL;
+      }
+      const rR0 = (aR0 + dR0) / DEG;
+      const rL0 = (aL0 + dL0) / DEG;
+      return {
+        aR0: wrap(aR0),
+        aL0: wrap(aL0),
+        exR: sr[0] + lR0 * Math.cos(rR0),
+        eyR: sr[1] + lR0 * Math.sin(rR0),
+        exL: sl[0] + lL0 * Math.cos(rL0),
+        eyL: sl[1] + lL0 * Math.sin(rL0),
+      };
+    };
+    const upper = solveTilt(cOpen);
+    const aimFore = (ex: number, ey: number, l1: number, d1: number, drawn1: number, turn1: readonly [number, number], tx: number, ty: number): [number, Pt] => {
+      const want = wrap(Math.atan2(ty - ey, tx - ex) * DEG - d1);
+      const off = Math.min(Math.max(wrap(want - drawn1), turn1[0]), turn1[1]);
+      let a1 = wrap(drawn1 + off);
+      let r1 = (a1 + d1) / DEG;
+      let wx = ex + l1 * Math.cos(r1);
+      let wy = ey + l1 * Math.sin(r1);
+      const xMin = hc[0] - 0.30 * ed;
+      const xMax = hc[0] + 0.30 * ed;
+      const yMin = hc[1] + 0.15 * ed;
+      const yMax = hc[1] + 0.95 * ed;
+      if (wx < xMin || wx > xMax || wy < yMin || wy > yMax) {
+        let bestA = a1;
+        let bestErr = Infinity;
+        for (let step = -200; step <= 200; step++) {
+          const candOff = turn1[0] + ((turn1[1] - turn1[0]) * (step + 200)) / 400;
+          const candA = wrap(drawn1 + candOff);
+          const cr = (candA + d1) / DEG;
+          const cwx = ex + l1 * Math.cos(cr);
+          const cwy = ey + l1 * Math.sin(cr);
+          const ox = cwx < xMin ? xMin - cwx : cwx > xMax ? cwx - xMax : 0;
+          const oy = cwy < yMin ? yMin - cwy : cwy > yMax ? cwy - yMax : 0;
+          const err = (ox + oy) * 1000 + Math.hypot(cwx - tx, cwy - ty);
+          if (err < bestErr) {
+            bestErr = err;
+            bestA = candA;
+          }
+        }
+        a1 = bestA;
+        r1 = (a1 + d1) / DEG;
+        wx = ex + l1 * Math.cos(r1);
+        wy = ey + l1 * Math.sin(r1);
+      }
+      return [a1, [wx, wy]];
+    };
+    const [aR1, wR] = aimFore(upper.exR, upper.eyR, lR1, dR1, drawnR1, turnR1, hc[0] - 0.20 * ed, hc[1] + 0.65 * ed);
+    const [aL1, wL] = aimFore(upper.exL, upper.eyL, lL1, dL1, drawnL1, turnL1, hc[0] + 0.20 * ed, hc[1] + 0.65 * ed);
+    targets.get(bR0)![i] = upper.aR0;
+    targets.get(bR1)![i] = aR1;
+    targets.get(bL0)![i] = upper.aL0;
+    targets.get(bL1)![i] = aL1;
+    return { cR, cL, wR, wL, hc, ed };
+  };
   if (headOk !== null || hipsOk !== null) {
     /** The anchor's two rig points posed on frame i: their midpoint and their distance apart. */
     const pairOn = (an: Anchor, i: number): { centre: Pt; dist: number } => {
@@ -1380,19 +1611,36 @@ 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)!;
+        if (set.support?.includes(c.name) === true) {
+          for (let i = s.frames[0]; i <= s.frames[1]; i++) solveSupportChainFrame(set, c, i);
+          continue;
+        }
         const drawn = set.drawn[c.bones[0]!];
         const up = isChainHeadPlaced(set, c, drawn);
         const low = hipsOk !== null && set.place?.chains.includes(c.name) === true;
         if (!up && !low && headOk !== null && drawn !== undefined && isRaised(drawn) && c.bones.length >= 1 && c.joints.length >= 2) {
-          const p0 = set.pose[c.joints[0]!];
-          const p1 = set.pose[c.joints[1]!];
-          if (p0 !== undefined && p1 !== undefined) {
-            const key0 = pictureAngle(p0, p1);
+          if (set.support !== undefined && c.bones.length >= 2) {
             const t0 = targets.get(c.bones[0]!)!;
+            const t1 = targets.get(c.bones[1]!)!;
             for (let i = s.frames[0]; i <= s.frames[1]; i++) {
-              const diff = Math.max(-3, Math.min(3, wrap(t0[i]! - key0)));
-              t0[i] = wrap(drawn + diff);
+              const pair = solveSupportActiveFrame(set, c, i);
+              if (pair !== null) {
+                t0[i] = pair[0];
+                t1[i] = pair[1];
+              }
+            }
+          } else {
+            const p0 = set.pose[c.joints[0]!];
+            const p1 = set.pose[c.joints[1]!];
+            if (p0 !== undefined && p1 !== undefined) {
+              const key0 = pictureAngle(p0, p1);
+              const t0 = targets.get(c.bones[0]!)!;
+              for (let i = s.frames[0]; i <= s.frames[1]; i++) {
+                const diff = Math.max(-3, Math.min(3, wrap(t0[i]! - key0)));
+                t0[i] = wrap(drawn + diff);
+              }
             }
           }
         }
@@ -1560,7 +1808,7 @@ export function retarget(rest: Rest, map: JointMap, frames: ReadonlyArray<Partia
           t1[i] = a1;
         }
         // A held upper arm whose re-aimed forearm leaves the wrist more than HELD_MISS short of its placed point: ART-RANGE on the upper arm, with the shortfall.
-        if (turn0 !== undefined) {
+        if (turn0 !== undefined && set.symmetric !== true) {
           for (const [a, b] of runsOf(heldMiss.map((m) => m > HELD_MISS), RANGE_GAP)) {
             let worst = a;
             for (let k = a; k <= b; k++) if (heldMiss[k]! > heldMiss[worst]!) worst = k;
@@ -1569,7 +1817,7 @@ export function retarget(rest: Rest, map: JointMap, frames: ReadonlyArray<Partia
             art.push({ set: set.name, chain: c.name, bone: b0, frames: [first, last], seconds: r6(endOf(last) - keyTimes[first]!), maxOverflow: r3(upperOver[worst]!), turn: r3(upperAsked[worst]!), limits: turn0, clamped: true, shortfall: r3(heldMiss[worst]!), ...(up ? {} : { anchor: 'hip' as const }) });
           }
         }
-        if (turn1 !== undefined) {
+        if (turn1 !== undefined && set.symmetric !== true) {
           for (const [a, b] of runsOf(foreOver.map((o) => o > RANGE_SLACK), RANGE_GAP)) {
             let worst = a;
             for (let k = a; k <= b; k++) if (foreOver[k]! > foreOver[worst]!) worst = k;
@@ -1580,10 +1828,51 @@ export function retarget(rest: Rest, map: JointMap, frames: ReadonlyArray<Partia
         }
         raisedJobs.push(job);
       }
+      if (set.symmetric === true) {
+        for (let i = s.frames[0]; i <= s.frames[1]; i++) {
+          const sym = solveSymmetricFrame(set, i);
+          if (sym === null) continue;
+          const k = i - s.frames[0];
+          for (const job of raisedJobs) {
+            if (job.sw !== s) continue;
+            const w = job.chain.name === sym.cR.name ? sym.wR : job.chain.name === sym.cL.name ? sym.wL : null;
+            if (w !== null && k >= 0 && k < job.placed.length) {
+              job.placed[k] = [(w[0] - sym.hc[0]) / job.rigEye, (w[1] - sym.hc[1]) / job.rigEye];
+              job.upperHeld = [];
+              job.short = [];
+            }
+          }
+        }
+      }
       art.sort((x, y) => x.frames[0] - y.frames[0]);
       if (art.length > 0) raisedArt.push({ sw: s, entries: art });
     }
   }
+  // #188: Even without --raised-by-head, apply symmetric normalisation and support-arm anchoring on each switch's span.
+  for (const s of sw.switches) {
+    const set = map.alternates.find((a) => a.name === s.set)!;
+    if (set.symmetric === true && headOk === null && hipsOk === null) {
+      for (let i = s.frames[0]; i <= s.frames[1]; i++) solveSymmetricFrame(set, i);
+    }
+    if (set.support !== undefined) {
+      for (const cn of s.chains) {
+        const c = map.chains.find((x) => x.name === cn)!;
+        if (set.support.includes(c.name)) {
+          for (let i = s.frames[0]; i <= s.frames[1]; i++) solveSupportChainFrame(set, c, i);
+        } else if (headOk === null && hipsOk === null && c.bones.length >= 2) {
+          const t0 = targets.get(c.bones[0]!)!;
+          const t1 = targets.get(c.bones[1]!)!;
+          for (let i = s.frames[0]; i <= s.frames[1]; i++) {
+            const pair = solveSupportActiveFrame(set, c, i);
+            if (pair !== null) {
+              t0[i] = pair[0];
+              t1[i] = pair[1];
+            }
+          }
+        }
+      }
+    }
+  }
   p.throwIfAny();
   // The art turn of every span; a raised chain's bones were held by the solve, and only its re-aimed forearm is listed (above).
   const measured = measureArt(sw.switches, map, targets, endOf, keyTimes, RANGE_GAP);
@@ -1633,6 +1922,158 @@ 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);
+        }
+      }
+    }
+  }
+  // #188: Cover the full shown/bridged span of symmetric sets and support-arm sets after short interpolation.
+  for (let sIdx = 0; sIdx < sw.switches.length; sIdx++) {
+    const s = sw.switches[sIdx]!;
+    const set = map.alternates.find((a) => a.name === s.set)!;
+    const setSlots = Object.entries(set.slots);
+    const isSetShownAt = (i: number): boolean =>
+      setSlots.length > 0 && setSlots.every(([sl, att]) => sw.shown.get(sl)?.[i] === att);
+    let loShow = s.frames[0];
+    while (loShow - 1 >= 0 && isSetShownAt(loShow - 1)) loShow--;
+    let hiShow = s.frames[1];
+    while (hiShow + 1 < n && isSetShownAt(hiShow + 1)) hiShow++;
+    if (set.symmetric === true) {
+      for (let i = loShow; i <= s.frames[1]; i++) solveSymmetricFrame(set, i);
+      if (loShow < s.frames[0]) {
+        const loRamp = Math.max(0, loShow - 6);
+        const steps = loShow - loRamp;
+        if (steps >= 2) {
+          for (const cn of set.chains) {
+            const c = map.chains.find((x) => x.name === cn);
+            if (!c) continue;
+            for (const b of c.bones) {
+              const tg = targets.get(b)!;
+              const startA = tg[loRamp]!;
+              const total = wrap(tg[loShow]! - startA);
+              for (let k = loRamp + 1; k < loShow; k++) {
+                tg[k] = wrap(startA + ((k - loRamp) / steps) * total);
+              }
+            }
+          }
+        }
+      }
+      if (hiShow > s.frames[1] && set.chains.length === 2) {
+        const c0 = map.chains.find((x) => x.name === set.chains[0]!);
+        const c1 = map.chains.find((x) => x.name === set.chains[1]!);
+        if (c0 !== undefined && c1 !== undefined && c0.bones.length === 2 && c1.bones.length === 2) {
+          const S0_0 = rigPoint(rest, c0.bones[0]!)!;
+          const S0_1 = rigPoint(rest, c1.bones[0]!)!;
+          const [cR, cL] = S0_0[0] <= S0_1[0] ? [c0, c1] : [c1, c0];
+          const bR0 = cR.bones[0]!;
+          const bL0 = cL.bones[0]!;
+          const SR0 = rigPoint(rest, bR0)!;
+          const ER0 = rigPoint(rest, cR.bones[1]!)!;
+          const SL0 = rigPoint(rest, bL0)!;
+          const EL0 = rigPoint(rest, cL.bones[1]!)!;
+          const lR0 = Math.hypot(ER0[0] - SR0[0], ER0[1] - SR0[1]);
+          const lL0 = Math.hypot(EL0[0] - SL0[0], EL0[1] - SL0[1]);
+          const dR0 = wrap(Math.atan2(ER0[1] - SR0[1], ER0[0] - SR0[0]) * DEG - restOf.get(bR0)!);
+          const dL0 = wrap(Math.atan2(EL0[1] - SL0[1], EL0[0] - SL0[0]) * DEG - restOf.get(bL0)!);
+          for (let i = s.frames[1] + 1; i <= hiShow; i++) {
+            const sr = posedOrigin(bR0, i);
+            const sl = posedOrigin(bL0, i);
+            const baseR = targets.get(bR0)![i]!;
+            const baseL = targets.get(bL0)![i]!;
+            let lo = -20;
+            let hi = 20;
+            const evalD = (deg: number) =>
+              sl[1] + lL0 * Math.sin((baseL + deg + dL0) / DEG) - (sr[1] + lR0 * Math.sin((baseR + deg + dR0) / DEG));
+            let fLo = evalD(lo);
+            for (let it = 0; it < 32; it++) {
+              const mid = 0.5 * (lo + hi);
+              const fMid = evalD(mid);
+              if ((fLo <= 0 && fMid <= 0) || (fLo > 0 && fMid > 0)) {
+                lo = mid;
+                fLo = fMid;
+              } else hi = mid;
+            }
+            const deg = 0.5 * (lo + hi);
+            targets.get(bR0)![i] = wrap(baseR + deg);
+            targets.get(bL0)![i] = wrap(baseL + deg);
+          }
+        }
+      }
+    }
+    if (set.support !== undefined) {
+      const prevSw = sIdx > 0 ? sw.switches[sIdx - 1] : undefined;
+      const loGap = prevSw !== undefined && s.frames[0] - prevSw.frames[1] <= 10 ? prevSw.frames[1] + 1 : loShow;
+      for (const cn of s.chains) {
+        const c = map.chains.find((x) => x.name === cn)!;
+        if (set.support.includes(c.name)) {
+          for (let i = Math.min(loGap, loShow); i <= hiShow; i++) solveSupportChainFrame(set, c, i);
+          const anchorStart = Math.min(loGap, loShow);
+          if (anchorStart >= 2) {
+            for (const b of c.bones) {
+              const tg = targets.get(b)!;
+              tg[anchorStart - 1] = wrap(tg[anchorStart - 2]! + 0.5 * wrap(tg[anchorStart]! - tg[anchorStart - 2]!));
+            }
+          }
+        } else if (c.bones.length >= 2) {
+          const [b0, b1] = c.bones as [string, string];
+          const drawn0 = set.drawn[b0];
+          if (drawn0 !== undefined && isRaised(drawn0)) {
+            const S0 = rigPoint(rest, b0);
+            let headX0 = 0;
+            if (gestureHead !== null) {
+              const ha0 = rigPoint(rest, gestureHead.points[0]);
+              const hb0 = rigPoint(rest, gestureHead.points[1]);
+              if (ha0 !== null && hb0 !== null) headX0 = (ha0[0] + hb0[0]) / 2;
+            }
+            const l0 = S0 !== null && rigPoint(rest, b1) !== null ? Math.hypot(rigPoint(rest, b1)![0] - S0[0], rigPoint(rest, b1)![1] - S0[1]) : 100;
+            const outSign: 1 | -1 = (S0?.[0] ?? 0) + l0 * Math.cos(drawn0 / DEG) <= headX0 ? 1 : -1;
+            const t0 = targets.get(b0)!;
+            const t1 = targets.get(b1)!;
+            for (let i = loShow; i <= hiShow; i++) {
+              const pair = solveSupportActiveFrame(set, c, i);
+              if (pair === null) continue;
+              if (i >= s.frames[0] || outSign * wrap(t0[i]! - pair[0]) < 0) t0[i] = pair[0];
+              if (i >= s.frames[0] || outSign * wrap(t1[i]! - pair[1]) < 0) t1[i] = pair[1];
+            }
+          }
+        }
+      }
+    }
+  }
 
   // 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.
@@ -2038,24 +2479,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 });
       }
@@ -2072,9 +2515,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;
         }
       }

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,57 @@ 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) {
+        if (set.support?.includes(cn) === true) continue;
+        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 +709,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 +734,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 +785,151 @@ 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 activeSwChains = switchingChains.filter((cn) => !set1.support?.includes(cn) && !set0.support?.includes(cn));
+        const measureChains = activeSwChains.length > 0 ? activeSwChains : switchingChains;
+        const measureBones = measureChains.flatMap((cn) => map.chains.find((c) => c.name === cn)?.bones ?? []);
+        const rootBones = measureChains
+          .map((cn) => map.chains.find((c) => c.name === cn)?.bones[0])
+          .filter((b): b is string => b !== undefined && set0.drawn[b] !== undefined && set1.drawn[b] !== undefined);
+        const pairs = measureBones.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);
+          const rootsCrossed =
+            activeSwChains.length === switchingChains.length ||
+            rootBones.every((b) => Math.abs(wrap(effAngle(b, i) - set1.drawn[b]!)) <= Math.abs(wrap(effAngle(b, i) - set0.drawn[b]!)));
+          if ((d1 <= d0 || (span > 1e-6 && d0 >= 0.5 * span)) && rootsCrossed) {
+            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 +977,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 +1039,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 +1224,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 +1235,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++) {