rig-parts 1.71.0 → 1.71.1

package/docs/AUTHORING.md

@@ -136,7 +136,7 @@ read by no CPU stage).
 | `motion.animations_from` | rig; check (named; read for folds) | optional, never proposed (issue #183): a path, relative to the config file's directory, to a file in rig-c's motion-spec shape, `{"spec": "rigc-motion/1", "animations": {"<name>": {"duration": …, "tracks": [...]}, …}}` — an expression, a gesture, anything beside the idle. On every `rig` and `build` each of its animations is written into `rig/motion.json` after `idle`, as read: nothing added, re-keyed or judged here (except `derive` keys on `turn`/`tilt`, issue #436, and `{"t": …, "set": "<name>" \| null}` keys on slot `"attachment"` tracks, issue #473, which expand to `"v": "<set>_<slot>"` or `"v": null` when the set hides the slot, or `"v": "<slot>"` for `null`, refused with `CONFIG_SET_COVERS_SLOT` when the set is undeclared or does not cover the track's slot), and each is rigc's to accept or refuse at the rig stage's gate, in rigc's words. It may name what `motion.json` already holds — the bones `bones` declares, the easings `shut` and `open`, the groups `eyes` and `brows` when the blink writes them — and nothing else from the file reaches it. The loader refuses, every problem at once: no such file or one that cannot be read (`CONFIG_FILE_PRESENT`), text that is not JSON (`CONFIG_IS_JSON`), a file that is not an object, a `spec` other than `"rigc-motion/1"`, an `animations` that is not a table of objects (`CONFIG_FIELD_TYPE`), any other key — rig-c's `easings`, `groups`, `setup`, `physics`, `mix`, `archetype` and `cut` included, which would be read and not written (`CONFIG_KEY_KNOWN`), an animation named `idle` (`CONFIG_ANIMATION_NAME_FREE`), and a key written twice in one object of the file, which JSON would fold into its last value without a word (`CONFIG_KEY_UNIQUE`). `check` names the others on one line (`beside the idle: …`) and reads each for folds, with the idle — `ANIMATIONS_DO_NOT_FOLD` (§7, issues #320, #333); every other bar reads the idle. Absent, `motion.json` holds the idle alone, byte for byte as before, and `check` reads that idle for folds |
 | `constraints` | rig (handed to rig-c as `rig.json`'s `constraints`); `compare` and the coverage lines (roles) | **authored**, optional; `propose` writes none, but with `--cloth` (issue #364), where it writes the recipe's physics and swing transforms (*Recipe: cloth and hair that answer the world*, below). A list of constraints in **rig-c's own rig-spec shape** (`RigConstraint`: `ik`, `transform`, `path`, `physics`, `slider` — rig-c's `src/rig.ts` documents every field), in the order rigc applies them. The loader checks only what this package owns: each entry is an object with a `type` rigc names (`CONFIG_CONSTRAINT_TYPE_KNOWN`) and a non-empty `name`, unique within its kind as rigc finds constraints (`CONFIG_CONSTRAINT_NAME_UNIQUE`; an ik and a transform may share one); every bone it names — `bones`, an ik's `target`, a transform's `source`, a physics or slider constraint's `bone` — is a bone `bones` declares, a chain link as `<chain><i>` (`CONFIG_NAME_RESOLVES`); the bone a constraint follows does not sit under a bone it drives (`CONFIG_CONSTRAINT_TARGET_DETACHED`). Every other field (`mix`, `softness`, `properties`, a path's `slot`, a slider's `animation`) and every value is rigc's to accept or refuse at the rig stage's gate, in rigc's words (`RIG_RIGC_GREEN`) — an ik's `bones` as a shape too: from rig-c 2.15.0 rigc refuses an ik over more than two bones, or over a pair whose second bone is not the first's child (issue #103; this loader refused both itself until then). A note and an `x-` record may ride on an entry; the rig stage leaves them out of what it hands rigc. Under the default `--idle-keys ctl` a two-bone ik whose child link the idle keys is split by that link's control, and rigc refuses the pair: run `rig --idle-keys direct` or `build --idle-keys direct` (the rig stage adds that sentence, naming the flag on the command that ran, to rigc's line; `build` forwards it to its rig stage, issue #95). Each bone a constraint follows is declared to rigc as `invariants.detached` from every bone it drives, which rigc's gate rule `A25` checks |
 | `stops` | rig (handed to rig-c as `rig.json`'s `stops`, and moves slots, mesh weights and child bones on stopped links onto `<link>_d`); `propose --from-config` (`LINT stop on <chain> …`) | **authored**, optional (issues #404, #447): `[{chain, links?, against, at, inward, outward, lower?: {inward, outward}}]` — rig-c's leg stops (`RigStop`, rig-c 2.56.0, `rig-c/src/stop.ts`). `chain` is a chain `bones` declares (`CONFIG_NAME_RESOLVES`, `RIG_NAME_RESOLVES`); `links`, optional, is a non-empty list of links of that chain (`CONFIG_NAME_RESOLVES`, `CONFIG_FIELD_TYPE`), or absent for every link of `chain` in chain order; `against` is a bone `bones` declares, a chain link as `<chain><i>` (`CONFIG_NAME_RESOLVES`, `RIG_NAME_RESOLVES`); `at` is `[x, y]` in `against`'s local space, as rig-c's stop takes it (`CONFIG_FIELD_TYPE`): since each chain link (`leg_r0`, `leg_r1`) is turned to point along its segment (`+x` from origin to next link or tip, `+y` 90° counter-clockwise in Spine world), `at: [d, n]` sits `d` px from `against`'s origin toward its end and `n` px perpendicular to it; `inward`, `outward` and `lower.inward`, `lower.outward` are finite numbers (`CONFIG_FIELD_TYPE`). Every other stop rule — non-negative bounds, each stopped link written by a constraint, `against` not under the stopped chain, the aim not degenerate, `\|rest\| + outward <= 180°` (`RIG_STOP_BOUNDS`) — is rigc's to accept or refuse at the rig stage's gate, in rigc's words (`RIG_RIGC_GREEN`). **Rising-limb / prone geometry (issue #447):** rig-c's `expandStops` aims `<chain>_rest` from `links[0]`'s setup origin at `<chain>_touch` (`at` in `against`'s local frame) and clamps `<link>_d` inside `[rest − inward, rest + outward]`; Spine wraps rotation at `±180°`, so `\|rest\| + outward <= 180°` is required (`RIG_STOP_BOUNDS`). Whenever `<chain>_touch` lies **above** `links[0]`'s root in rig pixels (`ty < y0`, i.e. higher Spine `y` — e.g. stopping a hanging cloth chain against a rising shin `leg_<s1>` in a prone or kneeling pose where the knee sits below `links[0]` and the ankle above it, so positive `at[0]` walks upward along the shin past `links[0]`'s root), `rest` lands in the upper half-plane (`\|rest\| > 90°`) and `\|rest\| + outward` exceeds `180°`. Stop against the descending thigh (`leg_<s0>`), set `links` to start at a link whose root sits above `<chain>_touch`, or omit the stop when the rising shin sits outside the hanging chain's sweep; `propose --from-config` prints `LINT stop on <chain> …` with the exact coordinates and angles when `<chain>_touch` lies above `links[0]`'s root or `\|rest\| + outward > 180°`. For every stopped link `<link>`, the rig stage moves any slot on `<link>`, any mesh weight on `<link>`, and any bone whose parent is `<link>` (a branched cloth tree's branches hanging from `<trunk_last>`, before `--idle-keys ctl` adds `<bone>_ctl` and before `turn` adds `turn_<part>_<bone>`) onto `<link>_d`, the drawn link bone rig-c's `expandStops` creates at `<link>`'s setup frame to carry the clamped rotation. Absent, `rig.json` carries no `stops` and no byte of any output moves |
-| `turn` | rig (adds the turn control or 2.5D head-turn producer) | **proposed** only with `propose --full`/`--head` (issue #251), then corrected, or **authored** for 2.5D depth-sampled head turns (issue #763): `{pivot?, depths?, deform?, band?, radius?, surface?: {radius?}, head?: {pivot?, radius?}, roles?, counter?, grid?, unitDepths?, body?}`. When `roles` is declared (`{<part>: "surface" \| "unit" \| "rear"}`, issue #763; `CONFIG_TURN_ROLE_UNKNOWN`, `CONFIG_TURN_SURFACE_REQUIRED`, `CONFIG_TURN_SURFACE_REGION`), the rig stage runs the 2.5D depth-sampled head-turn producer: it edge-extends each turn-bound part's depth sheet across its transparent border and semi-transparent fringe from the nearest fully opaque (`alpha === 255`) texel before `PAD = 4` clamping (`padTurnDepthSheet`, `DEPTH_SILHOUETTE_SIZE_MISMATCH`), promotes `"surface"` regions to `generator: {kind: "grid", cols, rows, depth}` (`grid`: `[cols, rows]` or `{<part>: [cols, rows]}`, default `[13, 16]`, bounded at `<= 2,400` triangles per slot and `<= 4,000` total, `RIG_TURN_GRID_BUDGET`, `RIG_TURN_SURFACE_DEPTH_REQUIRED`, `RIG_TURN_SHARED_DEPTH_SCALE`), emits `faceshift` and `rear_shift` under `head` (`CONFIG_TURN_HEAD_BONE`, `RIG_TURN_HEAD_BONE`), `<part>_surface` under `faceshift`, and `yaw_dial` and `pitch_dial` under `root` (`CONFIG_TURN_BONE_FREE`, `RIG_TURN_NAME_FREE`), re-parents `"unit"` and `"rear"` bones and mesh weights to `faceshift` and `rear_shift`, samples each `"unit"` bone's depth from the `"surface"` depth sheet at its rest position (or reads `unitDepths.<part>`, `RIG_TURN_UNIT_DEPTH_REQUIRED`), enforces ear occlusion (`ear_r`/`ear_l` drawn before `"surface"` in `assemble.plan`, `CONFIG_TURN_EAR_DRAW_ORDER`, and behind the cheek surface, `RIG_TURN_EAR_DEPTH_BEHIND_CHEEK`), and writes `turn` and `tilt` `derive` tracks (`pivot` default `55` rig px, `counter` default `0.1` in `[0, 1]`, `CONFIG_TURN_COUNTER_RANGE`). `depths` holds, per part, the See-through layer's `depth_median` the part came from (larger = further back), read from the run the part was assembled from; a `painting:` patch has none and is not carried. A rider (issue #271) — a part from an `eyewhite`, `irides`, `eyelash`, `eyebrow`, `nose` or `mouth` layer — is drafted at the `face` part's depth, 0.001 nearer when parts.json draws it after the face and 0.001 further when before: See-through makes no depth of its own for the eye group (it cuts them from one depth map of the combined eyes) and clamps nose and mouth to the face's median − 0.001, and the two runs' own medians for these layers disagreed by up to 0.47 and swapped their order against the face. Every other layer — ears, headwear and earwear included — keeps its own median, unless it rides another part's bone. With no `face` part, or more than one, the riders keep their own and a note says so. A rider by bone (issue #535) — a part every *ownable* bone of which (a chain link, or a bone no other bone hangs from; `head`, `chest` and any bone with a child are shared and never count on their own) is *hosted* by another carried part, the host of a bone being the carried part that binds it (its region's bone; a mesh's `segments`, `contour` and `auto` regions' bones) with the most `opaque_px`, the earlier in parts.json on a tie, and which hosts no bone itself — is drafted at its host's depth, 0.001 nearer when drawn after the host and 0.001 further when before, and a note names the host, the bones and its own median: a pin, clip or ornament on the back hair's links travels with the back hair, not with its own layer's depth. `propose` reads the proposal's own `bones`, `meshes` and `regions`; the face riders are read by their tag first and never by their bones. A part bound to two hosts' bones rides neither and a note says so. In the rig stage, an authored depth on a rider by bone whose fraction differs from its host's by more than 0.1 of the dial (`TURN_RIDER_APART`, a share of `pivot − nearest`) is refused (`CONFIG_TURN_RIDER_DEPTH`); the host is read off `parts.json`'s `opaque_px`, so the config loader cannot see it. One note lists each part's depth and where it came from; a carrier the other run places more than 10 % of `pivot − nearest` away gets a note naming both values and the run read — the two runs are not reconciled. `pivot` is the depth that stays put; `propose` drafts the mean of the parts' depths weighted by `opaque_px`, the one depth at which the painted pixels' centroid does not slide under the dial. The rig stage adds a bone `turn` under `root` at its origin that nothing keys — its local x is the dial, in rig px — and carries each part by `(pivot − depth) / (pivot − nearest depth)` of it: the nearest part all of it, a part behind the pivot the other way, a part at the pivot not at all. Each part rides leaf twins (`turn_<part>_<bone>`, an identity child of every bone its slot and weights bind) moved by one `transform` constraint (`turn_<part>`, after the config's own); the idle's keys, the `<bone>_ctl` controls and a physics constraint stay on the bones, and the dial moves none of them. Optional `deform` (`Partial<FaceDeformFractions>`, issue #436) overrides the Set B ×2.5 face surface deformation table (`FACE_DEFORM_FRACTIONS`, checked against `FACE_DEFORM_RANGES` by `CONFIG_TURN_DEFORM_RANGE`); when `applyFaceSurfaceDeform` runs on a rig whose `motion` carries `tilt` or `turn` slider `derive` keys, it requires `config.turn` (`CONFIG_TURN_REQUIRED`, issue #478; `propose --full`/`--head` drafts it), promotes `face` on `head` (or `turn_face_head` when `turn` is declared) to the uneven 5×5 grid mesh, keys `face`, `hair_front` and `hair_back` deform timelines and ear/topknot tracks from `evalPitchFaceSurface` and `evalYawFaceSurface`, and samples the same deform field across each `features` member's rest span (`featRx = (24 / 106) · W`, `featRy = (12 / 128) · H`) with its depth fraction `z / zRef` as the field's angle input and chord foreshortening (`scalex` narrowing on the leading side and widening on the trailing side, `scaley` on pitch) so every feature's bounding box stays inside the deformed face plate across the rated band (issue #468). On yaw (`issue #479`), `evalYawFaceSurface` evaluates a **cylinder projection** (`cylinderYawDx`: `Δx(x, θ, R) = R · (sin(clamp(arcsin(clamp(x / R, −1, 1)) − θ, −π/2, π/2)) − clamp(x / R, −1, 1))`) of radius `R` (`turnSurfaceRadius`: `turn.surface.radius ?? turn.radius ?? turn.head.radius`, positive rig px checked by `CONFIG_FIELD_TYPE`, defaulting to half the face plate's opaque width `W / 2`) tapered by a cubic Hermite outline weight (`wOutline = 1` for `\|ux\| <= 0.7`, reaching `0` at `\|ux\| = 1.0`) so features slide across a fixed outline (`iris` shift within `±2%` of `cylinderYawDx`), the trailing cheek strip widens (`>= 1.54×` at `±15°`), and the leading jaw edge holds fixed (`0 px` shift) unless explicit horizontal `turn.deform` overrides (`turn_mid_x`, `turn_lead_compress_x`, `turn_trail_shift_x`) request the flat yaw table. On yaw (`issue #478`), `applyFaceSurfaceDeform` also derives a **head-only pivot** (`headTurnPivot`: `turn.head.pivot` when authored, otherwise the `opaque_px`-weighted mean of `depths[part]` across the head parts `DEFAULT_HEAD_TURN_PARTS` — `face`, `hair_front`, `hair_back`, `ear_r`, `ear_l`, `hairpin` — from `parts.json`, falling back to `turn.pivot`) so a forward torso or arm in `turn.depths` does not pull the head's rotation axis in front of `face`: `hair_back` (`depth_median > headPivot`, negative `headTurnFraction`) and `hairpin` behind `headPivot` translate opposite to the face's turn (`dx = s · turn_face_center_x · W · (headPivot − depth) / (headPivot − nearestHeadDepth)`), emerging on the trailing side to compensate for the leading-cheek foreshortening and keeping the combined head silhouette width near-constant across `±15°` without any same-sign `turn_hair_back_cheek_x` term. Optional `band` (`number` or `{yaw?, pitch?}`, positive degrees, issue #472) declares the rig's rated face turn band (default `FACE_RATED_BAND`: `yaw <= 15°`, `pitch <= 12°`); declaring a `turn.band` or a `motion.animations_from` `turn`/`tilt` `derive.degrees` above `±15°` yaw or `±12°` pitch without an `assemble.alternates` entry that replaces `face` is refused (`CONFIG_FACE_BAND_EXCEEDED`), and on a single-plate rig `applyFaceSurfaceDeform` adds self-targeting transform constraints `yaw_clamp` (`[-15, 15]`) and `pitch_clamp` (`[-12, 12]`) ahead of the slider constraints so driving `yaw` or `pitch` beyond the rated band clamps at the boundary. At rest: with `turn` declared, no pixel differs by more than 1 level at dial 0 (not byte-identical; the cause is float noise in the identity child bones, and the constraints add nothing); without `turn`, byte-identical. Neither `pivot` nor `depths` has a default (`CONFIG_FIELD_PRESENT`); `pivot` and `head.pivot` must lie behind the nearest part (`CONFIG_TURN_PIVOT_BEHIND_NEAREST`). Absent, no control is added and no byte of any output moves |
+| `turn` | rig (adds the turn control or 2.5D head-turn producer) | **proposed** only with `propose --full`/`--head` (issue #251), then corrected, or **authored** for 2.5D depth-sampled head turns (issue #763): `{pivot?, depths?, deform?, band?, radius?, surface?: {radius?}, head?: {pivot?, radius?}, roles?, counter?, grid?, unitDepths?, body?}`. When `roles` is declared (`{<part>: "surface" \| "unit" \| "rear"}`, issue #763; `CONFIG_TURN_ROLE_UNKNOWN`, `CONFIG_TURN_SURFACE_REQUIRED`, `CONFIG_TURN_SURFACE_REGION`, `CONFIG_TURN_UNIT_MESH_BONES`), the rig stage runs the 2.5D depth-sampled head-turn producer: it edge-extends each turn-bound part's depth sheet across its transparent border and semi-transparent fringe from the nearest fully opaque (`alpha === 255`) texel before `PAD = 4` clamping (`padTurnDepthSheet`, `DEPTH_SILHOUETTE_SIZE_MISMATCH`), promotes `"surface"` regions to `generator: {kind: "grid", cols, rows, depth}` (`grid`: `[cols, rows]` or `{<part>: [cols, rows]}`, default `[13, 16]`, bounded at `<= 2,400` triangles per slot and `<= 4,000` total, `RIG_TURN_GRID_BUDGET`, `RIG_TURN_SURFACE_DEPTH_REQUIRED`, `RIG_TURN_SHARED_DEPTH_SCALE`), emits `faceshift` and `rear_shift` under `head` (`CONFIG_TURN_HEAD_BONE`, `RIG_TURN_HEAD_BONE`), `<part>_surface` and `<part>_unit` under `faceshift`, and `yaw_dial` and `pitch_dial` under `root` (`CONFIG_TURN_BONE_FREE`, `RIG_TURN_NAME_FREE`), re-parents `"unit"` region bones and `"rear"` bones and mesh weights to `faceshift` and `rear_shift` (while `"unit"` mesh parts receive their own `<part>_unit` carrier under `faceshift`, rebind direct `"head"` weights to `<part>_unit`, reparent bound chain roots to `<part>_unit` while keeping chain skinning weights intact, and key `<part>_unit` in `turn_units`, #790), samples each `"unit"` bone's depth from the `"surface"` depth sheet at its rest position (or reads `unitDepths.<part>`, `RIG_TURN_UNIT_DEPTH_REQUIRED`), enforces ear occlusion (`ear_r`/`ear_l` drawn before `"surface"` in `assemble.plan`, `CONFIG_TURN_EAR_DRAW_ORDER`, and behind the cheek surface, `RIG_TURN_EAR_DEPTH_BEHIND_CHEEK`), and writes `turn` and `tilt` `derive` tracks (`pivot` default `55` rig px, `counter` default `0.1` in `[0, 1]`, `CONFIG_TURN_COUNTER_RANGE`). `depths` holds, per part, the See-through layer's `depth_median` the part came from (larger = further back), read from the run the part was assembled from; a `painting:` patch has none and is not carried. A rider (issue #271) — a part from an `eyewhite`, `irides`, `eyelash`, `eyebrow`, `nose` or `mouth` layer — is drafted at the `face` part's depth, 0.001 nearer when parts.json draws it after the face and 0.001 further when before: See-through makes no depth of its own for the eye group (it cuts them from one depth map of the combined eyes) and clamps nose and mouth to the face's median − 0.001, and the two runs' own medians for these layers disagreed by up to 0.47 and swapped their order against the face. Every other layer — ears, headwear and earwear included — keeps its own median, unless it rides another part's bone. With no `face` part, or more than one, the riders keep their own and a note says so. A rider by bone (issue #535) — a part every *ownable* bone of which (a chain link, or a bone no other bone hangs from; `head`, `chest` and any bone with a child are shared and never count on their own) is *hosted* by another carried part, the host of a bone being the carried part that binds it (its region's bone; a mesh's `segments`, `contour` and `auto` regions' bones) with the most `opaque_px`, the earlier in parts.json on a tie, and which hosts no bone itself — is drafted at its host's depth, 0.001 nearer when drawn after the host and 0.001 further when before, and a note names the host, the bones and its own median: a pin, clip or ornament on the back hair's links travels with the back hair, not with its own layer's depth. `propose` reads the proposal's own `bones`, `meshes` and `regions`; the face riders are read by their tag first and never by their bones. A part bound to two hosts' bones rides neither and a note says so. In the rig stage, an authored depth on a rider by bone whose fraction differs from its host's by more than 0.1 of the dial (`TURN_RIDER_APART`, a share of `pivot − nearest`) is refused (`CONFIG_TURN_RIDER_DEPTH`); the host is read off `parts.json`'s `opaque_px`, so the config loader cannot see it. One note lists each part's depth and where it came from; a carrier the other run places more than 10 % of `pivot − nearest` away gets a note naming both values and the run read — the two runs are not reconciled. `pivot` is the depth that stays put; `propose` drafts the mean of the parts' depths weighted by `opaque_px`, the one depth at which the painted pixels' centroid does not slide under the dial. The rig stage adds a bone `turn` under `root` at its origin that nothing keys — its local x is the dial, in rig px — and carries each part by `(pivot − depth) / (pivot − nearest depth)` of it: the nearest part all of it, a part behind the pivot the other way, a part at the pivot not at all. Each part rides leaf twins (`turn_<part>_<bone>`, an identity child of every bone its slot and weights bind) moved by one `transform` constraint (`turn_<part>`, after the config's own); the idle's keys, the `<bone>_ctl` controls and a physics constraint stay on the bones, and the dial moves none of them. Optional `deform` (`Partial<FaceDeformFractions>`, issue #436) overrides the Set B ×2.5 face surface deformation table (`FACE_DEFORM_FRACTIONS`, checked against `FACE_DEFORM_RANGES` by `CONFIG_TURN_DEFORM_RANGE`); when `applyFaceSurfaceDeform` runs on a rig whose `motion` carries `tilt` or `turn` slider `derive` keys, it requires `config.turn` (`CONFIG_TURN_REQUIRED`, issue #478; `propose --full`/`--head` drafts it), promotes `face` on `head` (or `turn_face_head` when `turn` is declared) to the uneven 5×5 grid mesh, keys `face`, `hair_front` and `hair_back` deform timelines and ear/topknot tracks from `evalPitchFaceSurface` and `evalYawFaceSurface`, and samples the same deform field across each `features` member's rest span (`featRx = (24 / 106) · W`, `featRy = (12 / 128) · H`) with its depth fraction `z / zRef` as the field's angle input and chord foreshortening (`scalex` narrowing on the leading side and widening on the trailing side, `scaley` on pitch) so every feature's bounding box stays inside the deformed face plate across the rated band (issue #468). On yaw (`issue #479`), `evalYawFaceSurface` evaluates a **cylinder projection** (`cylinderYawDx`: `Δx(x, θ, R) = R · (sin(clamp(arcsin(clamp(x / R, −1, 1)) − θ, −π/2, π/2)) − clamp(x / R, −1, 1))`) of radius `R` (`turnSurfaceRadius`: `turn.surface.radius ?? turn.radius ?? turn.head.radius`, positive rig px checked by `CONFIG_FIELD_TYPE`, defaulting to half the face plate's opaque width `W / 2`) tapered by a cubic Hermite outline weight (`wOutline = 1` for `\|ux\| <= 0.7`, reaching `0` at `\|ux\| = 1.0`) so features slide across a fixed outline (`iris` shift within `±2%` of `cylinderYawDx`), the trailing cheek strip widens (`>= 1.54×` at `±15°`), and the leading jaw edge holds fixed (`0 px` shift) unless explicit horizontal `turn.deform` overrides (`turn_mid_x`, `turn_lead_compress_x`, `turn_trail_shift_x`) request the flat yaw table. On yaw (`issue #478`), `applyFaceSurfaceDeform` also derives a **head-only pivot** (`headTurnPivot`: `turn.head.pivot` when authored, otherwise the `opaque_px`-weighted mean of `depths[part]` across the head parts `DEFAULT_HEAD_TURN_PARTS` — `face`, `hair_front`, `hair_back`, `ear_r`, `ear_l`, `hairpin` — from `parts.json`, falling back to `turn.pivot`) so a forward torso or arm in `turn.depths` does not pull the head's rotation axis in front of `face`: `hair_back` (`depth_median > headPivot`, negative `headTurnFraction`) and `hairpin` behind `headPivot` translate opposite to the face's turn (`dx = s · turn_face_center_x · W · (headPivot − depth) / (headPivot − nearestHeadDepth)`), emerging on the trailing side to compensate for the leading-cheek foreshortening and keeping the combined head silhouette width near-constant across `±15°` without any same-sign `turn_hair_back_cheek_x` term. Optional `band` (`number` or `{yaw?, pitch?}`, positive degrees, issue #472) declares the rig's rated face turn band (default `FACE_RATED_BAND`: `yaw <= 15°`, `pitch <= 12°`); declaring a `turn.band` or a `motion.animations_from` `turn`/`tilt` `derive.degrees` above `±15°` yaw or `±12°` pitch without an `assemble.alternates` entry that replaces `face` is refused (`CONFIG_FACE_BAND_EXCEEDED`), and on a single-plate rig `applyFaceSurfaceDeform` adds self-targeting transform constraints `yaw_clamp` (`[-15, 15]`) and `pitch_clamp` (`[-12, 12]`) ahead of the slider constraints so driving `yaw` or `pitch` beyond the rated band clamps at the boundary. At rest: with `turn` declared, no pixel differs by more than 1 level at dial 0 (not byte-identical; the cause is float noise in the identity child bones, and the constraints add nothing); without `turn`, byte-identical. Neither `pivot` nor `depths` has a default (`CONFIG_FIELD_PRESENT`); `pivot` and `head.pivot` must lie behind the nearest part (`CONFIG_TURN_PIVOT_BEHIND_NEAREST`). Absent, no control is added and no byte of any output moves |
 | `scene` | assemble (the recomposite, its holes and the figure's mask); check, through `parts.json`'s `scene` block (`RECOMPOSITE_HOLES`, the seam) | **authored**, optional; `propose` writes none (issue #242). `{}` declares the painting a scene: the figure and its surroundings in one image, See-through's full run holding only the figure. With it, `assemble` reads the recomposite figures, the hole list and the `uncovered:` lines inside the figure — the rig pixels where any full-run layer's alpha is above 8 (`OPAQUE_ALPHA_ABOVE`, the cut every layer's painted pixels are read by) — each line starting `inside the figure (config.scene: …, <n> of <m> rig px)`; writes that figure as `figure_rig.png` (white on black) beside the recomposite, and a `scene` block in `parts.json`; flags error pixels on the error map inside it only (outside, the painting grey); and `check` leaves out of the seam every frame pixel whose composite sample reaches the painting's outermost row or column, saying how many (`seam_border` in `check.json`, and on the seam line). It takes no field: the figure and its threshold are derived. A key in it other than a record or an annotation is `CONFIG_KEY_KNOWN`. Absent, no byte of any output moves |
 | `cloth` | `propose --cloth` only; no other stage reads it, so it moves no byte of any build | **authored**, optional (issue #364): one recipe per tag, `{"bottomwear": {…}, "back hair": {…}, "front hair": {…}}`, each `{chains, links, wind, gravity, split?, length_ratio?, strength?, damping?, alternate_damping?, translate?, swing?, part?, influence?}`. `influence` (issue #518) — `{across, max, shape, radius?}`: the parts this recipe meshes are drafted in the influence mode (`meshes.<part>.influence` above) at their lattice's cell, with `across`, `max` and `shape` as declared (each required — the reading behind the radius did not vary them) and `radius` as declared or, absent, drafted as the farthest vertex's distance plus 3 cells (the `influence.radius` row); without it the parts keep their lattice. `chains` — trees across the piece (for `back hair`, per side of the eye axis), a whole number, 1 or more; `links` — links from root to tip on every path, 1 or more; `split` — `{at, into}`: the first `at` links are the trunk, which forks into `into` (2 or more) branches; `at` below `links` (`CONFIG_CLOTH_SPLIT_BEFORE_TIP`); `length_ratio` — a path's last link over its first, above 0, default 0.5; `strength` — `{trunk, branch, edge}`, each above 0 and below the spring's stability bound (`CONFIG_CLOTH_SPRING_STABLE`), default 100 / 100 / 50; `damping` — in [0, 1], absent: rig-c's default; `alternate_damping` — the odd trees' damping, in [0, 1], beside `damping` and different from it (`CONFIG_CLOTH_ALTERNATE_DIFFERS`); `wind`, `gravity` — `[root, tip]`, each 0 or more, tip at or above root (`CONFIG_CLOTH_RESPONSE_GROWS_TO_TIP`); `translate` — the x and y mix of a dangling end's flutter, above 0 and at most 1; `swing` — `bottomwear` only, `{scales}`, one positive scale per tree (`CONFIG_CLOTH_SWING_SCALE_PER_TREE`); `part` — `bottomwear` only (`CONFIG_CLOTH_PART_ON_BOTTOMWEAR`), a non-empty part or cut-piece name: the `topwear` part that holds a skirt See-through returned inside it (a dress), or its skirt piece cut by `assemble.cuts`, which takes the skirt's trees (issue #402, *A skirt inside topwear* below; the part is checked by `propose`, `PROPOSE_CLOTH_PART`). The two defaults are the recipe's own, measured on its synthetic fixture (the recipe below). The recipe below says what each field drafts. The config written: `propose --cloth <config.json> --write-config <out.json>` (issue #537) writes this config's own text back with the sections the recipe drafts spliced in — `meshes.<part>` and `regions.<part>`, and `bones`, `constraints` and `motion.tracks` entry by entry by name (issue #552) — and every other byte as read; `--from <previous config>` (issue #571) takes an entry equal to the previous recipe's draft as the recipe's (*The config written*, under the recipe below) |
 | `proposed_rig_scale` | assemble, rig, build, `propose --from-config`/`--compare` | **proposed** by `propose` (issue #354): `parts.json`'s `scale_rig_per_source`, the `assemble.rig_scale` the rig sections (`bones`, `meshes`, `limbs`, `motion`) were drafted at. Held equal to `assemble.rig_scale` when present (`CONFIG_PROPOSED_RIG_SCALE`; 0, negative or not a number: `CONFIG_FIELD_TYPE`). Absent on a hand-authored config, where no byte of any output moves |
@@ -4514,6 +4514,7 @@ and stay absent).
 | <a id="CONFIG_TURN_ROLE_UNKNOWN"></a>`CONFIG_TURN_ROLE_UNKNOWN` | `config.turn.roles.<part>` (or `config.turn.body.roles.<part>`) is not `"surface"`, `"unit"` or `"rear"` | declare `"surface"`, `"unit"` or `"rear"` |
 | <a id="CONFIG_TURN_SURFACE_REQUIRED"></a>`CONFIG_TURN_SURFACE_REQUIRED` | `config.turn.roles` (or `config.turn.body.roles`) declares no `"surface"` part | declare at least one part as `"surface"` |
 | <a id="CONFIG_TURN_SURFACE_REGION"></a>`CONFIG_TURN_SURFACE_REGION` | `config.turn.roles.<part>` (or `config.turn.body.roles.<part>`) declares `"surface"` for a part that is also in `config.meshes` | attach `"surface"` parts in `config.regions` (so the rig stage promotes them to depth-backed grid meshes on `<part>_surface`), or give the mesh part role `"unit"` or `"rear"` |
+| <a id="CONFIG_TURN_UNIT_MESH_BONES"></a>`CONFIG_TURN_UNIT_MESH_BONES` | `config.turn.roles.<part>` (or `config.turn.body.roles.<part>`) declares `"unit"` for a mesh part in `config.meshes` that binds a bone outside the `"head"` subtree (or outside the torso carrier subtree for `turn.body`), or shares a bound bone or chain with another `"unit"` mesh part, so its bones cannot be moved under `<part>_unit` (#790) | bind each `"unit"` mesh only to `"head"` and its own child bones or chains under `"head"` (or to the torso root bone and its own non-head descendants for `turn.body`), or give the part role `"rear"` |
 | <a id="CONFIG_TURN_EAR_DRAW_ORDER"></a>`CONFIG_TURN_EAR_DRAW_ORDER` | an ear part in `config.turn.roles` is drawn after a `"surface"` part in `assemble.plan` | place `ear_r` and `ear_l` before `face` in `assemble.plan` so the turning cheek occludes the far ear |
 | <a id="CONFIG_TURN_HEAD_BONE"></a>`CONFIG_TURN_HEAD_BONE` | `config.turn.roles` is declared without a single bone `"head"` in `config.bones`, or `config.turn.body` without a single bone `"chest"` / `"hip"` (or its declared `bone`) | declare `"head"` (or the body turn root bone) as a single bone in `config.bones` |
 | <a id="CONFIG_TURN_SLIDER_NAME_FREE"></a>`CONFIG_TURN_SLIDER_NAME_FREE` | `config.turn.body.slider` (or the default `"body_yaw_dial"`) collides with a head turn dial (`"yaw"`, `"pitch"`, `"yaw_dial"`, `"pitch_dial"`) or an existing slider constraint in `config.constraints` (#787) | choose a distinct slider name in `config.turn.body.slider` |
@@ -5569,7 +5570,8 @@ controls, and `config.turn.body` (#787) extends the same 2.5D turn pipeline to
 torso/body parts under an independent `body_yaw_dial` (or `turn.body.slider`)
 dial; see [`CONFIG_TURN_ROLE_UNKNOWN`](#CONFIG_TURN_ROLE_UNKNOWN),
 [`CONFIG_TURN_SURFACE_REQUIRED`](#CONFIG_TURN_SURFACE_REQUIRED),
-[`CONFIG_TURN_SURFACE_REGION`](#CONFIG_TURN_SURFACE_REGION) and
+[`CONFIG_TURN_SURFACE_REGION`](#CONFIG_TURN_SURFACE_REGION),
+[`CONFIG_TURN_UNIT_MESH_BONES`](#CONFIG_TURN_UNIT_MESH_BONES) and
 [`CONFIG_TURN_SLIDER_NAME_FREE`](#CONFIG_TURN_SLIDER_NAME_FREE).
 Authored weighted body meshes not named in `config.turn.body.roles` are unchanged and do not consume depth sheets. Measurement sheets are not packed
 art. An authored `parts.json` depth reference remains an active standalone

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rig-parts",
-  "version": "1.71.0",
+  "version": "1.71.1",
   "description": "AI-authored 2D character parts from one anime painting and its See-through layer decomposition: measured parts, weighted-mesh rig specs, verified through rig-c before anything is written. A CLI for agents that cannot see the image.",
   "type": "module",
   "bin": {

package/src/assemble.ts

@@ -101,7 +101,7 @@ import { bindDepthRun, copyDepthMaterial, registerDepthRun, transportPartDepth,
  * Pure: no clock, no randomness, no file access. The CLI reads and writes.
  */
 import { sourceLimbTarget, nearestTargetPart } from './limbownership.ts';
-import { type ArmSplit, type BoneEntry, type CharacterConfig, type ControlSkeleton, controlSkeletonOf, type Cut, type EarlyConfig, type Extend, type Limb, type Patch, type PlanEntry, type Run, type SeeThrough } from './config.ts';
+import { type ArmSplit, type BoneEntry, type CharacterConfig, type ConfigConstraint, type ControlSkeleton, controlSkeletonOf, type Cut, type EarlyConfig, type Extend, type Limb, type MeshSpec, type Patch, type PlanEntry, type RegionSpec, type Run, type SeeThrough, turnMovingPartPair, type TurnSpec } from './config.ts';
 import { PartsError, type Problem, refuseIfAny } from './errors.ts';
 import { CORE_ALPHA, figuresPhrase, implausibleRules, type Layer, type LayerFigures, layerFigures, type LayerSet, NEAR_WHITE_MIN, OPAQUE_ALPHA_ABOVE, ruleSummary } from './layers.ts';
 import { padToSquare, squarePad } from './inputs.ts';
@@ -398,6 +398,8 @@ export interface AssembleInput {
   limbUnderCover?: boolean;
   /** Issue #637: `source` is the pre-fix test mutant that skips source-transparent cap ownership; stages use target. */
   capOwnership?: 'target' | 'source';
+  /** Issue #791: pairs of parts a turn moves relative to each other, whose fringe and seam colour stay untouched. */
+  turnMovingPair?: ((a: string, b: string) => boolean) | null;
 }
 
 /**
@@ -2791,7 +2793,15 @@ function keepArtWhole(part: PlacedPart, cleared: Cleared[], holderAt: (q: number
  * hold the pixel after it); and every pixel at alpha >= `CORE_ALPHA`, which
  * is the seam override's.
  */
-export function pushBackFringe(parts: PlacedPart[], srcr: Raster, rule: SeamRule, silhouette: Mask | null, feathered: ReadonlyArray<Mask | null> | null = null, keep: ReadonlyArray<Mask | null> | null = null): FringePushed[][] {
+export function pushBackFringe(
+  parts: PlacedPart[],
+  srcr: Raster,
+  rule: SeamRule,
+  silhouette: Mask | null,
+  feathered: ReadonlyArray<Mask | null> | null = null,
+  keep: ReadonlyArray<Mask | null> | null = null,
+  turnMovingPair: ((a: string, b: string) => boolean) | null = null,
+): FringePushed[][] {
   const { width: W } = srcr;
   const { holder, cand } = seamCandidates(parts, srcr, rule, silhouette);
   const at = (i: number, d: number): number => {
@@ -2810,6 +2820,7 @@ export function pushBackFringe(parts: PlacedPart[], srcr: Raster, rule: SeamRule
     if (cand[d] === 0 || !shows(d)) continue;
     for (let i = holder[d] + 1; i < parts.length; i++) {
       if (feathered?.[i]?.data[d] === 1 || keep?.[i]?.data[d] === 1) continue;
+      if (turnMovingPair !== null && turnMovingPair(parts[i].record.name, parts[holder[d]].record.name)) continue;
       const s = at(i, d);
       if (s < 0) continue;
       const img = parts[i].image.data;
@@ -2820,7 +2831,8 @@ export function pushBackFringe(parts: PlacedPart[], srcr: Raster, rule: SeamRule
   }
   parts.forEach((part, i) => keepArtWhole(part, cleared[i], (q) => {
     const d = (part.record.y + Math.floor(q / part.record.w)) * W + part.record.x + (q % part.record.w);
-    return holder[d];
+    const h = holder[d];
+    return h >= 0 && turnMovingPair !== null && turnMovingPair(part.record.name, parts[h].record.name) ? -1 : h;
   }));
   const counts: Array<Map<number, number>> = parts.map(() => new Map());
   cleared.forEach((list, i) => {
@@ -2855,16 +2867,48 @@ export function pushBackFringe(parts: PlacedPart[], srcr: Raster, rule: SeamRule
  * under a subset set's actual cover instead of recolouring it to the painting.
  * (`assemble_parts.py` `main`, "5. seam override".)
  */
-export function seamOverride(parts: PlacedPart[], srcr: Raster, rule: SeamRule, silhouette: Mask | null, keep: ReadonlyArray<Mask | null> | null = null): void {
+export function seamOverride(
+  parts: PlacedPart[],
+  srcr: Raster,
+  rule: SeamRule,
+  silhouette: Mask | null,
+  keep: ReadonlyArray<Mask | null> | null = null,
+  turnMovingPair: ((a: string, b: string) => boolean) | null = null,
+): void {
   const { width: W } = srcr;
   const { top, cand } = seamCandidates(parts, srcr, rule, silhouette);
+  const r = (CORE_KERNEL - 1) >> 1;
   parts.forEach(({ record: p, image }, i) => {
+    const movingPeers =
+      turnMovingPair === null
+        ? []
+        : parts.map((_, j) => j).filter((j) => j !== i && turnMovingPair(p.name, parts[j].record.name));
     let n = 0;
     for (let y = 0; y < p.h; y++) {
       for (let x = 0; x < p.w; x++) {
-        const d = (p.y + y) * W + p.x + x;
+        const rx = p.x + x;
+        const ry = p.y + y;
+        const d = ry * W + rx;
         const s = (y * p.w + x) * 4;
         if (keep?.[i]?.data[d] === 1 || cand[d] === 0 || top[d] !== i || image.data[s + 3] < CORE_ALPHA) continue;
+        if (
+          movingPeers.some((j) => {
+            const pj = parts[j].record;
+            const imgJ = parts[j].image.data;
+            const x0 = Math.max(pj.x, rx - r);
+            const x1 = Math.min(pj.x + pj.w - 1, rx + r);
+            const y0 = Math.max(pj.y, ry - r);
+            const y1 = Math.min(pj.y + pj.h - 1, ry + r);
+            for (let ny = y0; ny <= y1; ny++) {
+              for (let nx = x0; nx <= x1; nx++) {
+                if (imgJ[((ny - pj.y) * pj.w + (nx - pj.x)) * 4 + 3] > 0) return true;
+              }
+            }
+            return false;
+          })
+        ) {
+          continue;
+        }
         image.data[s] = srcr.data[d * 4];
         image.data[s + 1] = srcr.data[d * 4 + 1];
         image.data[s + 2] = srcr.data[d * 4 + 2];
@@ -4999,7 +5043,7 @@ export function assemble(input: AssembleInput): AssembleResult {
   });
   const featheredInOrder: Array<Mask | null> = order.map((d) => ('patch' in d ? null : (pieceAt(d).b.feathered ?? null)));
   const keepInOrder = order.map((d) => ('limb' in d ? limbKeep[d.limb] : null));
-  const pushedBy = pushBackFringe(stack, srcr, seamRule, seamRule === 'silhouette' ? silhouette : null, featheredInOrder, keepInOrder);
+  const pushedBy = pushBackFringe(stack, srcr, seamRule, seamRule === 'silhouette' ? silhouette : null, featheredInOrder, keepInOrder, input.turnMovingPair ?? null);
   // Issue #255: a part's drift refusals in a body, and who holds the body in the draw order (the push-back clears
   // only fringe below CORE_ALPHA, and the seam override only recolours, so the holders read here are final).
   const holderAt = new Int32Array(W * H).fill(-1);
@@ -5123,7 +5167,7 @@ export function assemble(input: AssembleInput): AssembleResult {
   for (const p of placed) if (p.record.depth !== undefined && artFiles.has(p.record.depth.image)) refuseIfAny([{ code: 'DEPTH_SHEET_UNAMBIGUOUS', object: p.record.depth.image, detail: 'collides with a part artwork filename; choose noncolliding part names before sheet emission' }]);
 
 
-  seamOverride(placed, srcr, seamRule, seamRule === 'silhouette' ? silhouette : null, keepInOrder);
+  seamOverride(placed, srcr, seamRule, seamRule === 'silhouette' ? silhouette : null, keepInOrder, input.turnMovingPair ?? null);
   const can = recomposite(placed, W, H);
   // Issue #242: on a scene painting the figure is read off the full run, and every recomposite figure inside it.
   const inside = input.scene === true ? sceneFigure([...rig.entries()].filter(([k]) => k.startsWith('full:')).map(([, r]) => r), W, H) : null;
@@ -5923,7 +5967,14 @@ function unplannedNotes(
  * full-loader config, where it is optional.
  */
 export function stageFields(
-  cfg: Pick<CharacterConfig, 'seethrough' | 'assemble' | 'scene' | 'motion_seams'> & { limbs?: Record<string, Limb>; bones?: BoneEntry[] },
+  cfg: Pick<CharacterConfig, 'seethrough' | 'assemble' | 'scene' | 'motion_seams'> & {
+    limbs?: Record<string, Limb>;
+    bones?: BoneEntry[];
+    meshes?: Record<string, MeshSpec>;
+    regions?: Record<string, RegionSpec>;
+    constraints?: ConfigConstraint[];
+    turn?: TurnSpec;
+  },
   single: { w: number; h: number } | null = null,
 ): {
   resolution: number;
@@ -5941,6 +5992,7 @@ export function stageFields(
   armSplit?: ArmSplit;
   keySkeleton?: ControlSkeleton;
   headFaceUnderfill?: boolean;
+  turnMovingPair?: (a: string, b: string) => boolean;
 } {
   const problems: Problem[] = [];
   if (cfg.seethrough === undefined) {
@@ -5952,6 +6004,7 @@ export function stageFields(
   refuseIfAny(problems);
   const st = cfg.seethrough as SeeThrough;
   const keySkeleton = controlSkeletonOf(cfg);
+  const turnMovingPair = turnMovingPartPair(cfg);
   return {
     resolution: st.resolution,
     headBox: single !== null ? singleRunHeadBox(single.w, single.h, st.resolution) : (st.head_box as [number, number, number, number]),
@@ -5959,6 +6012,7 @@ export function stageFields(
     ...(st.arm_split === undefined ? {} : { armSplit: st.arm_split }),
     ...(keySkeleton === undefined ? {} : { keySkeleton }),
     ...(cfg.assemble.head_face_underfill === undefined ? {} : { headFaceUnderfill: cfg.assemble.head_face_underfill }),
+    ...(turnMovingPair === null ? {} : { turnMovingPair }),
     rigScale: cfg.assemble.rig_scale,
     plan: cfg.assemble.plan,
     extend: cfg.assemble.extend_below_crop ?? [],

package/src/build.ts

@@ -659,6 +659,7 @@ export function assembleStage(input: AssembleStageInput, outs: AssembleOutputs,
         ...(fields.scene === undefined ? {} : { scene: fields.scene }),
         ...(fields.armSplit !== undefined && altPlan.some((e) => e[1] === 'full' && (e[2] === 'handwear-r' || e[2] === 'handwear-l')) ? { armSplit: fields.armSplit } : {}),
         ...(fields.headFaceUnderfill === undefined ? {} : { headFaceUnderfill: fields.headFaceUnderfill }),
+        ...(fields.turnMovingPair === undefined ? {} : { turnMovingPair: fields.turnMovingPair }),
         seamRule: input.seam,
         projectRule: input.project,
         ...(altExclude.length === 0 ? {} : { exclude: altExclude }),

package/src/config.ts

@@ -99,7 +99,8 @@ import { edgeLength } from './length.ts';
 import { setFocusProblems } from './setfocus.ts';
 import { isSkeletonName, KEYPOINT_NAMES, type KeypointName, type PosePoints, scaledPoints, SKELETON_NAMES, type SkeletonName } from './skeleton.ts';
 import { acceptedTagNames, AUTHOR_LABEL_RULE, AUTHOR_PREFIX, readLayerTag } from './tags.ts';
-import { BODY_REAR_SHIFT_BONE, BODY_YAW_DIAL_BONE, BODYSHIFT_BONE, EAR_DEPTH_RANGE, FACE_DEFORM_FRACTIONS, FACE_DEFORM_RANGES, type FaceDeformKey, FACE_RATED_PITCH_BAND, FACE_RATED_YAW_BAND, FACESHIFT_BONE, PITCH_DIAL_BONE, REAR_SHIFT_BONE, TURN_BONE, TURN_ROLES, type TurnSpec, turnNearest, turnSurfaceBone, YAW_DIAL_BONE } from './turn.ts';
+import { BODYSHIFT_BONE, BODY_REAR_SHIFT_BONE, BODY_YAW_DIAL_BONE, EAR_DEPTH_RANGE, FACESHIFT_BONE, FACE_DEFORM_FRACTIONS, FACE_DEFORM_RANGES, FACE_RATED_PITCH_BAND, FACE_RATED_YAW_BAND, type FaceDeformKey, PITCH_DIAL_BONE, REAR_SHIFT_BONE, TURN_BONE, TURN_ROLES, type TurnRole, type TurnSpec, YAW_DIAL_BONE, turnNearest, turnSurfaceBone, turnUnitBone } from './turn.ts';
+export type { TurnSpec };
 import { FLOOR_FORMS, type FloorForm, type MeshInfluences } from './weights.ts';
 
 export type Point = [number, number];
@@ -791,30 +792,244 @@ export interface PartBinding {
  */
 export function partBoundBones(b: PartBinding): Map<string, string[]> {
   const chains = new Map<string, string[]>();
-  for (const e of b.bones) if ('chain' in e) chains.set(e.chain, e.points.map((_, k) => `${e.chain}${k}`));
+  for (const e of Array.isArray(b.bones) ? b.bones : []) {
+    if (isPlainObject(e) && 'chain' in e && typeof e.chain === 'string' && Array.isArray(e.points)) {
+      chains.set(e.chain, e.points.map((_, k) => `${e.chain}${k}`));
+    }
+  }
   const out = new Map<string, string[]>();
   const bind = (part: string, bone: string): void => {
     const list = out.get(part) ?? [];
     if (!list.includes(bone)) list.push(bone);
     out.set(part, list);
   };
-  for (const [part, m] of Object.entries(b.meshes)) {
-    if ('explicit' in m) {
-      for (const row of explicitWeightRows(m)) for (const w of row) bind(part, w.bone);
-      if (m.explicit.islands !== undefined) for (const bName of explicitSlotBones(m)) bind(part, bName);
-      continue;
+  if (isPlainObject(b.meshes)) {
+    for (const [part, m] of Object.entries(b.meshes)) {
+      if (isRecordKey(part) || !isPlainObject(m)) continue;
+      if ('explicit' in m && isPlainObject(m.explicit)) {
+        const addWeights = (ws: Json): void => {
+          if (!Array.isArray(ws)) return;
+          for (const row of ws) {
+            if (!Array.isArray(row)) continue;
+            for (const w of row) {
+              if (isPlainObject(w) && typeof w.bone === 'string') bind(part, w.bone);
+            }
+          }
+        };
+        if (Array.isArray(m.explicit.islands)) {
+          for (const isl of m.explicit.islands) {
+            if (isPlainObject(isl)) addWeights(isl.weights);
+          }
+          const seg0 =
+            Array.isArray(m.segments) && m.segments.length > 0
+              ? typeof m.segments[0] === 'string'
+                ? m.segments[0]
+                : Array.isArray(m.segments[0]) && typeof m.segments[0][0] === 'string'
+                  ? m.segments[0][0]
+                  : undefined
+              : undefined;
+          for (const isl of m.explicit.islands) {
+            if (!isPlainObject(isl)) continue;
+            const bName = typeof isl.bone === 'string' ? isl.bone : seg0;
+            if (bName !== undefined) bind(part, bName);
+          }
+        } else {
+          addWeights(m.explicit.weights);
+        }
+        continue;
+      }
+      if (Array.isArray(m.segments)) {
+        for (const sg of m.segments) {
+          if (typeof sg === 'string') {
+            for (const l of chains.get(sg) ?? [sg]) bind(part, l);
+          } else if (Array.isArray(sg) && typeof sg[0] === 'string') {
+            bind(part, sg[0]);
+          }
+        }
+      }
+      if ('contour' in m && isPlainObject(m.contour)) {
+        if (Array.isArray(m.contour.regions)) {
+          for (const rg of m.contour.regions) {
+            if (isPlainObject(rg) && typeof rg.bone === 'string') bind(part, rg.bone);
+          }
+        }
+        if (isPlainObject(m.contour.bust)) {
+          bind(part, typeof m.contour.bust.bone_r === 'string' ? m.contour.bust.bone_r : DEFAULT_BUST_BONE_R);
+          bind(part, typeof m.contour.bust.bone_l === 'string' ? m.contour.bust.bone_l : DEFAULT_BUST_BONE_L);
+        }
+      }
+      if ('auto' in m && isPlainObject(m.auto) && Array.isArray(m.auto.regions)) {
+        for (const rg of m.auto.regions) {
+          if (isPlainObject(rg) && typeof rg.bone === 'string') bind(part, rg.bone);
+        }
+      }
     }
-    for (const sg of m.segments) {
-      if (typeof sg !== 'string') bind(part, sg[0]);
-      else for (const l of chains.get(sg) ?? [sg]) bind(part, l);
+  }
+  if (isPlainObject(b.regions)) {
+    for (const [part, region] of Object.entries(b.regions)) {
+      if (isRecordKey(part)) continue;
+      const bone = rawRegionBone(region);
+      if (typeof bone === 'string') bind(part, bone);
     }
-    if ('contour' in m) for (const rg of contourRegionsOf(m.contour)) bind(part, rg.bone);
-    if ('auto' in m) for (const rg of m.auto.regions ?? []) if (weightsABone(rg)) bind(part, rg.bone);
   }
-  for (const [part, region] of Object.entries(b.regions)) bind(part, regionBone(region));
   return out;
 }
 
+/**
+ * Issue #791: whether a turn moves two parts relative to each other — two parts
+ * with different turn roles or carriers (`config.turn.roles`,
+ * `config.turn.body.roles`, `config.turn.depths`), or a part with a physics
+ * chain (`config.constraints` with `type: "physics"`) over another part.
+ * Returns null when `config.turn` is absent, so a rig without a turn block is
+ * untouched.
+ */
+export function turnMovingPartPair(
+  cfg: {
+    assemble?: CharacterConfig['assemble'];
+    turn?: TurnSpec;
+    bones?: BoneEntry[];
+    meshes?: Record<string, MeshSpec>;
+    regions?: Record<string, RegionSpec>;
+    limbs?: Record<string, Limb>;
+    constraints?: ConfigConstraint[];
+  },
+): ((a: string, b: string) => boolean) | null {
+  const turn = cfg.turn;
+  if (!isPlainObject(turn)) return null;
+
+  const sourceOf = new Map<string, string>();
+  for (const c of cfg.assemble?.cuts ?? []) {
+    if (isPlainObject(c) && typeof c.into === 'string' && typeof c.from === 'string') sourceOf.set(c.into, c.from);
+  }
+  if (isPlainObject(cfg.limbs)) {
+    for (const limb of Object.values(cfg.limbs)) {
+      if (!isPlainObject(limb) || !Array.isArray(limb.segments)) continue;
+      for (const sg of limb.segments) {
+        if (!isPlainObject(sg) || typeof sg.part !== 'string' || typeof sg.from !== 'string') continue;
+        sourceOf.set(sg.part, sg.from);
+        if (isPlainObject(sg.hybrid) && typeof sg.hybrid.part === 'string') sourceOf.set(sg.hybrid.part, sg.from);
+      }
+    }
+  }
+  const baseName = (p: string): string => {
+    let cur = p;
+    const seen = new Set<string>();
+    while (sourceOf.has(cur) && !seen.has(cur)) {
+      seen.add(cur);
+      cur = sourceOf.get(cur) as string;
+    }
+    return cur;
+  };
+
+  const boneEntries = Array.isArray(cfg.bones) ? cfg.bones.filter(isPlainObject) : [];
+  const parentOf = new Map<string, string>();
+  for (const e of boneEntries) {
+    if ('chain' in e && typeof e.chain === 'string' && Array.isArray(e.points)) {
+      e.points.forEach((_, k) => parentOf.set(`${e.chain}${k}`, k === 0 ? e.parent : `${e.chain}${k - 1}`));
+    } else if ('name' in e && typeof e.name === 'string' && typeof e.parent === 'string') {
+      parentOf.set(e.name, e.parent);
+    }
+  }
+  const physicsBones = new Set<string>();
+  if (Array.isArray(cfg.constraints)) {
+    for (const c of cfg.constraints) {
+      if (isPlainObject(c) && c.type === 'physics' && typeof c.bone === 'string') physicsBones.add(c.bone);
+    }
+  }
+  for (const b of parentOf.keys()) {
+    let cur: string | undefined = b;
+    const seen = new Set<string>();
+    while (cur !== undefined && !seen.has(cur)) {
+      if (physicsBones.has(cur)) {
+        physicsBones.add(b);
+        break;
+      }
+      seen.add(cur);
+      cur = parentOf.get(cur);
+    }
+  }
+
+  const meshParts = isPlainObject(cfg.meshes)
+    ? new Set(Object.keys(cfg.meshes).filter((k) => !isRecordKey(k)))
+    : new Set<string>();
+  const isMeshPart = (p: string): boolean => meshParts.has(p) || meshParts.has(baseName(p));
+
+  const bound =
+    isPlainObject(cfg.meshes) || isPlainObject(cfg.regions)
+      ? partBoundBones({
+          bones: boneEntries as BoneEntry[],
+          meshes: isPlainObject(cfg.meshes) ? (cfg.meshes as Record<string, MeshSpec>) : {},
+          regions: isPlainObject(cfg.regions) ? (cfg.regions as Record<string, RegionSpec>) : {},
+        })
+      : new Map<string, string[]>();
+  if (isPlainObject(cfg.limbs)) {
+    for (const limb of Object.values(cfg.limbs)) {
+      if (!isPlainObject(limb) || !Array.isArray(limb.segments)) continue;
+      for (const sg of limb.segments) {
+        if (!isPlainObject(sg) || typeof sg.part !== 'string' || typeof sg.bone !== 'string') continue;
+        if (!bound.has(sg.part)) bound.set(sg.part, [sg.bone]);
+        if (isPlainObject(sg.hybrid) && typeof sg.hybrid.part === 'string' && !bound.has(sg.hybrid.part)) {
+          bound.set(sg.hybrid.part, [sg.bone]);
+        }
+      }
+    }
+  }
+  const bonesOf = (p: string): readonly string[] => bound.get(p) ?? bound.get(baseName(p)) ?? [];
+  const sameNonEmptyBones = (a: readonly string[], b: readonly string[]): boolean =>
+    a.length > 0 && a.length === b.length && a.every((x, i) => x === b[i]);
+
+  const roleGroups: Array<{ roles: Readonly<Record<string, TurnRole>>; unitDepths?: Readonly<Record<string, number>> }> = [];
+  if (isPlainObject(turn.roles)) {
+    roleGroups.push({
+      roles: turn.roles as Readonly<Record<string, TurnRole>>,
+      ...(isPlainObject(turn.unitDepths) ? { unitDepths: turn.unitDepths as Readonly<Record<string, number>> } : {}),
+    });
+  }
+  if (isPlainObject(turn.body) && isPlainObject(turn.body.roles)) {
+    roleGroups.push({
+      roles: turn.body.roles as Readonly<Record<string, TurnRole>>,
+      ...(isPlainObject(turn.body.unitDepths) ? { unitDepths: turn.body.unitDepths as Readonly<Record<string, number>> } : {}),
+    });
+  }
+  const depths = isPlainObject(turn.depths) ? (turn.depths as Readonly<Record<string, number>>) : null;
+  const pivot = typeof turn.pivot === 'number' && Number.isFinite(turn.pivot) ? turn.pivot : null;
+
+  return (a: string, b: string): boolean => {
+    if (a === b) return false;
+    const bA = bonesOf(a);
+    const bB = bonesOf(b);
+    const hasPhysA = bA.some((x) => physicsBones.has(x));
+    const hasPhysB = bB.some((x) => physicsBones.has(x));
+    if ((hasPhysA || hasPhysB) && !(bA.length === 1 && sameNonEmptyBones(bA, bB))) return true;
+
+    for (const g of roleGroups) {
+      const rA = g.roles[a] ?? g.roles[baseName(a)];
+      const rB = g.roles[b] ?? g.roles[baseName(b)];
+      if (rA === undefined && rB === undefined) continue;
+      if (rA !== rB) return true;
+      if (rA === 'surface') return true;
+      if (rA === 'unit' && (isMeshPart(a) || isMeshPart(b) || !sameNonEmptyBones(bA, bB))) return true;
+      const ud = g.unitDepths;
+      if (ud !== undefined) {
+        const dA = ud[a] ?? ud[baseName(a)] ?? (bA.length === 1 ? ud[bA[0]] : undefined);
+        const dB = ud[b] ?? ud[baseName(b)] ?? (bB.length === 1 ? ud[bB[0]] : undefined);
+        if (dA !== dB) return true;
+      }
+      if ((bA.length > 0 || bB.length > 0) && !sameNonEmptyBones(bA, bB)) return true;
+    }
+
+    if (depths !== null) {
+      const rawA = depths[a] ?? depths[baseName(a)];
+      const rawB = depths[b] ?? depths[baseName(b)];
+      const effA = typeof rawA === 'number' && Number.isFinite(rawA) && rawA !== pivot ? rawA : null;
+      const effB = typeof rawB === 'number' && Number.isFinite(rawB) && rawB !== pivot ? rawB : null;
+      if (effA !== effB) return true;
+    }
+
+    return false;
+  };
+}
+
 /**
  * The bones a part can own (issue #535): every chain link, and every bone no
  * other bone hangs from. A trunk bone — `head`, `chest`, anything with a child —
@@ -1410,6 +1625,12 @@ export interface AssembleConfig {
   /** Issue #349: read with `bones` (the joints are the bones' origins) when present. */
   limbs?: Record<string, Limb>;
   bones?: BoneEntry[];
+  /** Issue #791: read with `turn` so `assemble` leaves moving pairs' fringes and seams alone. */
+  meshes?: Record<string, MeshSpec>;
+  regions?: Record<string, RegionSpec>;
+  constraints?: ConfigConstraint[];
+  motion?: Motion;
+  turn?: TurnSpec;
   motion_seams?: MotionSeamDeclaration[];
   /** Issue #354: the `rig_scale` `propose` drafted the rig sections at, held equal to `assemble.rig_scale` when present. */
   proposed_rig_scale?: number;
@@ -1488,10 +1709,25 @@ function parseEarlyConfigFrom(raw: Json, door: EarlyDoor, base: string | null):
     if (isPlainObject(t.assemble) && 'alternates' in t.assemble) {
       checkAlternates(c, t.assemble.alternates, made, limbs, names?.bones ?? null, names?.chains ?? null, t.regions, t.meshes);
     }
+    const output = new Set([...made.parts.filter(n => !limbs?.consumed.has(n)), ...made.patches, ...made.cuts, ...(limbs?.parts.keys() ?? [])]);
     if ('motion_seams' in t) {
-      const output = new Set([...made.parts.filter(n => !limbs?.consumed.has(n)), ...made.patches, ...made.cuts, ...(limbs?.parts.keys() ?? [])]);
       c.problems.push(...motionSeamProblems(t.motion_seams, output, 'config.motion_seams', 'CONFIG_MOTION_SEAM'));
     }
+    if ('turn' in t) {
+      if ('bones' in t && names === null) names = checkBones(c, t.bones);
+      const attached = 'meshes' in t || 'regions' in t ? attachedParts(t.meshes, t.regions) : output;
+      const hasAltFace = hasAlternateFaceSet(t.assemble, [...made.parts, ...made.cuts]);
+      const declaredSliders = new Set<string>();
+      if (Array.isArray(t.constraints)) {
+        for (const entry of t.constraints) {
+          if (isPlainObject(entry) && entry.type === 'slider' && typeof entry.name === 'string' && entry.name.length > 0) {
+            declaredSliders.add(entry.name);
+          }
+        }
+      }
+      const meshParts = isPlainObject(t.meshes) ? new Set(Object.keys(t.meshes).filter((k) => !isRecordKey(k))) : new Set<string>();
+      checkTurn(c, t.turn, attached, names?.bones ?? new Set(['root', 'head', 'chest', 'hip']), hasAltFace, made.parts, declaredSliders, meshParts);
+    }
   }
   if ('cloth' in t) checkCloth(c, t.cloth);
   const pose = base === null ? null : poseBeside(c, t.generation, base);
@@ -1706,7 +1942,7 @@ function parseConfigFrom(raw: Json, base: string | null): { config: CharacterCon
     }
   }
   const meshParts = isPlainObject(t.meshes) ? new Set(Object.keys(t.meshes).filter((k) => !isRecordKey(k))) : new Set<string>();
-  if ('turn' in t) checkTurn(c, t.turn, attached, names.bones, hasAltFace, parts, declaredSliders, meshParts);
+  if ('turn' in t) checkTurn(c, t.turn, attached, names.bones, hasAltFace, parts, declaredSliders, meshParts, t.meshes, names.chains, names.parents);
   if ('scene' in t) checkScene(c, t.scene);
   if ('cloth' in t) checkCloth(c, t.cloth);
   if ('requirements' in t && c.string('config.requirements', t.requirements) && base !== null) checkRequirementsFile(c, resolve(base, t.requirements));
@@ -4401,8 +4637,97 @@ function checkTurn(
   parts: readonly string[] = [],
   declaredSliders: ReadonlySet<string> = new Set(),
   meshParts: ReadonlySet<string> = new Set(),
+  rawMeshes: Json = undefined,
+  chains: ReadonlyMap<string, number> = new Map(),
+  parents: ReadonlyMap<string, string> = new Map(),
 ): void {
   const at = 'config.turn';
+  const meshBoundBones = (part: string): string[] => {
+    if (!isPlainObject(rawMeshes) || !isPlainObject(rawMeshes[part])) return [];
+    const m = rawMeshes[part] as Record<string, Json>;
+    const out: string[] = [];
+    const add = (rawBone: string): void => {
+      const b = rawBone.endsWith('_d') && bones.has(rawBone.slice(0, -2)) ? rawBone.slice(0, -2) : rawBone;
+      if (bones.has(b) && !out.includes(b)) out.push(b);
+    };
+    if (Array.isArray(m.segments)) {
+      for (const s of m.segments) {
+        if (typeof s === 'string') {
+          const linkCount = chains.get(s);
+          if (linkCount !== undefined) {
+            for (let lk = 0; lk < linkCount; lk++) add(`${s}${lk}`);
+          } else {
+            add(s);
+          }
+        } else if (Array.isArray(s) && typeof s[0] === 'string') {
+          add(s[0]);
+        }
+      }
+    }
+    if (isPlainObject(m.contour)) {
+      if (Array.isArray(m.contour.regions)) {
+        for (const rg of m.contour.regions) {
+          if (isPlainObject(rg) && typeof rg.bone === 'string') add(rg.bone);
+        }
+      }
+      if (isPlainObject(m.contour.bust)) {
+        add(typeof m.contour.bust.bone_r === 'string' ? m.contour.bust.bone_r : DEFAULT_BUST_BONE_R);
+        add(typeof m.contour.bust.bone_l === 'string' ? m.contour.bust.bone_l : DEFAULT_BUST_BONE_L);
+      }
+    }
+    if (isPlainObject(m.auto) && Array.isArray(m.auto.regions)) {
+      for (const rg of m.auto.regions) {
+        if (isPlainObject(rg) && typeof rg.bone === 'string') add(rg.bone);
+      }
+    }
+    if (isPlainObject(m.explicit)) {
+      const addWeights = (ws: Json): void => {
+        if (!Array.isArray(ws)) return;
+        for (const row of ws) {
+          if (!Array.isArray(row)) continue;
+          for (const w of row) {
+            if (isPlainObject(w) && typeof w.bone === 'string') add(w.bone);
+          }
+        }
+      };
+      addWeights(m.explicit.weights);
+      if (Array.isArray(m.explicit.islands)) {
+        for (const isl of m.explicit.islands) {
+          if (isPlainObject(isl)) addWeights(isl.weights);
+        }
+      }
+    }
+    return out;
+  };
+  const headSubtreeRoot = (boneName: string): string | null => {
+    if (boneName === 'head') return 'head';
+    let cur: string | undefined = boneName;
+    const seen = new Set<string>();
+    while (cur !== undefined && !seen.has(cur)) {
+      seen.add(cur);
+      const p = parents.get(cur);
+      if (p === 'head') return cur;
+      cur = p;
+    }
+    return null;
+  };
+  const canCarryHeadUnitBone = (boneName: string): boolean => headSubtreeRoot(boneName) !== null;
+  const bodySubtreeRoot = (boneName: string, torsoRoots: ReadonlySet<string>, headExclusion: ReadonlySet<string>): string | null => {
+    if (headExclusion.has(boneName)) return null;
+    if (torsoRoots.has(boneName)) return boneName;
+    let cur: string | undefined = boneName;
+    const seen = new Set<string>();
+    while (cur !== undefined && !seen.has(cur)) {
+      seen.add(cur);
+      const p = parents.get(cur);
+      if (p === undefined || headExclusion.has(p)) return null;
+      if (torsoRoots.has(p)) return !torsoRoots.has(cur) && !headExclusion.has(cur) ? cur : null;
+      cur = p;
+    }
+    return null;
+  };
+  const canCarryBodyUnitBone = (boneName: string, torsoRoots: ReadonlySet<string>, headExclusion: ReadonlySet<string>): boolean =>
+    bodySubtreeRoot(boneName, torsoRoots, headExclusion) !== null;
   const hasRoles = isPlainObject(v) && 'roles' in v;
   const hasBody = isPlainObject(v) && 'body' in v;
   const hasDepths = isPlainObject(v) && 'depths' in v;
@@ -4460,7 +4785,9 @@ function checkTurn(
       c.fail('CONFIG_FIELD_TYPE', `${at}.roles`, `is ${show(r)}; a non-empty object of part name -> ("surface" | "unit" | "rear") is required`);
     } else {
       const surfaceParts: string[] = [];
+      const unitMeshParts: string[] = [];
       const earParts: string[] = [];
+      const headUnitRootOwner = new Map<string, { part: string; bone: string }>();
       for (const [part, role] of Object.entries(r)) {
         if (isRecordKey(part)) continue;
         if (!attached.has(part)) {
@@ -4479,7 +4806,46 @@ function checkTurn(
             }
             surfaceParts.push(part);
           }
-          if (role === 'unit' && (part === 'ear_r' || part === 'ear_l')) earParts.push(part);
+          if (role === 'unit') {
+            if (part === 'ear_r' || part === 'ear_l') earParts.push(part);
+            if (meshParts.has(part)) {
+              unitMeshParts.push(part);
+              if (bones.has('head')) {
+                const bound = meshBoundBones(part);
+                const uncarried = bound.filter((b) => !canCarryHeadUnitBone(b));
+                if (bound.length > 0 && uncarried.length > 0) {
+                  c.fail(
+                    'CONFIG_TURN_UNIT_MESH_BONES',
+                    `${at}.roles.${part}`,
+                    `declares "${part}" as "unit", and config.meshes.${part} binds bone(s) ${uncarried.map((b) => `"${b}"`).join(', ')} outside the "head" subtree, which cannot be carried by "${turnUnitBone(part)}" under "${FACESHIFT_BONE}"; bind a head "unit" mesh only to "head" or bones and chains under "head"`,
+                  );
+                }
+                const reportedRoots = new Set<string>();
+                for (const b of bound) {
+                  if (b === 'head') continue;
+                  const rootBone = headSubtreeRoot(b);
+                  if (rootBone === null) continue;
+                  const owner = headUnitRootOwner.get(rootBone);
+                  if (owner !== undefined && owner.part !== part) {
+                    if (!reportedRoots.has(rootBone)) {
+                      reportedRoots.add(rootBone);
+                      const sharedDetail =
+                        owner.bone === b
+                          ? `bone "${b}"${b === rootBone ? '' : ` (under "${rootBone}")`}`
+                          : `chain root "${rootBone}" ("${owner.part}" binds "${owner.bone}", "${part}" binds "${b}")`;
+                      c.fail(
+                        'CONFIG_TURN_UNIT_MESH_BONES',
+                        `${at}.roles.${part}`,
+                        `declares "${part}" as "unit", and config.meshes.${part} shares ${sharedDetail} with "unit" mesh "${owner.part}" (${at}.roles.${owner.part}); each "unit" mesh reparents its bound chain root under its own "<part>_unit" carrier, so two "unit" meshes cannot share a bone or chain under "head"`,
+                      );
+                    }
+                  } else if (owner === undefined) {
+                    headUnitRootOwner.set(rootBone, { part, bone: b });
+                  }
+                }
+              }
+            }
+          }
         }
       }
       if (surfaceParts.length === 0) {
@@ -4501,7 +4867,7 @@ function checkTurn(
       if (!bones.has('head')) {
         c.fail('CONFIG_TURN_HEAD_BONE', `${at}.roles`, 'requires a declared "head" bone in config.bones to parent the 2.5D turn carriers');
       }
-      for (const reserved of [FACESHIFT_BONE, REAR_SHIFT_BONE, ...surfaceParts.map(turnSurfaceBone)]) {
+      for (const reserved of [FACESHIFT_BONE, REAR_SHIFT_BONE, ...surfaceParts.map(turnSurfaceBone), ...unitMeshParts.map(turnUnitBone)]) {
         if (bones.has(reserved)) {
           c.fail('CONFIG_TURN_BONE_FREE', `bone "${reserved}"`, `is a carrier bone the rig stage adds under head for config.turn.roles, and config.bones already declares a bone of that name; rename it`);
         }
@@ -4556,6 +4922,11 @@ function checkTurn(
         c.fail('CONFIG_FIELD_TYPE', `${bAt}.roles`, `is ${show(br)}; a non-empty object of part name -> ("surface" | "unit" | "rear") is required`);
       } else {
         const bodySurfaceParts: string[] = [];
+        const bodyUnitMeshParts: string[] = [];
+        const bodyRoot = typeof bo.bone === 'string' && bones.has(bo.bone) ? bo.bone : bones.has('chest') ? 'chest' : 'hip';
+        const torsoRoots = new Set<string>([bodyRoot, 'chest', 'hip']);
+        const headExclusion = new Set<string>(['head', 'neck']);
+        const bodyUnitRootOwner = new Map<string, { part: string; bone: string }>();
         for (const [part, role] of Object.entries(br)) {
           if (isRecordKey(part)) continue;
           if (!attached.has(part)) {
@@ -4572,12 +4943,48 @@ function checkTurn(
               );
             }
             bodySurfaceParts.push(part);
+          } else if (role === 'unit' && meshParts.has(part)) {
+            bodyUnitMeshParts.push(part);
+            if (bones.has(bodyRoot)) {
+              const bound = meshBoundBones(part);
+              const uncarried = bound.filter((b) => !canCarryBodyUnitBone(b, torsoRoots, headExclusion));
+              if (bound.length > 0 && uncarried.length > 0) {
+                c.fail(
+                  'CONFIG_TURN_UNIT_MESH_BONES',
+                  `${bAt}.roles.${part}`,
+                  `declares "${part}" as "unit", and config.meshes.${part} binds bone(s) ${uncarried.map((b) => `"${b}"`).join(', ')} outside the "${bodyRoot}" torso subtree, which cannot be carried by "${turnUnitBone(part)}" under "${BODYSHIFT_BONE}"; bind a body "unit" mesh only to the torso root or bones and chains under it`,
+                );
+              }
+              const reportedRoots = new Set<string>();
+              for (const b of bound) {
+                if (torsoRoots.has(b)) continue;
+                const rootBone = bodySubtreeRoot(b, torsoRoots, headExclusion);
+                if (rootBone === null) continue;
+                const owner = bodyUnitRootOwner.get(rootBone);
+                if (owner !== undefined && owner.part !== part) {
+                  if (!reportedRoots.has(rootBone)) {
+                    reportedRoots.add(rootBone);
+                    const sharedDetail =
+                      owner.bone === b
+                        ? `bone "${b}"${b === rootBone ? '' : ` (under "${rootBone}")`}`
+                        : `chain root "${rootBone}" ("${owner.part}" binds "${owner.bone}", "${part}" binds "${b}")`;
+                    c.fail(
+                      'CONFIG_TURN_UNIT_MESH_BONES',
+                      `${bAt}.roles.${part}`,
+                      `declares "${part}" as "unit", and config.meshes.${part} shares ${sharedDetail} with "unit" mesh "${owner.part}" (${bAt}.roles.${owner.part}); each "unit" mesh reparents its bound chain root under its own "<part>_unit" carrier, so two "unit" meshes cannot share a bone or chain under "${bodyRoot}"`,
+                    );
+                  }
+                } else if (owner === undefined) {
+                  bodyUnitRootOwner.set(rootBone, { part, bone: b });
+                }
+              }
+            }
           }
         }
         if (bodySurfaceParts.length === 0) {
           c.fail('CONFIG_TURN_SURFACE_REQUIRED', `${bAt}.roles`, 'declares no part with role "surface"; at least one surface part is required for 2.5D body turn');
         }
-        for (const reserved of [BODYSHIFT_BONE, BODY_REAR_SHIFT_BONE, ...bodySurfaceParts.map(turnSurfaceBone)]) {
+        for (const reserved of [BODYSHIFT_BONE, BODY_REAR_SHIFT_BONE, ...bodySurfaceParts.map(turnSurfaceBone), ...bodyUnitMeshParts.map(turnUnitBone)]) {
           if (bones.has(reserved)) {
             c.fail('CONFIG_TURN_BONE_FREE', `bone "${reserved}"`, `is a carrier bone the rig stage adds for config.turn.body.roles, and config.bones already declares a bone of that name; rename it`);
           }

package/src/rig.ts

@@ -187,7 +187,7 @@ import { alphaAbove, crop, pad, type Raster } from './raster/index.ts';
 import { pyRound } from './round.ts';
 import { boneHeat, type HeatDust, heatInfluences, HEAT_LIMITS, heatRow, type HeatRow, latticeSilhouette, tracedSilhouette } from './heat.ts';
 import type { PosePoints } from './skeleton.ts';
-import { applyFaceSurfaceDeform, BODY_REAR_SHIFT_BONE, BODY_YAW_DIAL_BONE, BODYSHIFT_BONE, buildDepth25DTurn, FACE_RATED_BAND, FACESHIFT_BONE, PITCH_DIAL_BONE, REAR_SHIFT_BONE, resolveTurnGrid, TURN_BONE, TURN_CARRIER_TAG, TURN_GRID_MAX_TRIANGLES_PER_SLOT, TURN_GRID_MAX_TRIANGLES_TOTAL, TURN_PLACES, TURN_RIDER_APART, TURN_RIDER_TAGS, turnRiderDepth, type TurnRole, type TurnSpec, turnConstraintName, turnFractions, turnNearest, turnSurfaceBone, turnTwin, YAW_DIAL_BONE } from './turn.ts';
+import { applyFaceSurfaceDeform, BODY_REAR_SHIFT_BONE, BODY_YAW_DIAL_BONE, BODYSHIFT_BONE, buildDepth25DTurn, FACE_RATED_BAND, FACESHIFT_BONE, PITCH_DIAL_BONE, REAR_SHIFT_BONE, resolveTurnGrid, TURN_BONE, TURN_CARRIER_TAG, TURN_GRID_MAX_TRIANGLES_PER_SLOT, TURN_GRID_MAX_TRIANGLES_TOTAL, TURN_PLACES, TURN_RIDER_APART, TURN_RIDER_TAGS, turnRiderDepth, type TurnRole, type TurnSpec, turnConstraintName, turnFractions, turnNearest, turnSurfaceBone, turnTwin, turnUnitBone, YAW_DIAL_BONE } from './turn.ts';
 import { DISTANCE_EXPONENT, type FloorForm, type Influence, influences, type InfluenceLimits, type MeshInfluences, meshLimits, type Segment } from './weights.ts';
 
 /** Transparent pixels added round every part image — the reference's `PAD`. */
@@ -3128,7 +3128,12 @@ export function buildWaistPairSource(
         const headTransform = world.get('head') as BoneTransform;
         const headTurnDeg = turn.get('head') ?? 0;
         const surfBones: RigBone[] = [];
+        const unitMeshBones: RigBone[] = [];
         for (const p of parts.parts) {
+          if (roles[p.name] === 'unit' && cfg.meshes[p.name] !== undefined) {
+            unitMeshBones.push({ name: turnUnitBone(p.name), parent: FACESHIFT_BONE, x: 0, y: 0 });
+            continue;
+          }
           if (roles[p.name] !== 'surface') continue;
           const [cols, rows] = resolveTurnGrid(cfg.turn, p.name);
           totalGridTriangles += 2 * (cols - 1) * (rows - 1);
@@ -3149,6 +3154,7 @@ export function buildWaistPairSource(
           { name: FACESHIFT_BONE, parent: 'head', x: 0, y: 0 },
           ...(hasRear ? [{ name: REAR_SHIFT_BONE, parent: 'head', x: 0, y: 0 }] : []),
           ...surfBones,
+          ...unitMeshBones,
         ];
         bones.splice(headIdx + 1, 0, ...carriers);
         const existingNames = new Set(bones.map((b) => b.name));
@@ -3156,7 +3162,14 @@ export function buildWaistPairSource(
         if (!existingNames.has(PITCH_DIAL_BONE)) bones.push({ name: PITCH_DIAL_BONE, parent: ROOT_BONE, x: 0, y: 0 });
 
         const boneByName = new Map(bones.map((b) => [b.name, b]));
+        const headCarriers = new Set<string>(carriers.map((b) => b.name));
+        const assertNotHeadTurnCarrier = (boneName: string, targetParent: string): void => {
+          if (headCarriers.has(boneName)) {
+            throw new Error(`turn invariant violated: turn carrier "${boneName}" must never be reparented (target "${targetParent}")`);
+          }
+        };
         const reparentFromHead = (boneName: string, targetParent: string): void => {
+          assertNotHeadTurnCarrier(boneName, targetParent);
           const b = boneByName.get(boneName);
           if (b !== undefined && b.parent === 'head') b.parent = targetParent;
         };
@@ -3168,25 +3181,100 @@ export function buildWaistPairSource(
             if (stillSl.bone === 'head') stillSl.bone = carrierBone;
             else reparentFromHead(stillSl.bone, carrierBone);
           }
-          const atts = skin[part] ?? {};
-          for (const att of Object.values(atts)) {
-            if (!('type' in att) || att.weights === undefined) continue;
-            for (const row of att.weights) {
-              for (const w of row) {
-                if (w.bone === 'head') {
-                  w.bone = carrierBone;
-                } else {
-                  let cur = boneByName.get(w.bone);
-                  while (cur !== undefined && cur.parent !== undefined && cur.parent !== 'head' && cur.parent !== carrierBone) {
-                    cur = boneByName.get(cur.parent);
+          for (const slotEntry of finalSlots) {
+            if (slotEntry.name !== part && !slotEntry.name.startsWith(`${part}__island`)) continue;
+            if (slotEntry.bone === 'head') slotEntry.bone = carrierBone;
+            const atts = skin[slotEntry.name] ?? {};
+            for (const att of Object.values(atts)) {
+              if (!('type' in att) || att.weights === undefined) continue;
+              for (const row of att.weights) {
+                for (const w of row) {
+                  if (w.bone === 'head') {
+                    w.bone = carrierBone;
+                  } else {
+                    let cur = boneByName.get(w.bone);
+                    while (cur !== undefined && cur.parent !== undefined && cur.parent !== 'head' && !headCarriers.has(cur.parent)) {
+                      cur = boneByName.get(cur.parent);
+                    }
+                    if (cur !== undefined && cur.parent === 'head') {
+                      assertNotHeadTurnCarrier(cur.name, carrierBone);
+                      cur.parent = carrierBone;
+                    }
                   }
-                  if (cur !== undefined && cur.parent === 'head') cur.parent = carrierBone;
                 }
               }
             }
           }
         };
 
+        const headUnitRootOwner = new Map<string, { part: string; bone: string; rootLabel: string }>();
+        const rebindUnitMeshToHeadCarrier = (part: string): void => {
+          const unitBone = turnUnitBone(part);
+          const bound: string[] = [];
+          const addBound = (bName: string): void => {
+            if (!bound.includes(bName)) bound.push(bName);
+          };
+          for (const sl of finalSlots) {
+            if (sl.name !== part && !sl.name.startsWith(`${part}__island`)) continue;
+            const atts = skin[sl.name] ?? {};
+            let hasWeights = false;
+            for (const att of Object.values(atts)) {
+              if ('type' in att && att.weights !== undefined && att.weights.length > 0) {
+                hasWeights = true;
+                for (const row of att.weights) {
+                  for (const w of row) addBound(w.bone);
+                }
+              }
+            }
+            if (!hasWeights) addBound(sl.bone);
+          }
+          const stillSl = slotByName.get(`${part}${STILL_SUFFIX}`);
+          if (stillSl !== undefined) addBound(stillSl.bone);
+          const uncarried: string[] = [];
+          const sharedRoots = new Set<string>();
+          let hasShared = false;
+          for (const bName of bound) {
+            if (bName === 'head' || bName === unitBone) continue;
+            let cur = boneByName.get(bName);
+            while (cur !== undefined && cur.parent !== undefined && cur.parent !== 'head' && !headCarriers.has(cur.parent)) {
+              cur = boneByName.get(cur.parent);
+            }
+            if (cur === undefined || cur.parent === undefined || (cur.parent !== 'head' && !headCarriers.has(cur.parent)) || headCarriers.has(cur.name)) {
+              uncarried.push(bName);
+              continue;
+            }
+            const rootLabel = cur.name.endsWith(CONTROL_SUFFIX) ? cur.name.slice(0, -CONTROL_SUFFIX.length) : cur.name;
+            const owner = headUnitRootOwner.get(cur.name);
+            if (owner !== undefined && owner.part !== part) {
+              hasShared = true;
+              if (!sharedRoots.has(cur.name)) {
+                sharedRoots.add(cur.name);
+                const sharedDetail =
+                  owner.bone === bName
+                    ? `bone "${bName}"${bName === owner.rootLabel ? '' : ` (under "${owner.rootLabel}")`}`
+                    : `chain root "${owner.rootLabel}" ("${owner.part}" binds "${owner.bone}", "${part}" binds "${bName}")`;
+                fail(
+                  'CONFIG_TURN_UNIT_MESH_BONES',
+                  `config.turn.roles.${part}`,
+                  `declares "${part}" as "unit", and config.meshes.${part} shares ${sharedDetail} with "unit" mesh "${owner.part}" (config.turn.roles.${owner.part}); each "unit" mesh reparents its bound chain root under its own "<part>_unit" carrier, so two "unit" meshes cannot share a bone or chain under "head"`,
+                );
+              }
+            } else if (owner === undefined) {
+              headUnitRootOwner.set(cur.name, { part, bone: bName, rootLabel });
+            }
+          }
+          if (uncarried.length > 0) {
+            fail(
+              'CONFIG_TURN_UNIT_MESH_BONES',
+              `config.turn.roles.${part}`,
+              `declares "${part}" as "unit", and config.meshes.${part} binds bone(s) ${uncarried.map((b) => `"${b}"`).join(', ')} outside the "head" subtree, which cannot be carried by "${unitBone}" under "${FACESHIFT_BONE}"; bind a head "unit" mesh only to "head" or bones and chains under "head"`,
+            );
+            return;
+          }
+          if (hasShared) return;
+          rebindPartToCarrier(part, unitBone);
+        };
+
         for (const [part, role] of Object.entries(roles)) {
           if (role === 'unit') {
             if (cfg.regions[part] !== undefined) {
@@ -3200,7 +3288,7 @@ export function buildWaistPairSource(
               const st = stills[part];
               if (st !== undefined) reparentFromHead(st.bone, FACESHIFT_BONE);
             } else if (cfg.meshes[part] !== undefined) {
-              rebindPartToCarrier(part, FACESHIFT_BONE);
+              rebindUnitMeshToHeadCarrier(part);
             }
           } else if (role === 'rear' && hasRear) {
             if (cfg.regions[part] !== undefined) {
@@ -3230,7 +3318,12 @@ export function buildWaistPairSource(
         const bodyTransform = world.get(bodyRoot) as BoneTransform;
         const bodyTurnDeg = turn.get(bodyRoot) ?? 0;
         const surfBones: RigBone[] = [];
+        const unitMeshBones: RigBone[] = [];
         for (const p of parts.parts) {
+          if (bodyRoles[p.name] === 'unit' && cfg.meshes[p.name] !== undefined) {
+            unitMeshBones.push({ name: turnUnitBone(p.name), parent: BODYSHIFT_BONE, x: 0, y: 0 });
+            continue;
+          }
           if (bodyRoles[p.name] !== 'surface') continue;
           const [cols, rows] = resolveTurnGrid(bodySpec, p.name, cfg.turn);
           totalGridTriangles += 2 * (cols - 1) * (rows - 1);
@@ -3251,6 +3344,7 @@ export function buildWaistPairSource(
           { name: BODYSHIFT_BONE, parent: bodyRoot, x: 0, y: 0 },
           ...(hasRear ? [{ name: BODY_REAR_SHIFT_BONE, parent: bodyRoot, x: 0, y: 0 }] : []),
           ...surfBones,
+          ...unitMeshBones,
         ];
         bones.splice(bodyIdx + 1, 0, ...carriers);
         const bodyDialBone = bodySpec.slider ?? BODY_YAW_DIAL_BONE;
@@ -3259,21 +3353,29 @@ export function buildWaistPairSource(
         }
 
         const boneByName = new Map(bones.map((b) => [b.name, b]));
+        const bodyCarriers = new Set<string>(carriers.map((b) => b.name));
+        const assertNotBodyTurnCarrier = (boneName: string, targetParent: string): void => {
+          if (bodyCarriers.has(boneName)) {
+            throw new Error(`turn invariant violated: turn carrier "${boneName}" must never be reparented (target "${targetParent}")`);
+          }
+        };
         const torsoRoots = new Set<string>([bodyRoot, 'chest', 'hip', `${bodyRoot}${CONTROL_SUFFIX}`, `chest${CONTROL_SUFFIX}`, `hip${CONTROL_SUFFIX}`]);
         const headExclusion = new Set<string>(['head', `head${CONTROL_SUFFIX}`, 'neck', `neck${CONTROL_SUFFIX}`, FACESHIFT_BONE, REAR_SHIFT_BONE]);
         const reparentFromTorso = (boneName: string, targetParent: string): void => {
+          assertNotBodyTurnCarrier(boneName, targetParent);
           if (torsoRoots.has(boneName) || headExclusion.has(boneName)) return;
           let cur = boneByName.get(boneName);
           while (
             cur !== undefined &&
             cur.parent !== undefined &&
             !torsoRoots.has(cur.parent) &&
-            cur.parent !== targetParent &&
+            !bodyCarriers.has(cur.parent) &&
             !headExclusion.has(cur.parent)
           ) {
             cur = boneByName.get(cur.parent);
           }
           if (cur !== undefined && cur.parent !== undefined && torsoRoots.has(cur.parent) && !torsoRoots.has(cur.name) && !headExclusion.has(cur.name)) {
+            assertNotBodyTurnCarrier(cur.name, targetParent);
             const oldParent = cur.parent;
             if (oldParent !== bodyRoot) {
               const oldTr = world.get(oldParent);
@@ -3295,30 +3397,119 @@ export function buildWaistPairSource(
             if (torsoRoots.has(stillSl.bone)) stillSl.bone = carrierBone;
             else reparentFromTorso(stillSl.bone, carrierBone);
           }
-          const atts = skin[part] ?? {};
-          for (const att of Object.values(atts)) {
-            if (!('type' in att) || att.weights === undefined) continue;
-            for (const row of att.weights) {
-              for (const w of row) {
-                if (torsoRoots.has(w.bone)) {
-                  if (w.bone !== bodyRoot) {
-                    const oldTr = world.get(w.bone);
-                    if (oldTr !== undefined) {
-                      const [wx, wy] = toWorld(oldTr, w.x, w.y);
-                      const [lx, ly] = toBoneLocal(bodyTransform, wx, wy);
-                      w.x = places(lx);
-                      w.y = places(ly);
+          for (const slotEntry of finalSlots) {
+            if (slotEntry.name !== part && !slotEntry.name.startsWith(`${part}__island`)) continue;
+            if (torsoRoots.has(slotEntry.bone)) slotEntry.bone = carrierBone;
+            const atts = skin[slotEntry.name] ?? {};
+            for (const att of Object.values(atts)) {
+              if (!('type' in att) || att.weights === undefined) continue;
+              for (const row of att.weights) {
+                for (const w of row) {
+                  if (torsoRoots.has(w.bone)) {
+                    if (w.bone !== bodyRoot) {
+                      const oldTr = world.get(w.bone);
+                      if (oldTr !== undefined) {
+                        const [wx, wy] = toWorld(oldTr, w.x, w.y);
+                        const [lx, ly] = toBoneLocal(bodyTransform, wx, wy);
+                        w.x = places(lx);
+                        w.y = places(ly);
+                      }
                     }
+                    w.bone = carrierBone;
+                  } else {
+                    reparentFromTorso(w.bone, carrierBone);
                   }
-                  w.bone = carrierBone;
-                } else {
-                  reparentFromTorso(w.bone, carrierBone);
                 }
               }
             }
           }
         };
 
+        const bodyUnitRootOwner = new Map<string, { part: string; bone: string; rootLabel: string }>();
+        const rebindBodyUnitMeshToCarrier = (part: string): void => {
+          const unitBone = turnUnitBone(part);
+          const bound: string[] = [];
+          const addBound = (bName: string): void => {
+            if (!bound.includes(bName)) bound.push(bName);
+          };
+          for (const sl of finalSlots) {
+            if (sl.name !== part && !sl.name.startsWith(`${part}__island`)) continue;
+            const atts = skin[sl.name] ?? {};
+            let hasWeights = false;
+            for (const att of Object.values(atts)) {
+              if ('type' in att && att.weights !== undefined && att.weights.length > 0) {
+                hasWeights = true;
+                for (const row of att.weights) {
+                  for (const w of row) addBound(w.bone);
+                }
+              }
+            }
+            if (!hasWeights) addBound(sl.bone);
+          }
+          const stillSl = slotByName.get(`${part}${STILL_SUFFIX}`);
+          if (stillSl !== undefined) addBound(stillSl.bone);
+          const uncarried: string[] = [];
+          const sharedRoots = new Set<string>();
+          let hasShared = false;
+          for (const bName of bound) {
+            if (headExclusion.has(bName)) {
+              uncarried.push(bName);
+              continue;
+            }
+            if (torsoRoots.has(bName) || bName === unitBone) continue;
+            let cur = boneByName.get(bName);
+            while (
+              cur !== undefined &&
+              cur.parent !== undefined &&
+              !torsoRoots.has(cur.parent) &&
+              !bodyCarriers.has(cur.parent) &&
+              !headExclusion.has(cur.parent)
+            ) {
+              cur = boneByName.get(cur.parent);
+            }
+            if (
+              cur === undefined ||
+              cur.parent === undefined ||
+              (!torsoRoots.has(cur.parent) && !bodyCarriers.has(cur.parent)) ||
+              torsoRoots.has(cur.name) ||
+              headExclusion.has(cur.name) ||
+              bodyCarriers.has(cur.name)
+            ) {
+              uncarried.push(bName);
+              continue;
+            }
+            const rootLabel = cur.name.endsWith(CONTROL_SUFFIX) ? cur.name.slice(0, -CONTROL_SUFFIX.length) : cur.name;
+            const owner = bodyUnitRootOwner.get(cur.name);
+            if (owner !== undefined && owner.part !== part) {
+              hasShared = true;
+              if (!sharedRoots.has(cur.name)) {
+                sharedRoots.add(cur.name);
+                const sharedDetail =
+                  owner.bone === bName
+                    ? `bone "${bName}"${bName === owner.rootLabel ? '' : ` (under "${owner.rootLabel}")`}`
+                    : `chain root "${owner.rootLabel}" ("${owner.part}" binds "${owner.bone}", "${part}" binds "${bName}")`;
+                fail(
+                  'CONFIG_TURN_UNIT_MESH_BONES',
+                  `config.turn.body.roles.${part}`,
+                  `declares "${part}" as "unit", and config.meshes.${part} shares ${sharedDetail} with "unit" mesh "${owner.part}" (config.turn.body.roles.${owner.part}); each "unit" mesh reparents its bound chain root under its own "<part>_unit" carrier, so two "unit" meshes cannot share a bone or chain under "${bodyRoot}"`,
+                );
+              }
+            } else if (owner === undefined) {
+              bodyUnitRootOwner.set(cur.name, { part, bone: bName, rootLabel });
+            }
+          }
+          if (uncarried.length > 0) {
+            fail(
+              'CONFIG_TURN_UNIT_MESH_BONES',
+              `config.turn.body.roles.${part}`,
+              `declares "${part}" as "unit", and config.meshes.${part} binds bone(s) ${uncarried.map((b) => `"${b}"`).join(', ')} outside the "${bodyRoot}" torso subtree, which cannot be carried by "${unitBone}" under "${BODYSHIFT_BONE}"; bind a body "unit" mesh only to the torso root or bones and chains under it`,
+            );
+            return;
+          }
+          if (hasShared) return;
+          rebindBodyPartToCarrier(part, unitBone);
+        };
+
         for (const [part, role] of Object.entries(bodyRoles)) {
           if (role === 'unit') {
             if (cfg.regions[part] !== undefined) {
@@ -3345,7 +3536,7 @@ export function buildWaistPairSource(
               const st = stills[part];
               if (st !== undefined) reparentFromTorso(st.bone, BODYSHIFT_BONE);
             } else if (cfg.meshes[part] !== undefined) {
-              rebindBodyPartToCarrier(part, BODYSHIFT_BONE);
+              rebindBodyUnitMeshToCarrier(part);
             }
           } else if (role === 'rear' && hasRear) {
             if (cfg.regions[part] !== undefined) {

package/src/turn.ts

@@ -245,6 +245,11 @@ export function turnSurfaceBone(part: string): string {
   return `${part}_surface`;
 }
 
+/** The carrier bone that carries a 2.5D `'unit'` mesh part (`<part>_unit`) under `faceshift` / `bodyshift` (#790). */
+export function turnUnitBone(part: string): string {
+  return `${part}_unit`;
+}
+
 /** Optional 2.5D body-yaw turn block under `config.turn.body` (#787). */
 export interface TurnBodySpec {
   pivot?: number;
@@ -1596,10 +1601,16 @@ function buildDepth25DTurnGroup(
   for (const [part, role] of Object.entries(roles)) {
     if (role !== 'unit') continue;
     const regSpec = opts.regions[part];
-    if (regSpec === undefined) continue;
-    const baseBone = typeof regSpec === 'string' ? regSpec : regSpec.bone;
-    const stillBone = opts.stills[part]?.bone;
-    const candidateBones = [baseBone, ...(stillBone === undefined ? [] : [stillBone])].filter((b) => carrierChildren.has(b));
+    let baseBone: string | undefined;
+    let candidateBones: string[] = [];
+    if (regSpec !== undefined) {
+      baseBone = typeof regSpec === 'string' ? regSpec : regSpec.bone;
+      const stillBone = opts.stills[part]?.bone;
+      candidateBones = [baseBone, ...(stillBone === undefined ? [] : [stillBone])].filter((b) => carrierChildren.has(b));
+    } else {
+      const uBone = turnUnitBone(part);
+      if (carrierChildren.has(uBone)) candidateBones = [uBone];
+    }
     if (candidateBones.length === 0) continue;
 
     for (const bName of candidateBones) {
@@ -1611,7 +1622,26 @@ function buildDepth25DTurnGroup(
       } else if (typeof explicitBoneDepth === 'number' && Number.isFinite(explicitBoneDepth)) {
         resolved = explicitBoneDepth;
       } else if (primarySurface !== undefined) {
-        const pt = opts.boneLandmarks.get(bName) ?? opts.boneLandmarks.get(baseBone);
+        let pt: readonly [number, number] | undefined =
+          opts.boneLandmarks.get(bName) ??
+          (baseBone === undefined ? undefined : opts.boneLandmarks.get(baseBone));
+        if (pt === undefined && regSpec === undefined) {
+          const childPts: Array<readonly [number, number]> = [];
+          for (const child of rig.bones) {
+            if (child.parent !== bName) continue;
+            const bare = child.name.endsWith('_ctl') ? child.name.slice(0, -4) : child.name;
+            const cp = opts.boneLandmarks.get(child.name) ?? opts.boneLandmarks.get(bare);
+            if (cp !== undefined) childPts.push(cp);
+          }
+          if (childPts.length > 0) {
+            const sx = childPts.reduce((acc, p) => acc + p[0], 0) / childPts.length;
+            const sy = childPts.reduce((acc, p) => acc + p[1], 0) / childPts.length;
+            pt = [sx, sy];
+          } else {
+            const partRec = partMap.get(part);
+            if (partRec !== undefined) pt = [partRec.x + partRec.w / 2, partRec.y + partRec.h / 2];
+          }
+        }
         if (pt !== undefined) {
           const { rec, ext, zRef } = primarySurface;
           const padX = Math.floor((ext.width - rec.w) / 2);