rig-parts 1.72.0 → 1.73.0

package/README.md

@@ -592,10 +592,17 @@ controls; see [`CONFIG_TURN_ROLE_UNKNOWN`](docs/AUTHORING.md#CONFIG_TURN_ROLE_UN
 and [`CONFIG_TURN_SURFACE_REQUIRED`](docs/AUTHORING.md#CONFIG_TURN_SURFACE_REQUIRED).
 `turn.body.roles` adds independent body yaw. A weighted mesh declared as
 `"surface"` in either group and blending head and torso bones receives both
-fields in proportion to its skin weights. Each sibling island takes only its
+fields in proportion to its skin weights. Inside the existing setup alpha
+overlap with a single-group neighbour, a blended attachment's vertex takes
+that neighbour's existing emitted triangle field at its setup position (#804), without changing skin weights,
+setup or idle. Conflicting neighbour groups are refused by name. Each sibling island takes only its
 own group; parts without a blended attachment keep their existing role behavior
 and output bytes. Unlisted meshes do not consume turn depth sheets. See the
 [blended surface contract](docs/AUTHORING.md#per-layer-depth-sheets-773).
+This copies the field at vertices; different triangle partitions can still
+differ between vertices. The [corrected #804 acceptance](https://github.com/rig-c/parts/issues/804#issuecomment-6478778123)
+checks vertex correspondence and reports those residuals per fixture; the
+contract records the measured grid residual and preserves its seam readings.
 No-image builds keep the legacy output bytes. `comfy seethrough --config <file> --depth-run <full|head>`
 uses the same opt-in; its default captures art only. Standalone authored part
 references remain active declarations. See [the input contract and refusals](docs/AUTHORING.md#per-layer-depth-sheets-773).

package/docs/AUTHORING.md

@@ -4518,7 +4518,10 @@ and stay absent).
 | <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` |
 | <a id="RIG_TURN_SURFACE_MESH_GROUPS"></a>`RIG_TURN_SURFACE_MESH_GROUPS` | a surface part contains a blended attachment but lacks one 2.5D group, includes an ungrouped positive influence in any attachment, or also declares a unit/rear role | declare both `turn.roles` and `turn.body`, a body root outside head, surface in one or both groups, and bindings wholly inside those two subtrees |
-| <a id="RIG_TURN_SURFACE_MESH_BINDINGS"></a>`RIG_TURN_SURFACE_MESH_BINDINGS` | an authored surface mesh has unresolved/nonclosing weights or shares a frame moved by a unit/rear turn carrier | provide weighted bindings closing at 1 in the authored frame; use independent chains for parts with different roles |
+| <a id="RIG_TURN_SURFACE_OVERLAP_GROUPS"></a>`RIG_TURN_SURFACE_OVERLAP_GROUPS` | a blended surface vertex overlaps incompatible single-group neighbours, or a neighbour without a blended attachment declares both turn groups | keep one neighbour group at that source-alpha overlap, or separate the overlapping art; the refusal names the vertex and neighbours |
+| <a id="RIG_TURN_SURFACE_OVERLAP_SUPPORT"></a>`RIG_TURN_SURFACE_OVERLAP_SUPPORT` | a selected neighbour has missing/invalid geometry, unresolved emitted vectors, or no triangle covering the requested setup point | supply its actual shown setup triangles and existing emitted field; no nearest triangle, extrapolation or target-field fallback is used; an unrelated disconnected drawing with no actual overlap is not selected |
+| <a id="RIG_TURN_SURFACE_OVERLAP_DEPTH"></a>`RIG_TURN_SURFACE_OVERLAP_DEPTH` | same-group overlap neighbours demand incompatible emitted offsets at one target setup point | separate the conflicting support or provide coincident neighbour fields; the refusal names the fields and target vertex |
+| <a id="RIG_TURN_SURFACE_MESH_BINDINGS"></a>`RIG_TURN_SURFACE_MESH_BINDINGS` | an authored surface mesh has unresolved/nonclosing weights or shares a frame moved by a unit/rear turn carrier; declared stop draw aliases resolve to their links for setup sampling | provide weighted bindings closing at 1 in the authored frame; `<link>_d` resolves only for links declared in `config.stops`; use independent chains for parts with different roles |
 | <a id="RIG_TURN_SURFACE_MESH_ATTACHMENT"></a>`RIG_TURN_SURFACE_MESH_ATTACHMENT` | a surface mesh has an alternate drawing without its own registered depth sampling frame | use the base attachment; explicit islands retain their own slot, attachment and bindings |
 | <a id="RIG_TURN_SURFACE_DEPTH_REQUIRED"></a>`RIG_TURN_SURFACE_DEPTH_REQUIRED` | a part with role `"surface"` in `config.turn.roles` or `config.turn.body.roles` carries no depth sheet in `parts.json` | run `assemble` with `config.depth` or provide `<part>_depth.png` in `parts.json` |
 | <a id="RIG_TURN_GRID_BUDGET"></a>`RIG_TURN_GRID_BUDGET` | a `"surface"` grid exceeds 2,400 triangles on one slot or 4,000 triangles across all `"surface"` slots | lower `config.turn.grid` / `config.turn.body.grid` `[cols, rows]` within the per-slot and total budgets |
@@ -5575,6 +5578,13 @@ dial; see [`CONFIG_TURN_ROLE_UNKNOWN`](#CONFIG_TURN_ROLE_UNKNOWN),
 [`RIG_TURN_SURFACE_MESH_BINDINGS`](#RIG_TURN_SURFACE_MESH_BINDINGS),
 [`CONFIG_TURN_UNIT_MESH_BONES`](#CONFIG_TURN_UNIT_MESH_BONES) and
 [`CONFIG_TURN_SLIDER_NAME_FREE`](#CONFIG_TURN_SLIDER_NAME_FREE).
+Weighted surfaces may bind chains declared in `config.stops` (#800). The
+sampler resolves each declared `<link>_d` draw alias and any child parent using
+it to the original link's setup frame, as `flattenRig` does. Weights, child
+parents and stops keep their emitted names; Core creates the draw bones later.
+A name ending in `_d` alone is not an alias: a missing non-stop bone still
+raises `RIG_TURN_SURFACE_MESH_BINDINGS`. No new config field is required.
+
 A weighted surface spanning the head and body subtrees (#796) takes both
 fields. Declare it as `"surface"` in `turn.roles` or `turn.body.roles` (both is
 also accepted), with both 2.5D groups present. Head descendants belong to the
@@ -5596,6 +5606,78 @@ role behavior and output bytes, even if separate single-group islands bind
 different subtrees. Generated meshes and explicit mixed attachments use the
 same split.
 
+Inside the setup alpha overlap with a single-group neighbour (#804), a
+vertex of an individually blended attachment takes that neighbour's existing
+triangle field, interpolated barycentrically at the target's setup position.
+Direct sheet sampling is a different operator from the field the neighbour mesh actually emits.
+The band is the undilated intersection at alpha 128, the
+half-opacity threshold used by Core's seam reader: both registered source
+drawings must cover the source cell containing the vertex's setup position.
+Weighted neighbour attachments additionally require that setup point inside
+their own triangles, including triangle edges; disconnected siblings do not
+lend one another a mask. This includes weighted unit/rear neighbours: their
+actual shown setup attachments are supplied separately as support, never
+promoted to surface targets. Missing weighted geometry is refused rather than
+treated as a region. A mixed neighbour supplies no single-group anchor.
+Multiple neighbours must agree on their emitted field; conflicting groups, or a pure
+neighbour declaring both fields, raise
+[`RIG_TURN_SURFACE_OVERLAP_GROUPS`](#RIG_TURN_SURFACE_OVERLAP_GROUPS).
+
+For a body-owned overlap, head yaw/pitch offsets are zero and body yaw is
+written into every positive binding's inverse frame. Spine still applies each
+original weight once, so the full body field replaces the skin-weight split.
+The symmetric rule holds for a head-owned overlap. Zero-weight entries retain
+zero offsets. A wholly inactive timeline is omitted. Outside the band the
+original split stands, including transparent padding; no distance, bounding
+box, dilation or nearest-neighbour fallback enlarges it. Exact support is read
+from the existing setup frames without a classification tolerance. Each
+neighbour field is frozen before overlap targets are rewritten: the producer's
+sheet-derived per-binding offsets are composed into one world vector per
+neighbour vertex, with its original skin weights applied once. The existing
+setup triangles interpolate those vectors at the target point. Different
+triangulations keep their different fields; a sheet resample, a bounding-box
+interpolator or an updated target cannot replace that source. The lowest-index
+triangle owns a shared edge. A selected point outside every neighbour triangle
+raises [`RIG_TURN_SURFACE_OVERLAP_SUPPORT`](#RIG_TURN_SURFACE_OVERLAP_SUPPORT).
+An unrelated disconnected sibling with no actual overlap stays unselected.
+Two same-group fields with incompatible emitted offsets raise
+[`RIG_TURN_SURFACE_OVERLAP_DEPTH`](#RIG_TURN_SURFACE_OVERLAP_DEPTH).
+
+Unit/rear neighbours contribute their actual emitted rigid carrier motion,
+including its resolved unit depth or rear counter field. Their own sheet is
+not resampled to invent a spatial bend or a new refusal. Generated surface
+grids keep their Core generator: Core's grid builder and transform evaluator
+provide inspection metadata for the same existing topology and vertex field.
+The original role's depth requirements and the mandatory Core gate remain.
+The target's own sheet and the #796 split remain in use outside the overlap.
+
+This operator matches the neighbour field at each selected vertex. It does
+not make two different triangle partitions represent the same field between
+vertices. The [corrected acceptance for #804](https://github.com/rig-c/parts/issues/804#issuecomment-6478778123)
+replaces the earlier inference of per-frame seam non-regression: an independent
+actual-Core rim vertex oracle must agree within 1.1e-6 px, and the
+differing-depth synthetic scanline must coincide on all 87 sampled turn,
+tilt and body-turn frames. Between-vertex residuals are reported per fixture;
+they do not add a topology refusal or change the existing mesh.
+
+For the synthetic generated-grid neighbour, 65 evenly spaced setup points
+along rim segment 2--3 over 31 body-turn frames measured a maximum field
+difference of 0.16825740877976836 px between vertices; the endpoint discrepancy
+was at most 1.022663678185154e-6 px. On that same fixture the seam's worst
+ghost count decreased from 5 to 2 cells, but six individual frames increased
+by one cell; pair gap stayed zero. Those readings remain reported residuals.
+The authored differing-depth neighbour measured 3.059309099384677e-7 px on
+the same segment and sampling schedule. These are fixture-specific sampled
+maxima, not a continuous-mesh bound, a universal tolerance, or a repair claim
+for other drawings. The original red measurement is retained beside the
+corrected acceptance result.
+
+There is no new config field. Only turn deform changes: skin weights, setup,
+idle, physics, art and topology are preserved. Parts without a blended
+attachment retain their existing emitted bytes. Synthetic overlap controls
+establish this rule; they do not establish an all-frame repair of a consumer
+demo.
+
 An unlisted mesh does not opt in merely by spanning the subtrees. A blended
 surface requires its own depth sheet (`RIG_TURN_SURFACE_DEPTH_REQUIRED`) and
 both groups, with every positive influence in one of their subtrees, including

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rig-parts",
-  "version": "1.72.0",
+  "version": "1.73.0",
   "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/rig.ts

@@ -138,14 +138,14 @@ import { explicitAttachment, type ExplicitMeshReport } from './explicitmesh.ts';
  * order the objects are built in, and every number is rounded by `pyRound`).
  */
 import { type AutoSpec, type BoneEntry, type InfluenceMeshSpec, type WeightRule, type CharacterConfig, type ConfigConstraint, type ConfigStop, CONSTRAINT_FOLLOWS, constraintForRig, contourRegionsOf, type ContourSpec, DEFAULT_BUST_BONE_L, DEFAULT_BUST_BONE_R, type Point, type RibsSpec, ROOT_BONE, stopForRig, turnRidersByBone, weightsABone } from './config.ts';
-import { type BoneTransform, computeExactFrameTransforms, cropToSpineY, normaliseDegrees, paintingToSetupPoint, toBoneLocal, toWorld } from './coords.ts';
+import { type BoneTransform, computeExactFrameTransforms, computeWorldTransforms, cropToSpineY, normaliseDegrees, paintingToSetupPoint, setupToPaintingPoint, toBoneLocal, toWorld } from './coords.ts';
 import { type Problem, refuseIfAny, PartsError } from './errors.ts';
 import { recordedFocusProblems } from './setfocus.ts';
 import { eyeLineDegrees } from './headframe.ts';
 import type { RigBoneInherit, RigStop } from 'rig-c/src/rig.ts';
 import { f32 } from 'rig-c/compile';
 import type { MeshCounts, MeshQualityReport, MeshReductionInput, MotionAmplitude, ReducedMesh, Termination } from 'rig-c/mesh';
-import { buildSegmentsLattice, type EntrySegment, influenceShares, segmentDistance as rigcSegmentDistance, type SegmentsLattice, type SegmentsLatticeReport } from 'rig-c/mesh';
+import { bindWeightedVertices, buildGridMesh, buildSegmentsLattice, type EntrySegment, influenceShares, segmentDistance as rigcSegmentDistance, type SegmentsLattice, type SegmentsLatticeReport } from 'rig-c/mesh';
 import { type AmplitudeRow, amplitudeRow, partAmplitude, withAmplitude } from './autoamplitude.ts';
 import { type ResidualRow, residualRow, slotEnvelope, withSkinning } from './autoenvelope.ts';
 import { type AutoMotionCase, type AutoSearch, DEFORM_MAY_FOLD_WHY, type MotionDeformation, type StimulusPose, stimulusAnimationNames } from './automotion.ts';
@@ -3662,6 +3662,7 @@ export function buildWaistPairSource(
       boneLandmarks,
       hasAlternateFaceSet,
       surfaceMeshes: turnSurfaceMeshes(cfg, rig, parts.rig_size),
+      neighbourMeshes: turnNeighbourMeshes(cfg, rig, parts),
     });
   }
   bindFaceSurfaceDeform(motion, (merged) => {
@@ -3678,6 +3679,7 @@ export function buildWaistPairSource(
         boneLandmarks,
         hasAlternateFaceSet,
         surfaceMeshes: turnSurfaceMeshes(cfg, rig, parts.rig_size),
+        neighbourMeshes: turnNeighbourMeshes(cfg, rig, parts),
       });
     }
     if (cfg.turn?.roles === undefined && (cfg.turn === undefined || cfg.turn.body === undefined || cfg.turn.depths !== undefined)) {
@@ -4190,7 +4192,45 @@ function turnSurfaceMeshes(cfg: CharacterConfig, rig: RigSpec, canvas: readonly
         if (attachment !== part && !slot.name.startsWith(`${part}__island`)) {
           throw new PartsError([{ code: 'RIG_TURN_SURFACE_MESH_ATTACHMENT', object: `surface mesh "${slot.name}/${attachment}"`, detail: `requires the base drawing "${part}"; alternate drawings need their own registered depth sampling frame` }]);
         }
-        meshes.push({ part, slot: slot.name, attachment, weights: att.weights, canvas });
+        meshes.push({ part, slot: slot.name, attachment, weights: att.weights, triangles: att.triangles, canvas });
+      }
+    }
+  }
+  return meshes;
+}
+
+/** Actual shown support; Core's own grid topology is inspection metadata only. */
+function turnNeighbourMeshes(cfg: CharacterConfig, rig: RigSpec, parts: PartsFile) {
+  const meshes: NonNullable<Parameters<typeof buildDepth25DTurn>[2]['neighbourMeshes']>[number][] = [];
+  const canvas = parts.rig_size;
+  const aliases = new Map<string, string>((rig.stops ?? []).flatMap(s => s.links.map(link => [`${link}_d`, link])));
+  const world = computeWorldTransforms(rig.bones.map(b => b.parent === undefined ? b : { ...b, parent: aliases.get(b.parent) ?? b.parent }));
+  for (const part of new Set([...Object.keys(cfg.turn?.roles ?? {}), ...Object.keys(cfg.turn?.body?.roles ?? {})])) {
+    if (cfg.meshes[part] !== undefined && [cfg.turn?.roles?.[part], cfg.turn?.body?.roles?.[part]].includes('surface')) continue;
+    const record = parts.parts.find(p => p.name === part);
+    if (record === undefined) continue;
+    for (const slot of rig.slots) {
+      if (slot.name !== part && !slot.name.startsWith(`${part}__island`)) continue;
+      for (const [attachment, att] of Object.entries(rig.skins.default[slot.name] ?? {})) {
+        if (attachment !== slot.attachment) continue;
+        if ('type' in att && att.weights !== undefined && att.weights.length > 0) { meshes.push({ part, slot: slot.name, attachment, weights: att.weights, triangles: att.triangles, canvas }); continue; }
+        const frame = world.get(aliases.get(slot.bone) ?? slot.bone);
+        if (frame === undefined) throw new PartsError([{ code: 'RIG_TURN_SURFACE_OVERLAP_SUPPORT', object: `turn neighbour "${slot.name}/${attachment}"`, detail: `has no resolved setup frame for "${slot.bone}"; supply the actual attachment frame` }]);
+        if ('type' in att && att.generator?.kind === 'grid') {
+          const gen = att.generator, cols = gen.cols, rows = gen.rows;
+          const us = Array.from({ length: cols }, (_, i) => i / (cols - 1));
+          const vs = Array.from({ length: rows }, (_, i) => i / (rows - 1));
+          const geometry = buildGridMesh({ size: [att.width, att.height], us, vs });
+          const place = (x: number, y: number): [number, number] => [frame.worldX + x - att.width / 2, frame.worldY + cropToSpineY(y, att.height) - att.height / 2];
+          const bound = bindWeightedVertices(geometry, place, { anchor: { name: slot.bone, toBind: (x, y) => toBoneLocal(frame, x, y) }, controls: [] });
+          meshes.push({ part, slot: slot.name, attachment, canvas, triangles: geometry.triangles,
+            weights: bound.bindings.map(row => row.map(w => ({ bone: w.bone, x: f32(w.x), y: f32(w.y), weight: f32(w.weight) }))),
+            gridSamples: geometry.points.map(([x, y]) => setupToPaintingPoint(place(x, y), canvas, canvas)),
+          });
+        } else if (!('type' in att)) {
+          const points = [[record.x - PAD, record.y - PAD], [record.x - PAD, record.y + record.h + PAD], [record.x + record.w + PAD, record.y + record.h + PAD], [record.x + record.w + PAD, record.y - PAD]];
+          meshes.push({ part, slot: slot.name, attachment, canvas, triangles: [0, 1, 2, 0, 2, 3], weights: points.map(p => { const q = paintingToSetupPoint(p, canvas, canvas), local = toBoneLocal(frame, q[0], q[1]); return [{ bone: slot.bone, x: f32(local[0]), y: f32(local[1]), weight: 1 }]; }) });
+        } else throw new PartsError([{ code: 'RIG_TURN_SURFACE_OVERLAP_SUPPORT', object: `turn neighbour "${slot.name}/${attachment}"`, detail: 'has neither final weighted geometry nor a supported Core grid; supply actual setup support, not a source rectangle' }]);
       }
     }
   }

package/src/turn.ts

@@ -33,6 +33,11 @@ import { extendDepthSilhouette, sampleDepthFloat, type PartDepthReference } from
 import { type Problem, refuseIfAny } from './errors.ts';
 import type { Raster } from './raster/index.ts';
 import { pyRound } from './round.ts';
+import { turnOverlapOwners } from './turnoverlap.ts';
+import { sampleTurnTriangleField, turnTriangleCoordinates } from './turnfield.ts';
+import { PartsError } from './errors.ts';
+import { f32 } from 'rig-c/compile';
+import { evaluateDeformTransform } from 'rig-c/src/deformgen.ts';
 
 /**
  * The layers that ride on the face (issue #271): See-through makes no depth
@@ -1487,9 +1492,17 @@ export interface Depth25DTurnOptions {
     attachment: string;
     weights: ReadonlyArray<ReadonlyArray<{ bone: string; x: number; y: number; weight: number }>>;
     canvas: readonly [number, number];
+    /** Existing setup topology resolves neighbour islands without a part-wide bbox. */
+    triangles?: readonly number[];
+    /** Core-generated grid sample positions, support only; never authored bindings. */
+    gridSamples?: ReadonlyArray<readonly [number, number]>;
+    /** Derived only from existing setup alpha overlap; never an authored switch. */
+    overlapOwners?: ReadonlyArray<{ group: 'head' | 'body'; neighbours: readonly string[] } | undefined>;
     /** Every attachment of a part containing a blended mesh carries its own group mask. */
     groups?: ReadonlyMap<string, 'head' | 'body'>;
   }>;
+  /** Final weighted unit/rear drawings are support only, never surface targets. */
+  neighbourMeshes?: Depth25DTurnOptions['surfaceMeshes'];
 }
 
 interface Depth25DGroupSpec {
@@ -1512,12 +1525,25 @@ interface Depth25DGroupSpec {
   }>;
 }
 
+interface Depth25DTurnRig {
+  bones: Array<{ name: string; parent?: string; x: number; y: number; rotation?: number; length?: number }>;
+  slots: Array<{ name: string; bone: string; attachment: string | null }>;
+  constraints?: Array<Record<string, unknown>>;
+  stops?: ReadonlyArray<{ links: readonly string[] }>;
+}
+
+/** Stop draw bones share their link's setup frame; Core emits them later. */
+function surfaceSetupGraph(rig: Depth25DTurnRig) {
+  const aliases = new Map<string, string>();
+  for (const stop of rig.stops ?? []) for (const link of stop.links) aliases.set(`${link}_d`, link);
+  const resolve = (name: string): string => aliases.get(name) ?? name;
+  // Like flattenRig: resolve parents as well as weights, without changing the rig.
+  const bones = rig.bones.map(b => b.parent === undefined ? b : { ...b, parent: resolve(b.parent) });
+  return { bones, resolve };
+}
+
 function buildDepth25DTurnGroup(
-  rig: {
-    bones: Array<{ name: string; parent?: string; x: number; y: number; rotation?: number; length?: number }>;
-    slots: Array<{ name: string; bone: string; attachment: string | null }>;
-    constraints?: Array<Record<string, unknown>>;
-  },
+  rig: Depth25DTurnRig,
   motion: {
     groups?: Record<string, string[]>;
     animations: Record<string, unknown>;
@@ -1814,27 +1840,29 @@ function buildDepth25DTurnGroup(
     for (const [part, { rec, ext, zRef }] of surfaceSheets) {
       const authored = opts.surfaceMeshes?.filter((m) => m.part === part) ?? [];
       if (authored.length > 0) {
-        const world = computeWorldTransforms(rig.bones);
+        const setup = surfaceSetupGraph(rig);
+        const world = computeWorldTransforms(setup.bones);
         for (const mesh of authored) {
           // An all-zero timeline can overwrite another slider's deform (Core A40).
           // A sibling with no positive binding in this group owns no timeline here.
-          const active = mesh.groups === undefined || [...mesh.groups.values()].includes(group.fieldPrefix === 'config.turn' ? 'head' : 'body');
+          const field = group.fieldPrefix === 'config.turn' ? 'head' : 'body';
+          const active = mesh.groups === undefined || mesh.weights.some((row, i) => row.some(w => w.weight > 0 && (mesh.overlapOwners?.[i] === undefined ? mesh.groups?.get(w.bone) === field : mesh.overlapOwners[i]?.group === field)));
           const vertices = mesh.weights.map((row, index) => {
             let wx = 0, wy = 0, total = 0;
             for (const w of row) {
-              const frame = world.get(w.bone);
+              const frame = world.get(setup.resolve(w.bone));
               if (frame === undefined) {
                 problems.push({ code: 'RIG_TURN_SURFACE_MESH_BINDINGS', object: `surface mesh "${mesh.slot}/${mesh.attachment}" vertex ${index}`, detail: `names missing bone "${w.bone}"; every influence must resolve in the final setup` });
                 continue;
               }
               // A unit/rear mesh sharing this root would move our bindings too.
-              let ancestor = rig.bones.find((b) => b.name === w.bone);
+              let ancestor = setup.bones.find((b) => b.name === setup.resolve(w.bone));
               while (ancestor !== undefined) {
                 if ([FACESHIFT_BONE, REAR_SHIFT_BONE, BODYSHIFT_BONE, BODY_REAR_SHIFT_BONE].includes(ancestor.name)) {
                   problems.push({ code: 'RIG_TURN_SURFACE_MESH_BINDINGS', object: `${group.fieldPrefix}.roles.${part}`, detail: `binds "${w.bone}" through turn carrier "${ancestor.name}" shared with another role; surface mesh bindings must retain their authored frame` });
                   break;
                 }
-                ancestor = rig.bones.find((b) => b.name === ancestor?.parent);
+                ancestor = setup.bones.find((b) => b.name === ancestor?.parent);
               }
               const [x, y] = toWorld(frame, w.x, w.y);
               wx += x * w.weight; wy += y * w.weight; total += w.weight;
@@ -1857,8 +1885,8 @@ function buildDepth25DTurnGroup(
               vertices: vertices.flatMap(({ row, depth }) => {
                 const d = -depth * Math.sin(deg * Math.PI / 180);
                 return row.flatMap((w) => {
-                  if (mesh.groups !== undefined && (w.weight === 0 || mesh.groups.get(w.bone) !== (group.fieldPrefix === 'config.turn' ? 'head' : 'body'))) return [0, 0];
-                  const frame = world.get(w.bone)!; // every influence resolved before emitting keys
+                  if (mesh.groups !== undefined && (w.weight === 0 || mesh.groups.get(w.bone) !== field)) return [0, 0];
+                  const frame = world.get(setup.resolve(w.bone))!; // every influence resolved before emitting keys
                   const [x, y] = toBoneLocalVector(frame, kind === 'yaw' ? d : 0, kind === 'pitch' ? d : 0);
                   return [pyRound(x, 6), pyRound(y, 6)];
                 });
@@ -1887,6 +1915,103 @@ function buildDepth25DTurnGroup(
       });
     }
 
+    // Snapshot the emitted fields BEFORE any overlap target is rewritten.
+    // Mixed targets never become another target's source by traversal order.
+    if (opts.surfaceMeshes?.some(m => m.overlapOwners !== undefined)) {
+      const setup = surfaceSetupGraph(rig), world = computeWorldTransforms(setup.bones);
+      const parents = new Map(setup.bones.map(b => [b.name, b.parent]));
+      const field = group.fieldPrefix === 'config.turn' ? 'head' : 'body';
+      const supports = [...(opts.surfaceMeshes ?? []), ...(opts.neighbourMeshes ?? [])];
+      const raw = deform.map(d => ({ ...d, keys: d.keys.map(k => ({ ...k, vertices: k.vertices?.slice() })) }));
+      const points = (mesh: typeof supports[number]) => mesh.weights.map(row => {
+        let x = 0, y = 0;
+        for (const w of row) { const frame = world.get(setup.resolve(w.bone)); if (frame === undefined) return [NaN, NaN]; const q = toWorld(frame, w.x, w.y); x += q[0] * w.weight; y += q[1] * w.weight; }
+        return [x, y];
+      });
+      for (const [ki, { deg }] of keyList.entries()) {
+        if (deg === 0) continue;
+        // All tracks this producer emits are local translations. Sum their
+        // actual emitted world vectors along each binding's ancestor chain.
+        const translations = new Map<string, [number, number]>();
+        for (const track of tracks) {
+          const names = track.bone === undefined ? motion.groups?.[track.group!] : [track.bone];
+          if (names === undefined) { problems.push({ code: 'RIG_TURN_SURFACE_OVERLAP_SUPPORT', object: `animation "${animName}"`, detail: `emitted group "${track.group}" has no resolved bones; an unresolved track is not a zero field` }); continue; }
+          for (const bone of names) {
+          const key = track.keys[ki], derived = key.derive;
+          const depth = typeof derived?.depth === 'number' ? derived.depth : derived?.depth?.[bone];
+          const stated = Array.isArray(key.v) ? key.v[0] : depth === undefined ? undefined : -(depth - (derived?.carried ?? 0)) * Math.sin(deg * Math.PI / 180);
+          if (stated === undefined || !Number.isFinite(stated)) { problems.push({ code: 'RIG_TURN_SURFACE_OVERLAP_SUPPORT', object: `animation "${animName}" bone "${bone}"`, detail: 'has no finite emitted translation; unresolved depth is not replaced by zero' }); continue; }
+          const value = f32(stated);
+          const parent = parents.get(bone), frame = parent === undefined ? undefined : world.get(setup.resolve(parent));
+          if (parent !== undefined && frame === undefined) { problems.push({ code: 'RIG_TURN_SURFACE_OVERLAP_SUPPORT', object: `animation "${animName}" bone "${bone}"`, detail: `has no resolved parent frame "${parent}"; supply its setup transform` }); continue; }
+          translations.set(bone, frame === undefined ? [track.property === 'translatex' ? value : 0, track.property === 'translatey' ? value : 0]
+            : track.property === 'translatex' ? [frame.a * value, frame.c * value] : [frame.b * value, frame.d * value]);
+          }
+        }
+        const carried = (bone: string): [number, number] => {
+          let x = 0, y = 0; const seen = new Set<string>();
+          for (let b: string | undefined = setup.resolve(bone); b !== undefined && !seen.has(b); b = parents.get(b)) { seen.add(b); const v = translations.get(b); if (v !== undefined) { x += v[0]; y += v[1]; } }
+          return [x, y];
+        };
+        const snapshots = supports.filter(m => roles[m.part] !== undefined && (m.groups === undefined || [...m.groups.values()].includes(field))).map(mesh => {
+          const positions = points(mesh), key = raw.find(d => d.slot === mesh.slot && d.attachment === mesh.attachment)?.keys[ki];
+          let generated: number[] | undefined;
+          if (key?.transform !== undefined && mesh.gridSamples !== undefined) {
+            const sheet = surfaceSheets.get(mesh.part);
+            if (sheet !== undefined) generated = evaluateDeformTransform(key.transform, positions.flat(), f32, `turn neighbour "${mesh.slot}/${mesh.attachment}"`, mesh.gridSamples.map(([x, y]) => levelToDepthZ(sampleDepthFloat(sheet.ext, x - sheet.rec.x, y - sheet.rec.y), sheet.rec.depth))).offsets;
+          }
+          let at = 0;
+          const vectors = mesh.weights.map((row, vi) => {
+            let x = 0, y = 0;
+            for (const w of row) {
+              const frame = world.get(setup.resolve(w.bone));
+              if (frame === undefined) return [NaN, NaN];
+              const v = generated === undefined ? [key?.vertices?.[at], key?.vertices?.[at + 1]] : toBoneLocalVector(frame, generated[2 * vi], generated[2 * vi + 1]);
+              // Surface fields require an emitted vertex run (or Core's grid
+              // transform); absence is never interpreted as target depth.
+              if (roles[mesh.part] === 'surface' && (v[0] === undefined || v[1] === undefined)) return [NaN, NaN];
+              const dx = f32(v[0] ?? 0), dy = f32(v[1] ?? 0), c = carried(w.bone);
+              x += (frame.a * dx + frame.b * dy + c[0]) * w.weight;
+              y += (frame.c * dx + frame.d * dy + c[1]) * w.weight; at += 2;
+            }
+            return [x, y];
+          });
+          return { mesh, label: `${mesh.part}/${mesh.slot}/${mesh.attachment}`, points: positions, triangles: mesh.triangles ?? [], vectors };
+        });
+        for (const mesh of opts.surfaceMeshes ?? []) {
+          if (mesh.overlapOwners === undefined) continue;
+          const target = deform.find(d => d.slot === mesh.slot && d.attachment === mesh.attachment)?.keys[ki];
+          if (target?.vertices === undefined) continue;
+          let at = 0; const positions = points(mesh);
+          for (const [vi, row] of mesh.weights.entries()) {
+            const owner = mesh.overlapOwners[vi];
+            if (owner === undefined) { at += 2 * row.length; continue; }
+            const encode = (v: readonly number[]) => row.flatMap(w => { if (w.weight === 0) return [0, 0]; const q = toBoneLocalVector(world.get(setup.resolve(w.bone))!, v[0], v[1]); return q.map(n => pyRound(n, 6)); });
+            let values: number[] = Array<number>(2 * row.length).fill(0);
+            if (owner.group === field) {
+              const samples: Array<{ name: string; values: number[] }> = [];
+              for (const name of owner.neighbours) {
+                const candidates = snapshots.filter(s => s.mesh.part === name), point = positions[vi];
+                const covering = candidates.filter(s => turnTriangleCoordinates(s.points, s.triangles, point[0], point[1]) !== null);
+                const chosen = covering.length === 0 ? candidates.slice(0, 1) : covering;
+                if (chosen.length === 0) problems.push({ code: 'RIG_TURN_SURFACE_OVERLAP_SUPPORT', object: `surface mesh "${mesh.slot}/${mesh.attachment}" vertex ${vi}`, detail: `selected neighbour "${name}" has no existing triangle field; supply actual setup support; target depth is not a fallback` });
+                for (const source of chosen) {
+                  try { samples.push({ name: source.label, values: encode(sampleTurnTriangleField(source, point, `surface mesh "${mesh.slot}/${mesh.attachment}" vertex ${vi}`)) }); }
+                  catch (e) { if (e instanceof PartsError) problems.push(...e.problems); else throw e; }
+                }
+              }
+              if (samples.length > 0) {
+                values = samples[0].values;
+                if (samples.some(s => s.values.some((v, i) => v !== values[i]))) problems.push({ code: 'RIG_TURN_SURFACE_OVERLAP_DEPTH', object: `surface mesh "${mesh.slot}/${mesh.attachment}" vertex ${vi}`, detail: `neighbours ${samples.map(s => `"${s.name}"`).join(', ')} require incompatible emitted fields at this setup point; separate the conflicting support or supply coincident fields` });
+              }
+            }
+            target.vertices.splice(at, 2 * row.length, ...values); at += 2 * row.length;
+          }
+        }
+      }
+      for (let i = deform.length - 1; i >= 0; i--) if (opts.surfaceMeshes.some(m => m.slot === deform[i].slot && m.attachment === deform[i].attachment && m.overlapOwners !== undefined) && deform[i].keys.every(k => k.vertices === undefined || k.vertices.every(v => v === 0))) deform.splice(i, 1);
+    }
+
     motion.animations[animName] = {
       duration,
       loop: false,
@@ -1947,11 +2072,7 @@ function buildDepth25DTurnGroup(
  * `derive` and `deform` `transform` (`depth: true, narrowing: false`).
  */
 export function buildDepth25DTurn(
-  rig: {
-    bones: Array<{ name: string; parent?: string; x: number; y: number; rotation?: number; length?: number }>;
-    slots: Array<{ name: string; bone: string; attachment: string | null }>;
-    constraints?: Array<Record<string, unknown>>;
-  },
+  rig: Depth25DTurnRig,
   motion: {
     groups?: Record<string, string[]>;
     animations: Record<string, unknown>;
@@ -1960,14 +2081,17 @@ export function buildDepth25DTurn(
 ): void {
   const problems: Problem[] = [];
   const { yaw: yawMax, pitch: pitchMax } = resolveTurnBands(opts.turn);
+  // Ownership is derived here, never accepted as an authored producer switch.
+  opts = { ...opts, surfaceMeshes: opts.surfaceMeshes?.map(({ overlapOwners: _owners, groups: _groups, ...mesh }) => mesh) };
 
   // Only a surface opt-in spanning both authored subtrees changes paths (#796).
   // Single-group meshes keep #795's role and bytes, including explicit islands.
-  const parents = new Map(rig.bones.map((b) => [b.name, b.parent]));
+  const setup = surfaceSetupGraph(rig);
+  const parents = new Map(setup.bones.map((b) => [b.name, b.parent]));
   const bodyRoot = opts.turn.body?.bone ?? (parents.has('chest') ? 'chest' : 'hip');
   const descends = (bone: string, root: string): boolean => {
     const seen = new Set<string>();
-    for (let cur: string | undefined = bone; cur !== undefined && !seen.has(cur); cur = parents.get(cur)) {
+    for (let cur: string | undefined = setup.resolve(bone); cur !== undefined && !seen.has(cur); cur = parents.get(cur)) {
       if (cur === root) return true;
       seen.add(cur);
     }
@@ -2008,8 +2132,14 @@ export function buildDepth25DTurn(
   });
   refuseIfAny(problems);
   if (blended.size > 0) {
+    const owners = turnOverlapOwners(rig, opts, classified ?? [], blended, problems);
+    refuseIfAny(problems);
+    const overlapped = surfaceMeshes?.map((mesh, i) => {
+      const overlapOwners = owners.get(classified![i].mesh);
+      return overlapOwners === undefined ? mesh : { ...mesh, overlapOwners };
+    });
     const surfaceRoles = Object.fromEntries([...blended].map(part => [part, 'surface' as const]));
-    opts = { ...opts, surfaceMeshes, turn: { ...opts.turn,
+    opts = { ...opts, surfaceMeshes: overlapped, turn: { ...opts.turn,
       roles: { ...opts.turn.roles, ...surfaceRoles },
       body: { ...opts.turn.body!, roles: { ...opts.turn.body!.roles, ...surfaceRoles } },
     } };

package/src/turnfield.ts

@@ -0,0 +1,36 @@
+/** Sampling an existing emitted triangle field is not resampling its source sheet. */
+import { PartsError } from './errors.ts';
+
+export interface TurnTriangleField {
+  label: string;
+  points: ReadonlyArray<readonly number[]>;
+  triangles: readonly number[];
+  vectors: ReadonlyArray<readonly number[]>;
+}
+
+/** Lowest triangle index on a shared edge; no epsilon or extrapolation. */
+export function turnTriangleCoordinates(points: ReadonlyArray<readonly number[]>, triangles: readonly number[], x: number, y: number): { ids: number[]; weights: number[] } | null {
+  for (let i = 0; i < triangles.length; i += 3) {
+    const ids = triangles.slice(i, i + 3), [a, b, c] = ids.map(j => points[j]);
+    if (a === undefined || b === undefined || c === undefined) continue;
+    const cross = (p: readonly number[], q: readonly number[]) => (p[0] - x) * (q[1] - y) - (p[1] - y) * (q[0] - x);
+    const area = (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]);
+    if (area === 0) continue;
+    const weights = [cross(b, c) / area, cross(c, a) / area, cross(a, b) / area];
+    if (weights.every(w => w >= 0)) return { ids, weights };
+  }
+  return null;
+}
+
+/** Named refusal outside support; never fall back to target depth or nearest geometry. */
+export function sampleTurnTriangleField(field: TurnTriangleField, point: readonly number[], object: string): [number, number] {
+  const fail = (detail: string): never => { throw new PartsError([{ code: 'RIG_TURN_SURFACE_OVERLAP_SUPPORT', object, detail: `neighbour "${field.label}" ${detail}` }]); };
+  if (point.length !== 2 || !point.every(Number.isFinite) || field.points.length !== field.vectors.length
+    || field.points.some(p => p.length !== 2 || !p.every(Number.isFinite)) || field.vectors.some(v => v.length !== 2 || !v.every(Number.isFinite))
+    || field.triangles.length === 0 || field.triangles.length % 3 !== 0 || field.triangles.some(i => !Number.isSafeInteger(i) || i < 0 || i >= field.points.length)) return fail('requires finite setup points, one emitted vector per point and existing triangle indices; supply the actual attachment field');
+  const hit = turnTriangleCoordinates(field.points, field.triangles, point[0], point[1]);
+  if (hit === null) return fail(`has no triangle covering setup (${point[0]}, ${point[1]}); provide actual covering support; no extrapolation or target-field fallback is permitted`);
+  const [a, b, c] = hit.ids.map(i => field.vectors[i]), [u, v] = hit.weights;
+  // Translation-invariant form: constant fields remain exactly constant.
+  return [c[0] + u * (a[0] - c[0]) + v * (b[0] - c[0]), c[1] + u * (a[1] - c[1]) + v * (b[1] - c[1])];
+}

package/src/turnoverlap.ts

@@ -0,0 +1,95 @@
+/** Source-alpha overlap selects turn fields, never skin bindings. */
+import { DRAWN_ALPHA } from 'rig-c/src/passthrough.ts';
+import { computeWorldTransforms, setupToPaintingPoint, toWorld } from './coords.ts';
+import type { Depth25DTurnOptions } from './turn.ts';
+import type { Problem } from './errors.ts';
+import { turnTriangleCoordinates } from './turnfield.ts';
+
+type Group = 'head' | 'body';
+type Surface = NonNullable<Depth25DTurnOptions['surfaceMeshes']>[number];
+type Owner = NonNullable<Surface['overlapOwners']>[number];
+export interface ClassifiedTurnSurface {
+  mesh: Surface;
+  groups: ReadonlyMap<string, Group>;
+}
+
+/**
+ * The seam reader's band is the undilated setup intersection at DRAWN_ALPHA.
+ * Here parts are registered one painting pixel per texel: test the source cell
+ * containing the setup vertex. No bbox, nearest island, falloff or art > 0 test
+ * substitutes for positive half-opacity support on BOTH drawings.
+ */
+export function turnOverlapOwners(
+  rig: { bones: Array<{ name: string; parent?: string; x: number; y: number; rotation?: number; length?: number }>; stops?: ReadonlyArray<{ links: readonly string[] }> },
+  opts: Depth25DTurnOptions,
+  classified: readonly ClassifiedTurnSurface[],
+  blended: ReadonlySet<string>,
+  problems: Problem[],
+): ReadonlyMap<Surface, ReadonlyArray<Owner>> {
+  // Declared Core stop draw aliases (including parents) share the link frame.
+  // This lookup does not rewrite the emitted rig or the caller's bindings.
+  const aliases = new Map<string, string>((rig.stops ?? []).flatMap(s => s.links.map(link => [`${link}_d`, link] as const)));
+  const resolve = (bone: string) => aliases.get(bone) ?? bone;
+  const world = computeWorldTransforms(rig.bones.map(b => b.parent === undefined ? b : { ...b, parent: resolve(b.parent) }));
+  const points = new Map<Surface, number[][]>();
+  const neighbours = [...classified, ...(opts.neighbourMeshes ?? []).map(mesh => ({ mesh, groups: new Map<string, Group>() }))];
+  for (const { mesh } of neighbours) {
+    points.set(mesh, mesh.weights.map(row => {
+      let x = 0, y = 0;
+      for (const w of row) {
+        if (w.weight === 0) continue;
+        const frame = world.get(resolve(w.bone));
+        if (frame === undefined) return [NaN, NaN]; // the binding reader names this refusal
+        const [wx, wy] = toWorld(frame, w.x, w.y); x += wx * w.weight; y += wy * w.weight;
+      }
+      return setupToPaintingPoint([x, y], mesh.canvas, mesh.canvas);
+    }));
+  }
+  const opaque = (part: Depth25DTurnOptions['parts'][number], x: number, y: number): boolean => {
+    const art = opts.images.get(part.name), px = Math.floor(x - part.x), py = Math.floor(y - part.y);
+    return art !== undefined && px >= 0 && py >= 0 && px < art.width && py < art.height && art.data[(py * art.width + px) * 4 + 3] >= DRAWN_ALPHA;
+  };
+  const result = new Map<Surface, ReadonlyArray<Owner>>();
+  for (const target of classified) {
+    // A part-level blend must not change a pure sibling attachment's legacy mask.
+    if (!blended.has(target.mesh.part) || new Set(target.groups.values()).size !== 2) continue;
+    const own = opts.parts.find(p => p.name === target.mesh.part);
+    if (own === undefined) continue;
+    const owners = points.get(target.mesh)!.map(([x, y], index): Owner => {
+      if (!opaque(own, x, y)) return undefined;
+      const anchors: Array<{ part: string; group: Group }> = [];
+      for (const neighbour of opts.parts) {
+        if (neighbour.name === own.name || !opaque(neighbour, x, y)) continue;
+        const roles = [opts.turn.roles?.[neighbour.name], opts.turn.body?.roles[neighbour.name]];
+        if (roles.every(r => r === undefined)) continue;
+        const meshes = neighbours.filter(c => c.mesh.part === neighbour.name);
+        const rolesGroups: Group[] = [...(roles[0] === undefined ? [] : ['head' as const]), ...(roles[1] === undefined ? [] : ['body' as const])];
+        if (meshes.length === 0) {
+          if (roles.some(r => r === 'unit' || r === 'rear') && opts.regions[neighbour.name] === undefined) problems.push({ code: 'RIG_TURN_SURFACE_OVERLAP_SUPPORT', object: `surface mesh "${target.mesh.slot}/${target.mesh.attachment}" vertex ${index}`, detail: `neighbour "${neighbour.name}" has no region declaration or weighted setup geometry; provide its actual weighted attachments, not source alpha alone` });
+          else if (rolesGroups.length === 1) anchors.push({ part: neighbour.name, group: rolesGroups[0] });
+          else problems.push({ code: 'RIG_TURN_SURFACE_OVERLAP_GROUPS', object: `surface mesh "${target.mesh.slot}/${target.mesh.attachment}" vertex ${index}`, detail: `overlaps "${neighbour.name}" in both turn groups without a single attachment group; declare one neighbour turn group or separate the overlapping art` });
+          continue;
+        }
+        for (const candidate of meshes) {
+          // A genuinely mixed neighbour has no single field to lend.
+          if (new Set(candidate.groups.values()).size === 2) continue;
+          if (candidate.mesh.triangles === undefined) {
+            problems.push({ code: 'RIG_TURN_SURFACE_OVERLAP_SUPPORT', object: `surface mesh "${target.mesh.slot}/${target.mesh.attachment}" vertex ${index}`, detail: `overlaps "${neighbour.name}" without setup triangles for "${candidate.mesh.slot}/${candidate.mesh.attachment}"; supply the existing attachment triangles so disconnected islands can be resolved` });
+            continue;
+          }
+          const vertices = points.get(candidate.mesh)!;
+          if (vertices.some(p => !p.every(Number.isFinite))) { problems.push({ code: 'RIG_TURN_SURFACE_OVERLAP_SUPPORT', object: `turn neighbour "${candidate.mesh.slot}/${candidate.mesh.attachment}"`, detail: 'has unresolved setup bindings; every positive influence must resolve before overlap is classified' }); continue; }
+          if (turnTriangleCoordinates(vertices, candidate.mesh.triangles, x, y) === null) continue;
+          const groups = blended.has(neighbour.name) ? [...new Set(candidate.groups.values())] : rolesGroups;
+          if (groups.length === 1) anchors.push({ part: neighbour.name, group: groups[0] });
+          else problems.push({ code: 'RIG_TURN_SURFACE_OVERLAP_GROUPS', object: `surface mesh "${target.mesh.slot}/${target.mesh.attachment}" vertex ${index}`, detail: `overlaps "${neighbour.name}" with ${groups.length} active turn groups; one neighbour group is required, or separate the overlapping art` });
+        }
+      }
+      const groups = [...new Set(anchors.map(a => a.group))];
+      if (groups.length > 1) problems.push({ code: 'RIG_TURN_SURFACE_OVERLAP_GROUPS', object: `surface mesh "${target.mesh.slot}/${target.mesh.attachment}" vertex ${index}`, detail: `setup alpha overlap at (${x}, ${y}) receives conflicting fields from ${anchors.map(a => `"${a.part}" (${a.group})`).join(', ')}; one neighbour group is required, or separate the overlapping art` });
+      return groups.length === 1 ? { group: groups[0], neighbours: [...new Set(anchors.map(a => a.part))] } : undefined;
+    });
+    if (owners.some(owner => owner !== undefined)) result.set(target.mesh, owners);
+  }
+  return result;
+}