@rig-c/pose 0.25.0 → 0.27.0

package/README.md

@@ -315,7 +315,7 @@ Which bones carry which joints. You write it for your rig:
   ⚠️ **Seen from the front, an elbow's side is not a joint limit.** An elbow flexes toward the camera, and its picture falls on either side of the upper arm depending on how the arm is turned. On a real 13 s front-facing dance (313 frames, RTMPose), the right elbow sat on the "wrong" side of the rig's rest on 165 frames (median 23°), and the left on 200 (median 29°, up to 179° with the hands behind the head). Every one was a real elbow bend. The knees strayed at most 8.8° and 14.7°, which is pose noise around a straight leg. So for front-facing material, arms go `"free"`. Legs on `"rest"` with `--bends clamp` hold only while the knees stay near straight. On a second dance with knee bends (Toca Toca, rig-c/pose#27), that setting straightened the left knee for most of the dance: `leg_l1` was 48.3° off at p90, against 0.0–0.3° with free legs. Leave legs `"free"` unless the dance keeps its knees straight.
 - `mid_hip` and `mid_shoulder` are the midpoints of the two hips and the two shoulders.
 - `translate.scale` is one length measured on both: two points on the rig, two points in the pose (its median over the frames where both are good). Pick a long segment that does not foreshorten much.
-- `face` (optional, [#138](https://github.com/rig-c/pose/issues/138), [#164](https://github.com/rig-c/pose/issues/164), [#173](https://github.com/rig-c/pose/issues/173)): `{ "yaw"?: { "bone": "yaw", "range": [-15, 15], "sets"?: [{ "set": "T1", "above": 45 }] }, "pitch"?: { "bone": "pitch", "range": [-10, 15] }, "sets"?: [{ "set": "T1", "above": 45 }] }` (`min ≤ 0 ≤ max`, `min < max`). Reads per-frame yaw and pitch from `nose` against `r_eye + l_eye` (and `r_ear + l_ear` when present), maps 1:1 inside `0.8 × range` (`[-12, 12]°` on `[-15, 15]°`) and compresses only the overshoot above the knee into the remaining 20% of the range so a single outlier frame does not crush the rest of the clip, and keys the named dial bone's `rotate` track (`FACE`). When `sets` (`[{ "set": "<name>", "above": <deg> }]`, `0 < above ≤ 90`) is declared on `face.yaw.sets` or `face.sets`, each set enters on frames where `|yaw| ≥ above` (or the highest `above` satisfied when multiple sets are declared) and leaves only when `|yaw| < above − 10°` (`10°` hysteresis), emitting stepped slot `attachment` keys for the set's `slots` and `hides` (resolved from `alternates` in the map or `sets.json` (`rig-parts-sets/1`) beside `rig.json`; an unknown set is refused by name as `MAP_SET_EXISTS`).
+- `face` (optional, [#138](https://github.com/rig-c/pose/issues/138), [#164](https://github.com/rig-c/pose/issues/164), [#173](https://github.com/rig-c/pose/issues/173), [#189](https://github.com/rig-c/pose/issues/189)): `{ "yaw"?: { "bone": "yaw", "range": [-15, 15], "sets"?: [{ "set": "T1", "above": 45 }] }, "pitch"?: { "bone": "pitch", "range": [-10, 15] }, "sets"?: [{ "set": "T1", "above": 45 }] }` (`min ≤ 0 ≤ max`, `min < max`). Reads per-frame yaw and pitch from `nose` against `r_eye + l_eye` (and `r_ear + l_ear` when present — where the eye span is foreshortened below `0.85 × median(de)` and the ear-chord offset `xea = (mid_ears − mid_eyes) · u / da` exceeds both `1.8 × |xne|` and `0.15`, yaw blends toward the ear chord `atan(2 × xea)` with weight `w = clamp((0.85 × median(de) − de) / ((0.85 − 0.80) × median(de)), 0, 1)` so a side gaze whose 2D nose sits near the eye midpoint reaches `atan(2 × xea)` below `0.80 × median(de)` and exits without a step), maps 1:1 inside `0.8 × range` (`[-12, 12]°` on `[-15, 15]°`) and compresses only the overshoot above the knee into the remaining 20% of the range so a single outlier frame does not crush the rest of the clip, and keys the named dial bone's `rotate` track (`FACE`). When `sets` (`[{ "set": "<name>", "above": <deg> }]`, `0 < above ≤ 90`) is declared on `face.yaw.sets` or `face.sets`, each set enters on frames where `|yaw| ≥ above` (or the highest `above` satisfied when multiple sets are declared) and leaves only when `|yaw| < above − 10°` (`10°` hysteresis), emitting stepped slot `attachment` keys for the set's `slots` and `hides` (resolved from `alternates` in the map or `sets.json` (`rig-parts-sets/1`) beside `rig.json`; an unknown set is refused by name as `MAP_SET_EXISTS`).
 - `body` (optional, [#173](https://github.com/rig-c/pose/issues/173)): `{ "yaw"?: { "bone": "body_yaw", "range": [-30, 30], "sets"?: [{ "set": "T8", "above": 45 }] }, "sets"?: [{ "set": "T8", "above": 45 }] }` (`min ≤ 0 ≤ max`, `min < max`). Maps the per-frame body yaw read from the camera-normalised shoulder and hip width (`BODY`) into `range` with the same `0.8 × range` knee mapping as `face`, keying the named dial bone's `rotate` track, and switches any declared `sets` (`body.sets` or `body.yaw.sets`) with the same `above` / `above − 10°` hysteresis (overriding `face` sets and arm `alternates` on slots they share while active). Without `body` in the map, `BODY` and `--report`'s `body` still report the reading while leaving every track in `motion.json` unchanged.
 
 ### A joint's range: `range`
@@ -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.25.0",
+  "version": "0.27.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/face.ts

@@ -123,6 +123,37 @@ function corrOf(a: readonly number[], b: readonly number[]): number {
   return den > 1e-9 ? r3(num / den) : 1;
 }
 
+/**
+ * Eye-span foreshortening entry threshold `de < EAR_CHORD_K_DE * median(de)` (`rig-c/pose#189`):
+ * derived from $\cos(31.79^\circ) = 0.85$ ($\approx 32^\circ$ head turn), the foreshortening angle
+ * beyond which the near-planar 2D nose point begins to sit trapped between the foreshortened eyes.
+ */
+export const EAR_CHORD_K_DE = 0.85;
+
+/**
+ * Eye-span foreshortening full-weight threshold `de <= EAR_CHORD_K_LO * median(de)` (`rig-c/pose#189`):
+ * derived from $\cos(36.87^\circ) = 0.80$ ($4/5$, $\approx 37^\circ$ head turn), where the foreshortening
+ * blend weight `w = clamp((EAR_CHORD_K_DE * de0 - de) / ((EAR_CHORD_K_DE - EAR_CHORD_K_LO) * de0), 0, 1)`
+ * reaches `1.0` so the exit from a foreshortened side gaze ramps smoothly instead of snapping at `EAR_CHORD_K_DE`.
+ */
+export const EAR_CHORD_K_LO = 0.8;
+
+/**
+ * Ear-chord to nose-cue disagreement ratio `|xea| > EAR_CHORD_K_RATIO * |xne|` (`rig-c/pose#189`):
+ * derived from the 95th-percentile of `|xea| / |xne|` on confident frames (`|de - median(de)| <= 15%`)
+ * above `EAR_CHORD_K_MIN`, measured at `p95 = 1.7352` on Dancer (`37` frames) and `p95 = 1.1937`
+ * (`p100 = 1.2867`) on Toca (`58` frames) -> `1.8`.
+ */
+export const EAR_CHORD_K_RATIO = 1.8;
+
+/**
+ * Minimum ear-to-eye-midpoint offset `|xea| > EAR_CHORD_K_MIN` (`rig-c/pose#189`):
+ * derived from the 100th-percentile (maximum) detector ear-placement noise `|xea - xne|` on
+ * confident frames (`|de - median(de)| <= 15%`), measured at `p99 = 0.0949, p100 = 0.1094` on Dancer
+ * (`231` frames) and `p99 = 0.1178, p100 = 0.1450` on Toca (`373` frames) -> `0.15` (`16.70°`).
+ */
+export const EAR_CHORD_K_MIN = 0.15;
+
 /**
  * Read per-frame yaw and pitch (degrees) from `nose`, `r_eye`, `l_eye`, and
  * (when both are present) `r_ear` and `l_ear`.
@@ -140,8 +171,10 @@ export function readFaceAngles(
 ): { ears: boolean; yaw: number[]; pitch: number[] } {
   const n = nose.length;
   const ears = rEar !== null && lEar !== null && rEar.length === n && lEar.length === n;
+  const des: number[] = [];
   const xne: number[] = [];
   const xna: number[] = [];
+  const xea: number[] = [];
   const yne: number[] = [];
   const yna: number[] = [];
 
@@ -153,14 +186,17 @@ export function readFaceAngles(
     const ey = El[1] - Er[1];
     const de = Math.hypot(ex, ey);
     if (!(de > 1e-9)) {
+      des.push(des[i - 1] ?? 0);
       xne.push(xne[i - 1] ?? 0);
       yne.push(yne[i - 1] ?? 0);
       if (ears) {
         xna.push(xna[i - 1] ?? 0);
+        xea.push(xea[i - 1] ?? 0);
         yna.push(yna[i - 1] ?? 0);
       }
       continue;
     }
+    des.push(de);
     const ux = ex / de;
     const uy = ey / de;
     const vx = -uy;
@@ -176,18 +212,31 @@ export function readFaceAngles(
       const may = 0.5 * (Ar[1] + Al[1]);
       const da = Math.max(de, (Al[0] - Ar[0]) * ux + (Al[1] - Ar[1]) * uy);
       xna.push(((max - N[0]) * ux + (may - N[1]) * uy) / da);
+      xea.push(((max - mex) * ux + (may - mey) * uy) / da);
       yna.push(((N[0] - max) * vx + (N[1] - may) * vy) / de);
     }
   }
 
+  const de0 = n > 0 ? median(des) : 0;
   const yne0 = median(yne);
   const yna0 = ears ? median(yna) : 0;
   const yaw: number[] = [];
   const pitch: number[] = [];
   for (let i = 0; i < n; i++) {
-    const ty = ears ? (2 * xne[i]! + xna[i]!) / 2 : 2 * xne[i]!;
+    const earChord =
+      ears &&
+      de0 > 1e-9 &&
+      des[i]! < EAR_CHORD_K_DE * de0 &&
+      Math.abs(xea[i]!) > EAR_CHORD_K_RATIO * Math.abs(xne[i]!) &&
+      Math.abs(xea[i]!) > EAR_CHORD_K_MIN;
+    const w = earChord
+      ? EAR_CHORD_K_DE > EAR_CHORD_K_LO
+        ? Math.max(0, Math.min(1, (EAR_CHORD_K_DE * de0 - des[i]!) / ((EAR_CHORD_K_DE - EAR_CHORD_K_LO) * de0)))
+        : 1
+      : 0;
+    const rawYaw = Math.atan(ears ? (2 * xne[i]! + xna[i]!) / 2 : 2 * xne[i]!) * DEG;
     const tp = ears ? (yne[i]! - yne0 + (yna[i]! - yna0)) / 2 : yne[i]! - yne0;
-    yaw.push(Math.atan(ty) * DEG);
+    yaw.push(w > 0 ? w * (Math.atan(2 * xea[i]!) * DEG) + (1 - w) * rawYaw : rawYaw);
     pitch.push(Math.atan(tp) * DEG);
   }
   return { ears, yaw, pitch };

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 } => {
@@ -1382,18 +1613,34 @@ export function retarget(rest: Rest, map: JointMap, frames: ReadonlyArray<Partia
       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);
+              }
             }
           }
         }
@@ -1561,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;
@@ -1570,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;
@@ -1581,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);
@@ -1673,6 +1961,119 @@ export function retarget(rest: Rest, map: JointMap, frames: ReadonlyArray<Partia
       }
     }
   }
+  // #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.

package/src/switch.ts

@@ -666,6 +666,7 @@ export function selectSwitches(map: JointMap, targets: ReadonlyMap<string, reado
       });
       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);
@@ -885,7 +886,13 @@ export function selectSwitches(map: JointMap, targets: ReadonlyMap<string, reado
           }
           return raw;
         };
-        const pairs = swBones.filter((b) => set0.drawn[b] !== undefined && set1.drawn[b] !== undefined);
+        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;
@@ -896,7 +903,10 @@ export function selectSwitches(map: JointMap, targets: ReadonlyMap<string, reado
           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)) {
+          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;
           }