@rig-c/pose 0.28.0 → 0.29.1

package/README.md

@@ -107,7 +107,7 @@ A retarget of the cleaned dancer, with `--flip 90 --short 0.35 --bends clamp --l
 rig-pose retarget --rig out/rig --map map.json --pose dance.pose.json --out motion.json --name dance
 ```
 
-For every frame of the pose and every bone the map names, the segment that bone carries (an upper arm: shoulder → elbow) points somewhere in the picture. The bone is turned so its segment points the same way: the picture angle, flipped into rig-c's y-up world, minus the bone's angle at the rig's setup pose (read through rig-c's own poser), less the turn of the mapped bone above it — because a `rotate` key in rig-c adds to the setup rotation and a child turns with its parent. The travel of the pelvis midpoint, scaled by a length measured on both the rig and the pose, moves the hip. When a head chain carries the eye line (`r_eye → l_eye`), the eyes' vertical travel against `neck` in the reference, scaled into the rig's units, keys a vertical `translate` nod channel on the head bone ([#111](https://github.com/rig-c/pose/issues/111)) clamped within `±2%` of the setup neck length (`head − neck`, [#181](https://github.com/rig-c/pose/issues/181)), while any vertical residual removed by that clamp (`rawNod − dy`) is coupled in phase into `face.pitch`'s dial (`+2.8°/unit`, mapped through `face.pitch.range`) and the head bone's `rotate` track (`+1.6°/unit`, [#190](https://github.com/rig-c/pose/issues/190); gains calibrated against the hand-polished reference `p1`), adding `0°` on frames where the clamp does not act. The result is one animation in rig-c's motion format (`rigc-motion/1`): a `rotate` track per mapped bone, a `translate` track on the hip (and on the head when the reference nods), one key per pose frame — and, when the map lists alternate drawings, an `attachment` track per slot they switch (and a `translate` track per bone a set offsets).
+For every frame of the pose and every bone the map names, the segment that bone carries (an upper arm: shoulder → elbow) points somewhere in the picture. The bone is turned so its segment points the same way: the picture angle, flipped into rig-c's y-up world, minus the bone's angle at the rig's setup pose (read through rig-c's own poser), less the turn of the mapped bone above it — because a `rotate` key in rig-c adds to the setup rotation and a child turns with its parent. The travel of the pelvis midpoint, scaled by a length measured on both the rig and the pose, moves the hip. When a head chain carries the eye line (`r_eye → l_eye`), the eyes' vertical travel against `neck` in the reference, scaled into the rig's units, keys a vertical `translate` nod channel on the head bone ([#111](https://github.com/rig-c/pose/issues/111)) clamped within `±2%` of the setup neck length (`head − neck`, [#181](https://github.com/rig-c/pose/issues/181)), while on sequences where that clamp acts, the clamped vertical nod (`clampedY`) is coupled in phase into `face.pitch`'s dial (`+2.8°/unit`, mapped through `face.pitch.range`) and the head bone's `rotate` track (`+1.6°/unit`, [#190](https://github.com/rig-c/pose/issues/190), [#205](https://github.com/rig-c/pose/issues/205); gains calibrated against the hand-polished reference `p1`). The result is one animation in rig-c's motion format (`rigc-motion/1`): a `rotate` track per mapped bone, a `translate` track on the hip (and on the head when the reference nods), one key per pose frame — and, when the map lists alternate drawings, an `attachment` track per slot they switch (and a `translate` track per bone a set offsets).
 
 Nothing is written until every check passes:
 
@@ -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), [#189](https://github.com/rig-c/pose/issues/189), [#190](https://github.com/rig-c/pose/issues/190)): `{ "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), couples any vertical residual removed by the head nod channel's `±2%` neck-length clamp (`+2.8°/unit`, `0°` where un-clamped) into `pitch` in phase ([#190](https://github.com/rig-c/pose/issues/190)), 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), [#190](https://github.com/rig-c/pose/issues/190), [#205](https://github.com/rig-c/pose/issues/205)): `{ "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), couples the head nod channel's clamped vertical travel (`clampedY`, `+2.8°/unit` when the `±2%` neck-length clamp acts on the sequence) into `pitch` in phase ([#190](https://github.com/rig-c/pose/issues/190), [#205](https://github.com/rig-c/pose/issues/205)), 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,12 +349,13 @@ 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 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).
+- `drawn` (optional): each bone's world angle (Spine degrees) as painted. It changes no key unless the set declares `symmetric`, `support` or `anchor` ([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)).
-- `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`.
+- `symmetric` (optional, [#188](https://github.com/rig-c/pose/issues/188), [#206](https://github.com/rig-c/pose/issues/206)): `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)), ramping in and out in joint space across any adjacent bridge frames where the set's slots remain shown. 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), [#206](https://github.com/rig-c/pose/issues/206)): 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's slots show (`loShow..hiShow`), each support chain's bones anchor to `drawn` within `±2.5°` (`≤ ±3°`) of the pose's delta relative to the set's reference pose (bridging in joint space across any preceding gap frames where the leaving set's slots still show), and an unplaced active raised arm in the same set clears the head/bun outward along the 2D shoulder→wrist direction (`MAP_ALT_SUPPORT`).
+- `anchor` (optional, [#191](https://github.com/rig-c/pose/issues/191)): a chain name or non-empty list of chain names of the set (`"anchor": "arm_l"` or `["arm_l"]`) whose hand is anchored to the set's drawn hand-tip-to-head offset in the `head` bone's local frame (`MAP_ALT_ANCHOR`, `ANCHOR_HEAD`); while the set's slots for that chain show, the target hand tip is `head_posed_origin + rotate(W_drawn − H_setup, head_posed_rot − head_drawn_rot)` and the 2-bone arm is solved by two-circle intersection (`twoBone` / `reachLimit`) inside the set's `turn`, listing any frame where `turn` saturates and leaves a residual hand-tip shortfall (`saturated: [{ frame, residual }]` on `raised`, printed as `; residual f46 9.68u, …` on `RAISED`).
+- 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`, `MAP_ALT_SUPPORT` and `MAP_ALT_ANCHOR`.
 
 **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.
 
@@ -364,7 +365,7 @@ The bound exists because speed alone rewarded showing art far from its pose. Unb
 
 Either way the `SWITCH` line ends with `moved on …, off …`: each boundary's old and new frame (the same under `first`), the frames and seconds it moved, the speed on both and its window, and the report carries the same under `moved`.
 
-**What is written.** An `attachment` track per slot whose picture changes: the set's attachment (or `null` for a hidden slot) where a span starts, and the slot's setup attachment, as the compiled model states it, where it ends. A direct switch from one set to another puts the first set's slots back to setup on the second's first frame, so an extra slot that is empty at setup goes empty. Between two sets that both draw an arm behind the torso, a frame that belongs to neither set stays behind (the set nearer in hand position and segment distance, not frame count); the default front slot is for a frame no set can claim **and** whose arm is read in front — not a fallback ([#136](https://github.com/rig-c/pose/issues/136), [#139](https://github.com/rig-c/pose/issues/139), [#162](https://github.com/rig-c/pose/issues/162), [#180](https://github.com/rig-c/pose/issues/180)). A switch onto frame *i* is keyed halfway between frames *i*−1 and *i*: a stepped key on the frame's own time fires a frame late wherever a player's accumulated time lands just below it (rig-c's docs/AUTHORING.md §4.5), and halfway both the pose's times and a renderer's `i / fps` see it on frame *i*. Before the first key a slot shows its setup attachment, so no key is written at 0 unless a span starts there. Offsets are `translate` keys at the same times, `stepped`. rig-c's gate checks these keys like any other.
+**What is written.** An `attachment` track per slot whose picture changes: the set's attachment (or `null` for a hidden slot) where a span starts, and the slot's setup attachment, as the compiled model states it, where it ends. A direct switch from one set to another puts the first set's slots back to setup on the second's first frame, so an extra slot that is empty at setup goes empty. Between two sets that both draw an arm behind the torso, a frame that belongs to neither set stays behind (the set nearer in hand position and segment distance, not frame count), with any adjacent bridge or `SHORT` ramp interpolated in joint space (parent-local angle for child bones) and any extended hold of a tight set included in `chainHolds`/`covered` so the held art is clamped and exempted from `capShortSteps` and `range`; the default front slot is for a frame no set can claim **and** whose arm is read in front — not a fallback ([#136](https://github.com/rig-c/pose/issues/136), [#139](https://github.com/rig-c/pose/issues/139), [#162](https://github.com/rig-c/pose/issues/162), [#180](https://github.com/rig-c/pose/issues/180), [#187](https://github.com/rig-c/pose/issues/187), [#206](https://github.com/rig-c/pose/issues/206)). A switch onto frame *i* is keyed halfway between frames *i*−1 and *i*: a stepped key on the frame's own time fires a frame late wherever a player's accumulated time lands just below it (rig-c's docs/AUTHORING.md §4.5), and halfway both the pose's times and a renderer's `i / fps` see it on frame *i*. Before the first key a slot shows its setup attachment, so no key is written at 0 unless a span starts there. Offsets are `translate` keys at the same times, `stepped`. rig-c's gate checks these keys like any other.
 
 **TURN.** The cutoff was measured on the three lines across the body before it was fixed ([#6](https://github.com/rig-c/pose/issues/6)): on the 13 s front-facing dance their picture length never drops under 0.81 of its median and none reverses; on a second sequence the hip line falls to 0.17 at frames 465–491 (side-on) and the eye line to 0.22 at 26–58 (head in profile), and 3 frames reverse. 0.5 lies between. A line is reversed when it points more than 90° from the subject's right joint to the left (front-facing, it points at 0°). The lines are read after holds, held as the map's points are even where the map does not use them; a line whose points are good on no frame is named as not measured.
 

package/package.json

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

@@ -104,6 +104,8 @@ export interface AlternateSet {
   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[];
+  /** `anchor` (rig-c/pose#191): the set's two-bone arm chains whose hand-tip is anchored to the set's `drawn` head-local offset while the set shows. */
+  anchor?: string[];
 }
 export interface YawSet {
   set: string;
@@ -439,7 +441,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', 'symmetric', 'support']);
+    refuseUnknownKeys(p, 'MAP_KEYS', aw, a, ['name', 'note', 'slots', 'hides', 'chains', 'pose', 'drawn', 'offsets', 'turn', 'frames', 'place', 'symmetric', 'support', 'anchor']);
     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`);
@@ -602,7 +604,48 @@ function readAlternates(p: Problems, where: string, raw: unknown, chains: readon
         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 }) });
+    let anchor: string[] | undefined;
+    if ('anchor' in a) {
+      const anc = typeof a.anchor === 'string' && a.anchor !== '' ? [a.anchor] : strings(a.anchor);
+      if (anc === null || anc.length === 0 || anc.some((s) => s === '')) {
+        p.add('MAP_ALT_ANCHOR', `${label} "anchor" is ${JSON.stringify(a.anchor)}; it must name one or more of the set's chains (${(cs ?? []).join(', ') || 'none'})`);
+        ok = false;
+      } else {
+        if (new Set(anc).size !== anc.length) {
+          p.add('MAP_ALT_ANCHOR', `${label} "anchor" names a chain twice: ${anc.join(', ')}`);
+          ok = false;
+        }
+        const outside = anc.filter((c) => !(cs ?? []).includes(c));
+        if (outside.length > 0) {
+          p.add('MAP_ALT_ANCHOR', `${label} "anchor" names chain ${outside.map((c) => `"${c}"`).join(', ')}, which is not in the set's chains (${(cs ?? []).join(', ') || 'none'})`);
+          ok = false;
+        }
+        const ancChains = own.filter((c) => anc.includes(c.name));
+        const nonTwo = ancChains.filter((c) => c.bones.length !== 2);
+        if (nonTwo.length > 0) {
+          p.add('MAP_ALT_ANCHOR', `${label} "anchor" chain ${nonTwo.map((c) => `"${c.name}" (${c.bones.length} bone(s))`).join(', ')} is not a two-bone chain; a head-anchored chain solves a two-bone arm`);
+          ok = false;
+        }
+        if (a.symmetric === true) {
+          p.add('MAP_ALT_ANCHOR', `${label} names both "symmetric" and "anchor"; a set either normalises both arms symmetrically or anchors an arm to the head`);
+          ok = false;
+        }
+        const supRaw = typeof a.support === 'string' ? [a.support] : strings(a.support) ?? [];
+        const bothSup = anc.filter((c) => supRaw.includes(c));
+        if (bothSup.length > 0) {
+          p.add('MAP_ALT_ANCHOR', `${label} names chain ${bothSup.map((c) => `"${c}"`).join(', ')} in both "support" and "anchor"; a chain is anchored one way`);
+          ok = false;
+        }
+        const ancBones = ancChains.flatMap((c) => c.bones);
+        const missing = ancBones.filter((b) => !(b in drawn));
+        if (missing.length > 0) {
+          p.add('MAP_ALT_ANCHOR', `${label} "anchor" chain has no "drawn" angle for ${missing.map((b) => `"${b}"`).join(', ')}; a head-anchored chain derives its head-local offset from its drawn angles`);
+          ok = false;
+        }
+        if (ok) anchor = anc;
+      }
+    }
+    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 }), ...(anchor === undefined ? {} : { anchor }) });
   });
   return out;
 }

package/src/retarget.ts

@@ -99,21 +99,31 @@ const DEG = 180 / Math.PI;
 export const HELD_MISS = 0.01;
 
 /**
- * Beat-nod phase-coupling gain (`°/unit`) from the vertical residual that the
- * `±2%` neck-length clamp removes from `head.translate.y` (`rawNod - dy`) onto
- * `map.face.pitch` (`pitch_dial.rotate`, `rig-c/pose#190`). Measured on the
- * dancer reference hand pass (`hand/p1` HP2: `+2.8°/unit`).
+ * Beat-nod phase-coupling gain (`°/unit`) from the clamped `head.translate.y`
+ * offset (`clampedY`, bounded by `±2%` of neck length) onto `map.face.pitch`
+ * (`pitch_dial.rotate`, `rig-c/pose#190`, `#205`) when the neck-length clamp
+ * acts on the sequence. Measured on the dancer reference hand pass (`hand/p1`
+ * HP2: `+2.8°/unit`).
  */
 export const NOD_RESIDUAL_PITCH_GAIN = 2.8;
 
 /**
- * Beat-nod phase-coupling gain (`°/unit`) from the vertical residual that the
- * `±2%` neck-length clamp removes from `head.translate.y` (`rawNod - dy`) onto
- * the head chain bone's `rotate` track (`head.rotate`, `rig-c/pose#190`).
- * Measured on the dancer reference hand pass (`hand/p1` HP2: `+1.6°/unit`).
+ * Beat-nod phase-coupling gain (`°/unit`) from the clamped `head.translate.y`
+ * offset (`clampedY`, bounded by `±2%` of neck length) onto the head chain
+ * bone's `rotate` track (`head.rotate`, `rig-c/pose#190`, `#205`) when the
+ * neck-length clamp acts on the sequence. Measured on the dancer reference
+ * hand pass (`hand/p1` HP2: `+1.6°/unit`).
  */
 export const NOD_RESIDUAL_HEAD_GAIN = 1.6;
 
+/**
+ * Reference frame for sets declaring `anchor` (`rig-c/pose#191`): `'head-local'`
+ * rotates the set's drawn hand-tip-to-head offset by the head bone's posed world
+ * turn on each frame; `'world-fixed'` holds the unrotated setup world offset;
+ * `'off'` disables head-anchored end-effector solving.
+ */
+export const HEAD_ANCHOR_FRAME: 'head-local' | 'world-fixed' | 'off' = 'head-local';
+
 export interface HeadNodReading {
   bone: string;
   maxNod: number;
@@ -481,6 +491,10 @@ export function retarget(rest: Rest, map: JointMap, frames: ReadonlyArray<Partia
   // `place: "by-hip"` (#93) measures against the hip in hip widths: the map must name the rig's two hip points.
   const hips = map.alternates.some((a) => a.place !== undefined && a.place !== null) ? hipOf(map) : null;
   if (hips !== null && 'problem' in hips) p.add('PLACE_HIP', hips.problem);
+  const headAnchorBone = map.alternates.some((a) => a.anchor !== undefined) ? headBoneOf(map) : null;
+  if (map.alternates.some((a) => a.anchor !== undefined) && headAnchorBone === null) {
+    p.add('ANCHOR_HEAD', '"anchor" anchors a set\'s hand to the head bone\'s local frame, and no chain of the map carries the eye line (joints r_eye → l_eye)');
+  }
 
   // Every point the map reads, held where it is not good.
   const needed = new Set<string>();
@@ -1353,11 +1367,147 @@ export function retarget(rest: Rest, map: JointMap, frames: ReadonlyArray<Partia
   const raised: Raised[] = [];
   const byHip: ByHip[] = [];
   const raisedArt: Array<{ sw: Switch; entries: ArtRange[] }> = [];
-  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 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[]; saturated?: Array<{ frame: number; residual: 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);
+  /**
+   * #191: Posed origin and final world rotation (degrees, including #190's nod-residual coupling
+   * and `headNodTrack` translation) of the head bone `hb` on frame `i`.
+   */
+  const finalHeadPose = (hb: string, i: number): { origin: Pt; rotDeg: number } => {
+    let origin = posedOrigin(hb, i);
+    if (headNodTrack !== null && headNodTrack.bone === hb) {
+      const k = headNodTrack.keys.find((x) => Math.abs(x.t - keyTimes[i]!) < 1e-5);
+      if (k !== undefined && Array.isArray(k.v)) {
+        const pName = rest.get(hb)?.parent ?? null;
+        const pRest = pName !== null ? rest.get(pName) : undefined;
+        if (pName !== null && pRest !== undefined) {
+          const pTurn = turnAbove(pName, i);
+          const rad = pTurn / DEG;
+          const c = Math.cos(rad);
+          const s = Math.sin(rad);
+          const pa = c * pRest.a - s * pRest.c;
+          const pb = c * pRest.b - s * pRest.d;
+          const pc = s * pRest.a + c * pRest.c;
+          const pd = s * pRest.b + c * pRest.d;
+          const [lx, ly] = k.v;
+          origin = [origin[0] + pa * lx + pb * ly, origin[1] + pc * lx + pd * ly];
+        }
+      }
+    }
+    let rotDeg = targets.get(hb)?.[i] ?? restOf.get(hb) ?? 0;
+    if (headNodReading !== null && headNodReading.bone === hb && headNodReading.residual.some((r) => r !== 0)) {
+      const nodY = headNodReading.clampedY[i] ?? 0;
+      if (nodY !== 0) {
+        const above = mappedAbove(hb);
+        const hc = map.chains.find((c) => c.bones.includes(hb));
+        const limits = hc?.range[hb];
+        const cov = hc !== undefined ? covered.get(hc.name) : undefined;
+        let next = wrap(rotDeg + NOD_RESIDUAL_HEAD_GAIN * nodY);
+        if (limits !== undefined && cov?.[i] !== true) {
+          const key = wrap((next - restOf.get(hb)!) - (above === null ? 0 : turn(above, i)));
+          if (overflow(key, limits) > RANGE_SLACK) {
+            next = wrap(next + Math.min(Math.max(key, limits[0]), limits[1]) - key);
+          }
+        }
+        rotDeg = next;
+      }
+    }
+    return { origin, rotDeg };
+  };
+  /**
+   * #191: For a chain listed in `set.anchor`, compute the target hand-tip position from the set's
+   * `drawn` hand-tip-to-head offset in the `head` bone's local frame (or fixed world offset when
+   * `HEAD_ANCHOR_FRAME === 'world-fixed'`), and solve the two-bone arm inside `set.turn`.
+   */
+  const solveHeadAnchorFrame = (
+    set: (typeof map.alternates)[number],
+    c: Chain,
+    i: number,
+  ): {
+    a0: number;
+    a1: number;
+    targetTip: Pt;
+    placedTip: Pt;
+    achievedTip: Pt;
+    residual: number;
+    saturated: boolean;
+    upperHeld: boolean;
+  } | null => {
+    if (HEAD_ANCHOR_FRAME === 'off' || headAnchorBone === null || c.bones.length < 2) 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) 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);
+    const H0 = rigPoint(rest, headAnchorBone);
+    const headRestRot = restOf.get(headAnchorBone);
+    if (S0 === null || E0 === null || W0 === null || H0 === null || headRestRot === undefined) 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]);
+    const d0 = wrap(Math.atan2(E0[1] - S0[1], E0[0] - S0[0]) * DEG - restOf.get(b0)!);
+    const d1 = wrap(Math.atan2(W0[1] - E0[1], W0[0] - E0[0]) * DEG - restOf.get(b1)!);
+    const r0Drawn = (drawn0 + d0) / DEG;
+    const r1Drawn = (drawn1 + d1) / DEG;
+    const WDrawn: Pt = [
+      S0[0] + l0 * Math.cos(r0Drawn) + l1 * Math.cos(r1Drawn),
+      S0[1] + l0 * Math.sin(r0Drawn) + l1 * Math.sin(r1Drawn),
+    ];
+    const dWorld0: Pt = [WDrawn[0] - H0[0], WDrawn[1] - H0[1]];
+    const drawnHeadRot = set.drawn[headAnchorBone] ?? headRestRot;
+    const { origin: H, rotDeg: headRot } = finalHeadPose(headAnchorBone, i);
+    const dRotRad = HEAD_ANCHOR_FRAME === 'world-fixed' ? 0 : wrap(headRot - drawnHeadRot) / DEG;
+    const cosH = Math.cos(dRotRad);
+    const sinH = Math.sin(dRotRad);
+    const targetTip: Pt = [
+      H[0] + dWorld0[0] * cosH - dWorld0[1] * sinH,
+      H[1] + dWorld0[0] * sinH + dWorld0[1] * cosH,
+    ];
+    const shoulder = posedOrigin(b0, i);
+    const place = reachLimit(H, targetTip, shoulder, l0, l1);
+    const P = place.point;
+    const side: 1 | -1 = wrap(drawn1 + d1 - (drawn0 + d0)) >= 0 ? 1 : -1;
+    const sol = twoBone(shoulder, P, l0, l1, side);
+    const turn0 = set.turn[b0];
+    const turn1 = set.turn[b1];
+    let a0 = sol.upper !== null ? wrap(sol.upper - d0) : drawn0;
+    let a1 = sol.upper !== null ? wrap(sol.fore - d1) : drawn1;
+    let upperHeld = false;
+    let foreHeld = false;
+    if (turn0 !== undefined) {
+      const tt0 = wrap(a0 - drawn0);
+      const cl0 = Math.min(Math.max(tt0, turn0[0]), turn0[1]);
+      if (Math.abs(cl0 - tt0) > RANGE_SLACK) {
+        upperHeld = true;
+        a0 = wrap(drawn0 + cl0);
+        const r0 = (a0 + d0) / DEG;
+        const E: Pt = [shoulder[0] + l0 * Math.cos(r0), shoulder[1] + l0 * Math.sin(r0)];
+        a1 = wrap(Math.atan2(P[1] - E[1], P[0] - E[0]) * DEG - d1);
+      }
+    }
+    if (turn1 !== undefined) {
+      const tt1 = wrap(a1 - drawn1);
+      const cl1 = Math.min(Math.max(tt1, turn1[0]), turn1[1]);
+      if (Math.abs(cl1 - tt1) > RANGE_SLACK) {
+        foreHeld = true;
+        a1 = wrap(drawn1 + cl1);
+      }
+    }
+    const r0 = (a0 + d0) / DEG;
+    const r1 = (a1 + d1) / DEG;
+    const achievedTip: Pt = [
+      shoulder[0] + l0 * Math.cos(r0) + l1 * Math.cos(r1),
+      shoulder[1] + l0 * Math.sin(r0) + l1 * Math.sin(r1),
+    ];
+    const residual = Math.hypot(achievedTip[0] - targetTip[0], achievedTip[1] - targetTip[1]);
+    const saturated = (place.how !== 'in' || upperHeld || foreHeld) && residual > 1e-3;
+    return { a0, a1, targetTip, placedTip: P, achievedTip, residual, saturated, upperHeld };
+  };
   /**
    * #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
@@ -1595,6 +1745,7 @@ export function retarget(rest: Rest, map: JointMap, frames: ReadonlyArray<Partia
     };
     const isChainHeadPlaced = (set: (typeof map.alternates)[number], c: Chain, drawn: number | undefined): boolean => {
       if (headOk === null) return false;
+      if (set.anchor?.includes(c.name) === true) return true;
       const wJoint = c.joints[c.joints.length - 1];
       const ea = set.pose[headOk.joints[0]];
       const eb = set.pose[headOk.joints[1]];
@@ -1736,6 +1887,8 @@ export function retarget(rest: Rest, map: JointMap, frames: ReadonlyArray<Partia
         const upperAsked: number[] = [];
         const upperOver: number[] = [];
         const heldMiss: number[] = [];
+        const isHeadAnchored = HEAD_ANCHOR_FRAME !== 'off' && set.anchor?.includes(c.name) === true;
+        if (isHeadAnchored) job.saturated = [];
         for (const i of span) {
           const h = pairOn(anchor, i);
           const rc = refCentre(i);
@@ -1745,6 +1898,25 @@ export function retarget(rest: Rest, map: JointMap, frames: ReadonlyArray<Partia
           job.reference.push(ref);
           job.before.push([(w[0] - h.centre[0]) / rigEye, (w[1] - h.centre[1]) / rigEye]);
           const shoulder = posedOrigin(b0, i);
+          if (isHeadAnchored) {
+            const ha = solveHeadAnchorFrame(set, c, i);
+            if (ha !== null) {
+              job.farthest = Math.max(job.farthest, Math.hypot(ha.targetTip[0] - shoulder[0], ha.targetTip[1] - shoulder[1]));
+              job.placed.push([(ha.placedTip[0] - h.centre[0]) / rigEye, (ha.placedTip[1] - h.centre[1]) / rigEye]);
+              if (ha.upperHeld) job.upperHeld.push(i);
+              if (ha.saturated) job.saturated!.push({ frame: i, residual: r3(ha.residual) });
+              const tt0 = turn0 === undefined ? 0 : wrap(ha.a0 - set.drawn[b0]!);
+              const tt1 = turn1 === undefined ? 0 : wrap(ha.a1 - set.drawn[b1]!);
+              upperAsked.push(tt0);
+              upperOver.push(0);
+              foreAsked.push(tt1);
+              foreOver.push(0);
+              heldMiss.push(ha.saturated ? ha.residual / rigEye : 0);
+              t0[i] = ha.a0;
+              t1[i] = ha.a1;
+              continue;
+            }
+          }
           const target: Pt = [h.centre[0] + ref[0] * rigEye, h.centre[1] + ref[1] * rigEye];
           let solveTarget: Pt = target;
           if (up && l0 / rigEye <= 3.5 && (turn0 !== undefined || turn1 !== undefined)) {
@@ -1877,12 +2049,28 @@ export function retarget(rest: Rest, map: JointMap, frames: ReadonlyArray<Partia
       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.
+  // #188 / #191: Even without --raised-by-head, apply symmetric normalisation, support-arm anchoring, and head-anchored IK 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.anchor !== undefined && headOk === null && hipsOk === null && HEAD_ANCHOR_FRAME !== 'off') {
+      for (const cn of set.anchor) {
+        if (!s.chains.includes(cn)) continue;
+        const c = map.chains.find((x) => x.name === cn);
+        if (!c || c.bones.length < 2) continue;
+        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 ha = solveHeadAnchorFrame(set, c, i);
+          if (ha !== null) {
+            t0[i] = ha.a0;
+            t1[i] = ha.a1;
+          }
+        }
+      }
+    }
     if (set.support !== undefined) {
       for (const cn of s.chains) {
         const c = map.chains.find((x) => x.name === cn)!;
@@ -1944,6 +2132,7 @@ export function retarget(rest: Rest, map: JointMap, frames: ReadonlyArray<Partia
       worst: { before: worst(job.before), after: worst(after), placed: r6(Math.max(...after.map((v, k) => Math.hypot(v[0] - job.placed[k]![0], v[1] - job.placed[k]![1])))) },
       short,
       upperHeld: job.upperHeld,
+      ...(job.saturated !== undefined ? { saturated: job.saturated } : {}),
       reach: { min: r6(Math.abs(job.l0 - job.l1)), max: r6(job.l0 + job.l1), farthest: r6(job.farthest) },
     };
     // The unit sits after `seconds`, as the report has always written it.
@@ -1958,15 +2147,38 @@ export function retarget(rest: Rest, map: JointMap, frames: ReadonlyArray<Partia
       const [lo, hi] = s.frames;
       if (lo <= 0 || hi + 1 >= n) continue;
       if (cov?.[lo - 1] !== true && cov?.[hi + 1] !== true) continue;
+      if (cov?.[lo - 1] === true && cov?.[hi + 1] === true && hi - lo + 1 <= 10) continue;
+      const ch = map.chains.find((c) => c.name === s.chain);
+      const bIdx = ch !== undefined ? ch.bones.indexOf(s.bone) : -1;
+      const parentTg = ch !== undefined && bIdx > 0 ? targets.get(ch.bones[bIdx - 1]!) : undefined;
       const tg = targets.get(s.bone)!;
-      const startA = tg[lo - 1]!;
-      const total = wrap(tg[hi + 1]! - startA);
+      const startA = parentTg !== undefined ? wrap(tg[lo - 1]! - parentTg[lo - 1]!) : tg[lo - 1]!;
+      const endA = parentTg !== undefined ? wrap(tg[hi + 1]! - parentTg[hi + 1]!) : tg[hi + 1]!;
+      const total = wrap(endA - startA);
       const steps = hi - lo + 2;
       for (let k = lo; k <= hi; k++) {
-        tg[k] = wrap(startA + ((k - lo + 1) / steps) * total);
+        const localA = wrap(startA + ((k - lo + 1) / steps) * total);
+        tg[k] = parentTg !== undefined ? wrap(parentTg[k]! + localA) : localA;
       }
       s.step = r3(total / steps);
     }
+    const interpolateChainInJointSpace = (ch: Chain, i0: number, i1: number) => {
+      const steps = i1 - i0;
+      if (steps < 2 || i0 < 0 || i1 >= n) return;
+      for (let bIdx = 0; bIdx < ch.bones.length; bIdx++) {
+        const b = ch.bones[bIdx]!;
+        const tg = targets.get(b);
+        if (!tg) continue;
+        const parentTg = bIdx > 0 ? targets.get(ch.bones[bIdx - 1]!) : undefined;
+        const startA = parentTg !== undefined ? wrap(tg[i0]! - parentTg[i0]!) : tg[i0]!;
+        const endA = parentTg !== undefined ? wrap(tg[i1]! - parentTg[i1]!) : tg[i1]!;
+        const total = wrap(endA - startA);
+        for (let k = i0 + 1; k < i1; k++) {
+          const localA = wrap(startA + ((k - i0) / steps) * total);
+          tg[k] = parentTg !== undefined ? wrap(parentTg[k]! + localA) : localA;
+        }
+      }
+    };
     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]);
@@ -1978,19 +2190,10 @@ export function retarget(rest: Rest, map: JointMap, frames: ReadonlyArray<Partia
       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);
-        }
-      }
+      interpolateChainInJointSpace(ch, lo - 1, hi + 1);
     }
   }
-  // #188: Cover the full shown/bridged span of symmetric sets and support-arm sets after short interpolation.
+  // #188 / #191 / #206: Cover the full shown/bridged span of symmetric sets, support-arm sets, and head-anchored chains 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)!;
@@ -2001,6 +2204,46 @@ export function retarget(rest: Rest, map: JointMap, frames: ReadonlyArray<Partia
     while (loShow - 1 >= 0 && isSetShownAt(loShow - 1)) loShow--;
     let hiShow = s.frames[1];
     while (hiShow + 1 < n && isSetShownAt(hiShow + 1)) hiShow++;
+    if (set.anchor !== undefined && HEAD_ANCHOR_FRAME !== 'off') {
+      for (const cn of set.anchor) {
+        const c = map.chains.find((x) => x.name === cn);
+        if (!c || c.bones.length < 2) continue;
+        const chainSlots = setSlots.filter(([sl]) => {
+          const sb = slots.get(sl)?.bone;
+          return sb !== undefined && c.bones.includes(sb);
+        });
+        const isChainShownAt = (i: number): boolean =>
+          chainSlots.length > 0
+            ? chainSlots.every(([sl, att]) => sw.shown.get(sl)?.[i] === att)
+            : isSetShownAt(i);
+        let loC = s.frames[0];
+        while (loC - 1 >= 0 && isChainShownAt(loC - 1)) loC--;
+        let hiC = s.frames[1];
+        while (hiC + 1 < n && isChainShownAt(hiC + 1)) hiC++;
+        const t0 = targets.get(c.bones[0]!)!;
+        const t1 = targets.get(c.bones[1]!)!;
+        for (let i = loC; i <= hiC; i++) {
+          const ha = solveHeadAnchorFrame(set, c, i);
+          if (ha !== null) {
+            t0[i] = ha.a0;
+            t1[i] = ha.a1;
+          }
+        }
+        // If `short` or `chainHolds` ramp-interpolated the boundary frame immediately outside the
+        // anchored chain's shown window (`loC - 1` or `hiC + 1`) while a neighbouring set's
+        // attachment is still displayed on that bone, restore that boundary frame from the
+        // neighbouring set's clamped key (`loC - 2` / `hiC + 2`) so the neighbouring set's art
+        // is not bent toward the anchored pose before its slot switches.
+        if (loC >= 2 && covered.get(cn)?.[loC - 1] === true) {
+          t0[loC - 1] = t0[loC - 2]!;
+          t1[loC - 1] = t1[loC - 2]!;
+        }
+        if (hiC + 2 < n && covered.get(cn)?.[hiC + 1] === true) {
+          t0[hiC + 1] = t0[hiC + 2]!;
+          t1[hiC + 1] = t1[hiC + 2]!;
+        }
+      }
+    }
     if (set.symmetric === true) {
       for (let i = loShow; i <= s.frames[1]; i++) solveSymmetricFrame(set, i);
       if (loShow < s.frames[0]) {
@@ -2010,12 +2253,16 @@ export function retarget(rest: Rest, map: JointMap, frames: ReadonlyArray<Partia
           for (const cn of set.chains) {
             const c = map.chains.find((x) => x.name === cn);
             if (!c) continue;
-            for (const b of c.bones) {
+            for (let bIdx = 0; bIdx < c.bones.length; bIdx++) {
+              const b = c.bones[bIdx]!;
               const tg = targets.get(b)!;
-              const startA = tg[loRamp]!;
-              const total = wrap(tg[loShow]! - startA);
+              const parentTg = bIdx > 0 ? targets.get(c.bones[bIdx - 1]!) : undefined;
+              const startA = parentTg !== undefined ? wrap(tg[loRamp]! - parentTg[loRamp]!) : tg[loRamp]!;
+              const endA = parentTg !== undefined ? wrap(tg[loShow]! - parentTg[loShow]!) : tg[loShow]!;
+              const total = wrap(endA - startA);
               for (let k = loRamp + 1; k < loShow; k++) {
-                tg[k] = wrap(startA + ((k - loRamp) / steps) * total);
+                const localA = wrap(startA + ((k - loRamp) / steps) * total);
+                tg[k] = parentTg !== undefined ? wrap(parentTg[k]! + localA) : localA;
               }
             }
           }
@@ -2030,23 +2277,43 @@ export function retarget(rest: Rest, map: JointMap, frames: ReadonlyArray<Partia
           const [cR, cL] = S0_0[0] <= S0_1[0] ? [c0, c1] : [c1, c0];
           const bR0 = cR.bones[0]!;
           const bL0 = cL.bones[0]!;
+          const bR1 = cR.bones[1]!;
+          const bL1 = cL.bones[1]!;
           const SR0 = rigPoint(rest, bR0)!;
-          const ER0 = rigPoint(rest, cR.bones[1]!)!;
+          const ER0 = rigPoint(rest, bR1)!;
           const SL0 = rigPoint(rest, bL0)!;
-          const EL0 = rigPoint(rest, cL.bones[1]!)!;
+          const EL0 = rigPoint(rest, bL1)!;
           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 iEnd = s.frames[1];
+          const iNext = Math.min(n - 1, hiShow + 1);
+          const spanOut = Math.max(1, iNext - iEnd);
+          const startR0 = targets.get(bR0)![iEnd]!;
+          const startL0 = targets.get(bL0)![iEnd]!;
+          const drawnR0 = set.drawn[bR0] ?? startR0;
+          const drawnL0 = set.drawn[bL0] ?? startL0;
+          const drawnR1 = set.drawn[bR1] ?? targets.get(bR1)![iEnd]!;
+          const drawnL1 = set.drawn[bL1] ?? targets.get(bL1)![iEnd]!;
+          const inR1 = wrap(drawnR1 + (set.turn[bR1]?.[0] ?? 0));
+          const inL1 = wrap(drawnL1 + 0.6 * (set.turn[bL1]?.[1] ?? 0));
+          const endR0 = targets.get(bR0)![iNext]!;
+          const endL0 = targets.get(bL0)![iNext]!;
+          for (let i = iEnd + 1; i <= hiShow; i++) {
+            const u = (i - iEnd) / spanOut;
+            const w = 1 - u;
+            const alpha = 0.25 * u + 0.75 * u * u;
             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 baseR = wrap(startR0 + alpha * wrap(endR0 - startR0));
+            const baseL = wrap(startL0 + alpha * wrap(endL0 - startL0));
+            let lo = -30;
+            let hi = 30;
+            const dR = (deg: number) => (deg < 0 ? 0.25 * deg : deg);
+            const dL = (deg: number) => (deg > 0 ? 0.25 * deg : deg);
             const evalD = (deg: number) =>
-              sl[1] + lL0 * Math.sin((baseL + deg + dL0) / DEG) - (sr[1] + lR0 * Math.sin((baseR + deg + dR0) / DEG));
+              0.4 * w * (sl[1] - sr[1]) + lL0 * Math.sin((baseL + dL(deg) + dL0) / DEG) - lR0 * Math.sin((baseR + dR(deg) + dR0) / DEG);
             let fLo = evalD(lo);
             for (let it = 0; it < 32; it++) {
               const mid = 0.5 * (lo + hi);
@@ -2057,24 +2324,50 @@ export function retarget(rest: Rest, map: JointMap, frames: ReadonlyArray<Partia
               } else hi = mid;
             }
             const deg = 0.5 * (lo + hi);
-            targets.get(bR0)![i] = wrap(baseR + deg);
-            targets.get(bL0)![i] = wrap(baseL + deg);
+            const aR0 = wrap(baseR + dR(deg));
+            const aL0 = wrap(baseL + dL(deg));
+            targets.get(bR0)![i] = aR0;
+            targets.get(bL0)![i] = aL0;
+            targets.get(bR1)![i] = wrap(inR1 + 0.45 * wrap(aR0 - drawnR0));
+            targets.get(bL1)![i] = wrap(inL1 + 0.45 * wrap(aL0 - drawnL0));
           }
         }
       }
     }
+    if (set.anchor === undefined && set.symmetric !== true && set.support === undefined && loShow < s.frames[0]) {
+      for (const cn of s.chains) {
+        const c = map.chains.find((x) => x.name === cn);
+        if (!c || c.bones.length < 2) continue;
+        const b1 = c.bones[1]!;
+        const t1 = targets.get(b1)!;
+        const entryWorld1 = t1[s.frames[0]]!;
+        for (let i = loShow; i < s.frames[0]; i++) {
+          t1[i] = entryWorld1;
+        }
+      }
+    }
     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) {
+          for (let i = loShow; i <= hiShow; i++) solveSupportChainFrame(set, c, i);
+          if (loGap < loShow && loGap >= 1) {
+            const i0 = loGap - 1;
+            const i1 = loShow;
+            const steps = i1 - i0;
+            for (let bIdx = 0; bIdx < c.bones.length; bIdx++) {
+              const b = c.bones[bIdx]!;
               const tg = targets.get(b)!;
-              tg[anchorStart - 1] = wrap(tg[anchorStart - 2]! + 0.5 * wrap(tg[anchorStart]! - tg[anchorStart - 2]!));
+              const parentTg = bIdx > 0 ? targets.get(c.bones[bIdx - 1]!) : undefined;
+              const startA = parentTg !== undefined ? wrap(tg[i0]! - parentTg[i0]!) : tg[i0]!;
+              const endA = parentTg !== undefined ? wrap(tg[i1]! - parentTg[i1]!) : tg[i1]!;
+              const total = wrap(endA - startA);
+              for (let k = loGap; k < loShow; k++) {
+                const localA = wrap(startA + ((k - i0) / steps) * total);
+                tg[k] = parentTg !== undefined ? wrap(parentTg[k]! + localA) : localA;
+              }
             }
           }
         } else if (c.bones.length >= 2) {
@@ -2098,6 +2391,18 @@ export function retarget(rest: Rest, map: JointMap, frames: ReadonlyArray<Partia
               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];
             }
+            if (loGap <= loShow && loGap >= 1 && loShow + 1 <= hiShow) {
+              const i0 = loGap - 1;
+              const i1 = loShow + 1;
+              const steps = i1 - i0;
+              const startLocal = wrap(t1[i0]! - t0[i0]!);
+              const endLocal = wrap(t1[i1]! - t0[i1]!);
+              const totalLocal = wrap(endLocal - startLocal);
+              for (let k = loGap; k <= loShow; k++) {
+                const localA = wrap(startLocal + ((k - i0) / steps) * totalLocal);
+                t1[k] = wrap(t0[k]! + localA);
+              }
+            }
           }
         }
       }
@@ -2123,9 +2428,11 @@ export function retarget(rest: Rest, map: JointMap, frames: ReadonlyArray<Partia
   }
   const solvedKey = (b: string, i: number) => legPoses?.[i]!.solved.get(b);
 
-  // #190: couple the vertical residual removed by the neck-length clamp into head.rotate
-  // in phase (+NOD_RESIDUAL_HEAD_GAIN °/unit), adding 0 on frames where the clamp did not act.
-  if (headNodReading !== null) {
+  // #190 / #205: when the neck-length clamp acts on the sequence, couple the clamped
+  // head.translate.y (`clampedY`, the signal the gains were calibrated against) into
+  // head.rotate (+NOD_RESIDUAL_HEAD_GAIN °/unit) and pitch_dial.rotate (+NOD_RESIDUAL_PITCH_GAIN °/unit).
+  const nodCoupled = headNodReading !== null && headNodReading.residual.some((r) => r !== 0) ? headNodReading.clampedY : null;
+  if (headNodReading !== null && nodCoupled !== null) {
     const hb = headNodReading.bone;
     const tg = targets.get(hb);
     if (tg !== undefined) {
@@ -2134,9 +2441,9 @@ export function retarget(rest: Rest, map: JointMap, frames: ReadonlyArray<Partia
       const limits = hc?.range[hb];
       const cov = hc !== undefined ? covered.get(hc.name) : undefined;
       for (let i = 0; i < n; i++) {
-        const res = headNodReading.residual[i]!;
-        if (res === 0) continue;
-        let next = wrap(tg[i]! + NOD_RESIDUAL_HEAD_GAIN * res);
+        const nodY = nodCoupled[i]!;
+        if (nodY === 0) continue;
+        let next = wrap(tg[i]! + NOD_RESIDUAL_HEAD_GAIN * nodY);
         if (limits !== undefined && cov?.[i] !== true) {
           const key = wrap((next - restOf.get(hb)!) - (above === null ? 0 : turn(above, i)));
           if (overflow(key, limits) > RANGE_SLACK) {
@@ -2183,7 +2490,7 @@ export function retarget(rest: Rest, map: JointMap, frames: ReadonlyArray<Partia
       const h = heldOf('l_ear');
       return 'never' in h ? null : h.at;
     })();
-    face = readFace(map.face, series.get('nose')!, series.get('r_eye')!, series.get('l_eye')!, rEar, lEar, headNodReading?.residual ?? null, NOD_RESIDUAL_PITCH_GAIN);
+    face = readFace(map.face, series.get('nose')!, series.get('r_eye')!, series.get('l_eye')!, rEar, lEar, nodCoupled, NOD_RESIDUAL_PITCH_GAIN);
     for (const axis of ['yaw', 'pitch'] as const) {
       const ax = face[axis];
       if (ax === undefined) continue;
@@ -2381,6 +2688,20 @@ function headOf(map: JointMap): Head | { problem: string } {
   return { problem: `${lead}; no chain of the map carries the eye line (joints r_eye → l_eye), so the rig has no eye points to measure` };
 }
 
+/** The rig's head bone (the bone carrying `r_eye → l_eye` or `l_eye → r_eye` in the map), or null if no chain carries the eye line. */
+function headBoneOf(map: JointMap): string | null {
+  for (const c of map.chains) {
+    for (let k = 0; k + 1 < c.joints.length; k++) {
+      const a = c.joints[k]!;
+      const b = c.joints[k + 1]!;
+      if ((a === 'r_eye' && b === 'l_eye') || (a === 'l_eye' && b === 'r_eye')) {
+        return c.bones[k] ?? null;
+      }
+    }
+  }
+  return null;
+}
+
 type ShortSpan = Omit<Short, 'chain' | 'bone' | 'joints'>;
 
 /**

package/src/switch.ts

@@ -787,14 +787,14 @@ export function selectSwitches(map: JointMap, targets: ReadonlyMap<string, reado
         }
         const tight0 = isTightSet(set0, cn);
         const tight1 = isTightSet(set1, cn);
-        if (tight0 && set0 !== set1) {
+        if (tight0 && set0 !== set1 && g1 - g0 + 1 <= 10) {
           let i = g0;
           while (i <= g1 && rawChainMax(set0, cn, i) <= opts.switchTolerance + hyst) {
             cClamp.get(cn)![i] = set0;
             i++;
           }
         }
-        if (tight1 && set0 !== set1) {
+        if (tight1 && set0 !== set1 && g1 - g0 + 1 <= 10) {
           let enter1 = g1 + 1;
           for (let i = g0; i <= g1; i++) {
             if (rawChainMax(set1, cn, i) <= opts.switchTolerance) {
@@ -809,63 +809,53 @@ export function selectSwitches(map: JointMap, targets: ReadonlyMap<string, reado
             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);
       }
-      // #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
+      // #187 Rule 1 & Rule 2 / #206: when two gesture sets are adjacent (gap <= 10 frames),
+      // unwrap any bone that turned the long way (> 180° through inverted angles in its own joint
+      // space — world angle for a chain's root bone, parent-local angle for a child bone) 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);
+      const bridgeDirect = set0 !== set1 && g1 - g0 + 1 <= 10;
       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);
+        for (const cn of switchingChains) {
+          const ch = map.chains.find((c) => c.name === cn);
+          if (!ch) continue;
+          for (let bIdx = 0; bIdx < ch.bones.length; bIdx++) {
+            const b = ch.bones[bIdx]!;
+            const parentBone = bIdx > 0 ? ch.bones[bIdx - 1] : undefined;
+            const tg = targets.get(b) as number[] | undefined;
+            const parentTg = parentBone !== undefined ? targets.get(parentBone) : undefined;
+            const d0World = set0.drawn[b];
+            const d1World = set1.drawn[b];
+            if (tg === undefined || d0World === undefined || d1World === undefined) continue;
+            const pd0 = parentBone !== undefined ? set0.drawn[parentBone] : undefined;
+            const pd1 = parentBone !== undefined ? set1.drawn[parentBone] : undefined;
+            const jointAngle = (i: number): number =>
+              parentTg !== undefined ? wrap(tg[i]! - parentTg[i]!) : tg[i]!;
+            const d0 = pd0 !== undefined ? wrap(d0World - pd0) : d0World;
+            const d1 = pd1 !== undefined ? wrap(d1World - pd1) : d1World;
+            const i0 = sw0.frames[1];
+            const i1 = sw1.frames[0];
+            const startA = jointAngle(i0);
+            const endA = jointAngle(i1);
+            const unwrapped: number[] = [startA];
+            for (let i = i0 + 1; i <= i1; i++) {
+              unwrapped.push(unwrapped[unwrapped.length - 1]! + wrap(jointAngle(i) - jointAngle(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 = jointAngle(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;
+                const localA = wrap(startA + p * shortTurn);
+                tg[i] = parentTg !== undefined ? wrap(parentTg[i]! + localA) : localA;
+              }
             }
           }
         }
@@ -904,7 +894,8 @@ export function selectSwitches(map: JointMap, targets: ReadonlyMap<string, reado
             ? 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 ||
+            switchingChains.length === 1 ||
+            rootBones.length === 0 ||
             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;
@@ -912,6 +903,9 @@ export function selectSwitches(map: JointMap, targets: ReadonlyMap<string, reado
           }
         }
       }
+      const syncBridgeClamp = (cn: string, i: number, picked: AlternateSet) => {
+        if (isTightSet(picked, cn)) cClamp.get(cn)![i] = picked;
+      };
       const anyHeldBehind = switchingChains.some((cn) => {
         const arr = cPick.get(cn)!;
         for (let i = g0; i <= g1; i++) if (arr[i] === null) return false;
@@ -924,7 +918,11 @@ export function selectSwitches(map: JointMap, targets: ReadonlyMap<string, reado
         });
         if (bridgeDirect) {
           for (const cn of switchingChains) {
-            for (let i = g0; i <= g1; i++) cPick.get(cn)![i] = i < tSwitch ? set0 : set1;
+            for (let i = g0; i <= g1; i++) {
+              const picked = i < tSwitch ? set0 : set1;
+              cPick.get(cn)![i] = picked;
+              syncBridgeClamp(cn, i, picked);
+            }
           }
         } else if (!frontNear) for (const cn of chains) for (let i = g0; i <= g1; i++) cPick.get(cn)![i] = set0;
       } else {
@@ -980,7 +978,11 @@ export function selectSwitches(map: JointMap, targets: ReadonlyMap<string, reado
         }
         if (bridgeDirect) {
           for (const cn of switchingChains) {
-            for (let i = g0; i <= g1; i++) cPick.get(cn)![i] = i < tSwitch ? set0 : set1;
+            for (let i = g0; i <= g1; i++) {
+              const picked = i < tSwitch ? set0 : set1;
+              cPick.get(cn)![i] = picked;
+              syncBridgeClamp(cn, i, picked);
+            }
           }
         }
       }
@@ -1224,7 +1226,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, b0]: [number, number]) => {
+  const clampSpan = (set: AlternateSet, bone: string, [a, b]: [number, number]) => {
     const limits = set.turn[bone];
     if (limits === undefined) return;
     const drawn = set.drawn[bone]!;
@@ -1236,28 +1238,14 @@ export function clampArt(switches: readonly Switch[], map: JointMap, targets: Ma
       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 prevNearSw = switches.some((s) => s.frames[1] < a && a - s.frames[1] <= 11);
+    const nextNearSw = switches.some((s) => s.frames[0] > b && s.frames[0] - b <= 11);
     const da = delta(a);
     const db = delta(b);
-    const easeIn = a > 0 && da !== 0 && Math.sign(delta(a - 1)) === Math.sign(da) && !tightHold
+    const easeIn = a > 0 && da !== 0 && Math.sign(delta(a - 1)) === Math.sign(da) && !(tightHold && prevNearSw)
       ? 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) && !tightHold && !trimmedExit
+    const easeOut = b + 1 < n && db !== 0 && Math.sign(delta(b + 1)) === Math.sign(db) && !(tightHold && nextNearSw)
       ? Math.max(ART_EASE_FRAMES, Math.ceil(Math.abs(db) / ART_EASE_STEP) - 1)
       : 0;
     for (let i = a; i <= b; i++) {
@@ -1426,6 +1414,8 @@ export interface Raised {
   short: ReachShort[];
   /** The frames whose upper arm the set's `turn` held: the forearm re-aimed at the placed wrist. */
   upperHeld: number[];
+  /** For a head-anchored chain (`anchor`, rig-c/pose#191): each frame where the set's `turn` clamp saturated and left a non-zero wrist residual, in rig world units. */
+  saturated?: Array<{ frame: number; residual: number }>;
   /** The arm's reach (from |l0 − l1| to l0 + l1, world units from the shoulder) and the farthest target from the shoulder over the span. */
   reach: { min: number; max: number; farthest: number };
 }
@@ -1459,7 +1449,8 @@ export function raisedLine(e: Raised | ByHip, times: readonly number[]): string
   const w = anchorOf(e);
   const units = 'hips' in e ? e.hips : e.eyes;
   const med = (vs: readonly P2[]): P2 => [median(vs.map((v) => v[0])), median(vs.map((v) => v[1]))];
-  const held = e.upperHeld.length === 0 ? 'the upper arm within its turn on every frame' : `the upper arm held by the set's turn on ${e.upperHeld.length} frame(s) (${framesText(e.upperHeld)}), the forearm re-aimed`;
+  const satText = e.saturated !== undefined && e.saturated.length > 0 ? `; residual ${e.saturated.map((s) => `f${s.frame} ${s.residual.toFixed(2)}u`).join(', ')}` : '';
+  const held = e.upperHeld.length === 0 ? 'the upper arm within its turn on every frame' : `the upper arm held by the set's turn on ${e.upperHeld.length} frame(s) (${framesText(e.upperHeld)}${satText}), the forearm re-aimed`;
   const out = e.short.length === 0 ? 'every target in reach' : `out of reach on ${e.short.reduce((k, s) => k + s.frames[1] - s.frames[0] + 1, 0)} frame(s) (REACH)`;
   return `set "${e.set}" chain "${e.chain}" ${spanOf(e.frames, times)}: the wrist placed against ${w.against}; ${w.unitOne} (median) rig ${units.rig.toFixed(2)} units, reference ${units.reference.toFixed(2)} px; wrist − ${w.centre} in ${w.unit} (x right, y up), median reference ${xy(med(e.reference))}, placed ${xy(med(e.placed))}, before ${xy(med(e.before))}, after ${xy(med(e.after))}; worst |rig − reference| before ${xy(e.worst.before)}, after ${xy(e.worst.after)}; worst |after − placed| ${e.worst.placed.toFixed(2)}; ${held}; ${out}`;
 }