@rig-c/parts 1.35.0 → 1.37.0

package/src/build.ts

@@ -78,6 +78,7 @@ import { encodeGif } from './gif.ts';
 import { CONTROL_SUFFIX, withAnimations } from './motion.ts';
 import type { PaletteError } from './palette.ts';
 import { type LayerSet, readLayers } from './layers.ts';
+import { poseBoneEntriesForDrawn } from './limbs.ts';
 import { type AlternatePartsRecord, type PartRecord, readParts, type RecompositeRecord, type SingleRunPad, tagOf, writeParts } from './parts.ts';
 import { encodePngBytes, readPng, writePng } from './raster/png.ts';
 import type { Raster } from './raster/types.ts';
@@ -444,24 +445,69 @@ export function assembleStage(input: AssembleStageInput, outs: AssembleOutputs,
     const altCuts: Cut[] = rawCuts.map((c) => ({ ...c, draw: remapDraw(c.draw) }));
     const altUnder = alt.cuts !== undefined ? readUnders(input.config, altCuts) : altCuts.map(() => null);
     const altHeadBox = alt.head_box ?? (altRuns.single ? singleRunHeadBox(altSrc.width, altSrc.height, fields.resolution) : fields.headBox);
-    const altRes = assemble({
-      source: altSrc,
-      full: altRuns.full,
-      head: altRuns.head,
-      resolution: fields.resolution,
-      headBox: altHeadBox,
-      rigScale: fields.rigScale,
-      plan: altPlan,
-      extend: altExtend,
-      patches: altPatches,
-      cuts: altCuts,
-      under: altUnder,
-      ...(Object.keys(altLimbs).length > 0 ? { limbs: altLimbs, bones: fields.bones } : {}),
-      ...(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 } : {}),
-      seamRule: input.seam,
-      projectRule: input.project,
-    });
+    let altBones = fields.bones;
+    if (Object.keys(altLimbs).length > 0 && fields.bones !== undefined && (altSkeleton !== undefined || alt.drawn !== undefined)) {
+      const coveredLimbBones = new Set(Object.values(altLimbs).flatMap((l) => l.segments.map((sg) => sg.bone)));
+      const limbDrawn: Record<string, number> = {};
+      if (altSkeleton !== undefined) {
+        const deg = (a: readonly [number, number], b: readonly [number, number]): number =>
+          (Math.atan2(-(b[1] - a[1]), b[0] - a[0]) * 180) / Math.PI;
+        const skPairs: ReadonlyArray<readonly [string, readonly [number, number], readonly [number, number]]> = [
+          ['sleeve_r0', altSkeleton.r_shoulder, altSkeleton.r_elbow],
+          ['sleeve_r1', altSkeleton.r_elbow, altSkeleton.r_wrist],
+          ['arm_r0', altSkeleton.r_shoulder, altSkeleton.r_elbow],
+          ['arm_r1', altSkeleton.r_elbow, altSkeleton.r_wrist],
+          ['sleeve_l0', altSkeleton.l_shoulder, altSkeleton.l_elbow],
+          ['sleeve_l1', altSkeleton.l_elbow, altSkeleton.l_wrist],
+          ['arm_l0', altSkeleton.l_shoulder, altSkeleton.l_elbow],
+          ['arm_l1', altSkeleton.l_elbow, altSkeleton.l_wrist],
+          ['leg_r0', altSkeleton.r_hip, altSkeleton.r_knee],
+          ['leg_r1', altSkeleton.r_knee, altSkeleton.r_ankle],
+          ['leg_l0', altSkeleton.l_hip, altSkeleton.l_knee],
+          ['leg_l1', altSkeleton.l_knee, altSkeleton.l_ankle],
+        ];
+        for (const [bName, a, b] of skPairs) {
+          if (alt.parts === undefined || coveredLimbBones.has(bName)) limbDrawn[bName] = deg(a, b);
+        }
+      }
+      if (alt.drawn !== undefined) {
+        for (const [bName, degVal] of Object.entries(alt.drawn)) limbDrawn[bName] = degVal;
+      }
+      altBones = poseBoneEntriesForDrawn(fields.bones, limbDrawn);
+    }
+    let altRes: ReturnType<typeof assemble>;
+    try {
+      altRes = assemble({
+        source: altSrc,
+        full: altRuns.full,
+        head: altRuns.head,
+        resolution: fields.resolution,
+        headBox: altHeadBox,
+        rigScale: fields.rigScale,
+        plan: altPlan,
+        extend: altExtend,
+        patches: altPatches,
+        cuts: altCuts,
+        under: altUnder,
+        ...(Object.keys(altLimbs).length > 0 ? { limbs: altLimbs, bones: altBones } : {}),
+        ...(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 }),
+        seamRule: input.seam,
+        projectRule: input.project,
+      });
+    } catch (err) {
+      if (err instanceof PartsError) {
+        for (const p of err.problems) {
+          altProblems.push({
+            ...p,
+            object: `${p.object} (alternate set "${alt.name}")`,
+          });
+        }
+        continue;
+      }
+      throw err;
+    }
     const keptImages = altRes.images
       .filter(({ record }) => coveredSet.has(record.name))
       .map(({ record, image }) => ({ name: `${alt.name}_${record.name}`, image }));
@@ -524,10 +570,11 @@ export function assembleStage(input: AssembleStageInput, outs: AssembleOutputs,
   const pad = result.parts.single_run_pad;
   if (pad !== undefined) log(singleRunPadLine(input.full, pad));
   for (const p of result.parts.parts) {
+    const underfillSuffix = p.from === 'head:face' && (result.headFaceUnderfillPx ?? 0) > 0 ? ` underfill=${result.headFaceUnderfillPx}px(full:face)` : '';
     log(
       `  ${p.name.padEnd(11)} ${p.from.padEnd(16)} ${`${p.w}x${p.h}`.padEnd(9)} @${String(p.x).padStart(4)},${String(p.y).padStart(4)} ` +
         `op=${String(p.opaque_px).padStart(6)} vis=${String(p.visible_px).padStart(6)} src=${String(p.source_px_taken).padStart(6)}/${String(p.projected_core_px).padStart(6)} ` +
-        `unproj=${String(p.visible_not_projected_px).padStart(5)} drift=${String(p.refused_drift_px).padStart(5)} ${driftShare(p.refused_drift_px, p.projected_core_px)} merged=${p.merged_px} seam=${p.seam_override_px}`,
+        `unproj=${String(p.visible_not_projected_px).padStart(5)} drift=${String(p.refused_drift_px).padStart(5)} ${driftShare(p.refused_drift_px, p.projected_core_px)} merged=${p.merged_px} seam=${p.seam_override_px}${underfillSuffix}`,
     );
   }
   // Issue #256: one line per part from an author-made layer, so it never reads as See-through's. None without one.

package/src/config.ts

@@ -92,7 +92,7 @@ import { CLOTH_TARGETS, type ClothRecipes, RECIPE_STRENGTH, RIGC_DEFAULT_DAMPING
 import { GRID, MAX_SIDE } from './contour.ts';
 import { type Problem, refuseIfAny } from './errors.ts';
 import { edgeLength } from './length.ts';
-import { isSkeletonName, KEYPOINT_NAMES, type KeypointName, type PosePoints, SKELETON_NAMES, type SkeletonName } from './skeleton.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 { EAR_DEPTH_RANGE, FACE_DEFORM_FRACTIONS, FACE_DEFORM_RANGES, type FaceDeformKey, FACE_RATED_PITCH_BAND, FACE_RATED_YAW_BAND, TURN_BONE, type TurnSpec, turnNearest } from './turn.ts';
 import { FLOOR_FORMS, type FloorForm, type MeshInfluences } from './weights.ts';
@@ -267,6 +267,8 @@ export interface Assemble {
   patches?: Patch[];
   cuts?: Cut[];
   alternates?: AlternateSetConfig[];
+  /** Issue #492: composite full:face under head:face on the head canvas to fill transparent holes inside the face silhouette. */
+  head_face_underfill?: boolean;
 }
 
 export interface SingleBone {
@@ -1140,7 +1142,7 @@ export interface PaintConfig {
 export interface EarlyConfig {
   key: string;
   seethrough: SeeThrough;
-  assemble: { rig_scale: number };
+  assemble: { rig_scale: number; head_face_underfill?: boolean };
 }
 
 /** What plain `assemble` reads: the early config plus the plan `--propose-plan` printed. */
@@ -1199,8 +1201,13 @@ function parseEarlyConfigFrom(raw: Json, door: EarlyDoor, base: string | null):
   if (door === 'layers') {
     if ('seethrough' in t) checkSeeThrough(c, t.seethrough);
     if ('assemble' in t) {
-      const a = c.object('config.assemble', t.assemble, sectionRequired(door, 'assemble'), ['plan', 'extend_below_crop', 'patches', 'cuts', 'alternates']);
-      if (a !== null && 'rig_scale' in a) c.number('config.assemble.rig_scale', a.rig_scale, 'positive');
+      const a = c.object('config.assemble', t.assemble, sectionRequired(door, 'assemble'), ['plan', 'extend_below_crop', 'patches', 'cuts', 'alternates', 'head_face_underfill']);
+      if (a !== null) {
+        if ('rig_scale' in a) c.number('config.assemble.rig_scale', a.rig_scale, 'positive');
+        if ('head_face_underfill' in a && typeof a.head_face_underfill !== 'boolean') {
+          c.fail('CONFIG_FIELD_TYPE', 'config.assemble.head_face_underfill', `is ${show(a.head_face_underfill)}; true or false is required`);
+        }
+      }
     }
   }
   if (door === 'assemble') {
@@ -1210,19 +1217,23 @@ function parseEarlyConfigFrom(raw: Json, door: EarlyDoor, base: string | null):
     if ('scene' in t) checkScene(c, t.scene);
     // Issue #349: the limbs' joints are their bones' origins, so the bones are read with them, and only then.
     let limbs: LimbNames | null = null;
+    let names: { bones: Set<string>; chains: Map<string, number>; parents: Map<string, string> } | null = null;
     if ('limbs' in t) {
       if (!('bones' in t)) c.fail('CONFIG_FIELD_PRESENT', 'config.bones', 'is absent; config.limbs names bones, and each joint is its bone\'s origin, so assemble reads the bones with the limbs');
-      const names = 'bones' in t ? checkBones(c, t.bones) : null;
+      names = 'bones' in t ? checkBones(c, t.bones) : null;
       limbs = checkLimbs(c, t.limbs, made, names);
     }
     if (isPlainObject(t.assemble) && 'alternates' in t.assemble) {
-      checkAlternates(c, t.assemble.alternates, made, limbs, null);
+      checkAlternates(c, t.assemble.alternates, made, limbs, names?.bones ?? null, names?.chains ?? null, t.regions, t.meshes);
     }
   }
   if ('cloth' in t) checkCloth(c, t.cloth);
   const pose = base === null ? null : poseBeside(c, t.generation, base);
   refuseIfAny(c.problems);
-  return { config: raw as PaintConfig | EarlyConfig | AssembleConfig, pose };
+  const config = raw as PaintConfig | EarlyConfig | AssembleConfig;
+  const controlSkel = resolveControlSkeleton(t.generation, pose);
+  if (controlSkel !== undefined) controlSkeletons.set(config, controlSkel);
+  return { config, pose };
 }
 
 export function loadEarlyConfig(path: string, door: 'paint'): PaintConfig;
@@ -1242,6 +1253,40 @@ export function loadPaintConfig(path: string): { config: PaintConfig; pose: Cont
   return { config: config as PaintConfig, pose };
 }
 
+/**
+ * Issue #490: the control skeleton `config.generation.control.skeleton` names,
+ * with its points on the `generation.latent` canvas (`[w, h]`, x right, y down).
+ */
+export interface ControlSkeleton {
+  latent: readonly [number, number];
+  points: PosePoints;
+}
+
+const controlSkeletons = new WeakMap<object, ControlSkeleton>();
+
+function resolveControlSkeleton(gen: Json, pose: ControlPose | null): ControlSkeleton | undefined {
+  if (!isPlainObject(gen) || !isPlainObject(gen.control)) return undefined;
+  const l = gen.latent;
+  if (!(Array.isArray(l) && l.length === 2 && typeof l[0] === 'number' && typeof l[1] === 'number' && l[0] > 0 && l[1] > 0)) return undefined;
+  const latent: readonly [number, number] = [l[0], l[1]];
+  if (pose !== null) return { latent, points: pose.points };
+  const skel = gen.control.skeleton;
+  if (isSkeletonName(skel)) return { latent, points: scaledPoints(skel, latent[0], latent[1]) };
+  return undefined;
+}
+
+/**
+ * Return the {@link ControlSkeleton} resolved for a loaded or parsed config
+ * (`loadEarlyConfig`, `loadConfig`, `parseEarlyConfig`, `parseConfig`), or
+ * computed from an inline `generation.control.skeleton` built-in when present.
+ */
+export function controlSkeletonOf(cfg: object): ControlSkeleton | undefined {
+  const cached = controlSkeletons.get(cfg);
+  if (cached !== undefined) return cached;
+  const gen = (cfg as { generation?: unknown }).generation;
+  return resolveControlSkeleton(gen, null);
+}
+
 /** The pose file a checked `generation` block's control names, read relative to `base`; null for a built-in, an absent control, or a block already refused. */
 function poseBeside(c: Check, gen: Json, base: string): ControlPose | null {
   if (!isPlainObject(gen) || !isPlainObject(gen.control)) return null;
@@ -1368,7 +1413,7 @@ function parseConfigFrom(raw: Json, base: string | null): { config: CharacterCon
   const names = 'bones' in t ? checkBones(c, t.bones) : { bones: new Set<string>([ROOT_BONE]), chains: new Map<string, number>(), parents: new Map<string, string>() };
   const limbs = 'limbs' in t ? checkLimbs(c, t.limbs, { parts, patches, cuts }, 'bones' in t ? names : null) : null;
   if (isPlainObject(t.assemble) && 'alternates' in t.assemble) {
-    checkAlternates(c, t.assemble.alternates, { parts, patches, cuts }, limbs, names.bones);
+    checkAlternates(c, t.assemble.alternates, { parts, patches, cuts }, limbs, names.bones, names.chains, t.regions, t.meshes);
   }
   if ('meshes' in t) checkMeshes(c, t.meshes, names.bones, names.chains);
   if ('regions' in t) checkRegions(c, t.regions, names.bones);
@@ -1387,9 +1432,12 @@ function parseConfigFrom(raw: Json, base: string | null): { config: CharacterCon
     checkFaceAnimationBand(c, animations, hasAltFace, t.turn, attached);
     checkAnimationSetKeys(c, animations, t.assemble, new Set<string>([...parts, ...patches, ...cuts, ...(limbs?.parts.keys() ?? [])]));
   }
-  if (base !== null) poseBeside(c, t.generation, base);
+  const pose = base === null ? null : poseBeside(c, t.generation, base);
   refuseIfAny(c.problems);
-  return { config: raw as CharacterConfig, animations };
+  const config = raw as CharacterConfig;
+  const controlSkel = resolveControlSkeleton(t.generation, pose);
+  if (controlSkel !== undefined) controlSkeletons.set(config, controlSkel);
+  return { config, animations };
 }
 
 /**
@@ -1790,13 +1838,16 @@ function checkRunTag(c: Check, path: string, run: Json, tag: Json): void {
  */
 function checkAssemble(c: Check, v: Json, door: 'assemble' | 'full'): { parts: string[]; patches: string[]; cuts: string[] } {
   const required = sectionRequired(door, 'assemble');
-  const a = c.object('config.assemble', v, required.filter((k) => k !== 'plan'), ['plan', 'extend_below_crop', 'patches', 'cuts', 'alternates']);
+  const a = c.object('config.assemble', v, required.filter((k) => k !== 'plan'), ['plan', 'extend_below_crop', 'patches', 'cuts', 'alternates', 'head_face_underfill']);
   if (a === null) return { parts: [], patches: [], cuts: [] };
   if (required.includes('plan') && !('plan' in a)) {
     c.fail('CONFIG_FIELD_PRESENT', 'config.assemble.plan', 'is absent and required; `assemble --propose-plan` prints one from the two runs — paste its plan and extend_below_crop into config.assemble');
   }
   const p = 'config.assemble';
   if ('rig_scale' in a) c.number(`${p}.rig_scale`, a.rig_scale, 'positive');
+  if ('head_face_underfill' in a && typeof a.head_face_underfill !== 'boolean') {
+    c.fail('CONFIG_FIELD_TYPE', `${p}.head_face_underfill`, `is ${show(a.head_face_underfill)}; true or false is required`);
+  }
   const parts: string[] = [];
   if ('plan' in a && c.array(`${p}.plan`, a.plan, true)) {
     const seenPart = new Map<string, number>();
@@ -1902,10 +1953,18 @@ function checkAlternates(
   made: { parts: string[]; patches: string[]; cuts: string[] },
   limbs: LimbNames | null,
   bones: Set<string> | null = null,
+  chains: Map<string, number> | null = null,
+  regions: Json = undefined,
+  meshes: Json = undefined,
 ): void {
   const p = 'config.assemble.alternates';
   if (!c.array(p, v, true)) return;
-  const allSlots = new Set<string>([...made.parts, ...made.patches, ...made.cuts, ...(limbs?.parts.keys() ?? [])]);
+  const allSlots = new Set<string>([
+    ...made.parts.filter((n) => !(limbs?.consumed.has(n) ?? false)),
+    ...made.patches,
+    ...made.cuts,
+    ...(limbs?.parts.keys() ?? []),
+  ]);
   const seenNames = new Map<string, number>();
   (v as Json[]).forEach((entry, i) => {
     const at = `${p}[${i}]`;
@@ -1934,29 +1993,135 @@ function checkAlternates(
     }
     if ('head_box' in e) checkHeadBox(c, `${at}.head_box`, e.head_box);
     const altCuts = 'cuts' in e ? checkCuts(c, e.cuts, made.parts, [], `${at}.cuts`) : [];
+    let cutsConsumedLimb = false;
+    if (limbs !== null && 'cuts' in e && Array.isArray(e.cuts)) {
+      e.cuts.forEach((ce, ci) => {
+        if (!isPlainObject(ce) || typeof ce.from !== 'string') return;
+        const byLimb = limbs.consumed.get(ce.from);
+        if (byLimb !== undefined) {
+          cutsConsumedLimb = true;
+          const segList = (limbs.chains.get(byLimb)?.parts ?? []).map((s) => `"${s}"`).join(', ');
+          c.fail(
+            'CONFIG_LIMB_SET_JOINTS',
+            `${at}.cuts[${ci}].from`,
+            `cuts "${ce.from}", which config.limbs.${byLimb} cuts at the base's joints into ${segList}; a gesture set over a limb chain is cut at the base's joints and may not declare its own polygon cuts for that layer`,
+          );
+        }
+      });
+    }
     const validParts = new Set<string>([...allSlots, ...altCuts]);
+    const seenParts = new Set<string>();
     if ('parts' in e && c.array(`${at}.parts`, e.parts, true)) {
-      const seen = new Set<string>();
       (e.parts as Json[]).forEach((pn, k) => {
         if (!c.string(`${at}.parts[${k}]`, pn)) return;
-        if (!validParts.has(pn)) {
+        const byLimb = limbs?.consumed.get(pn);
+        if (byLimb !== undefined) {
+          const segList = (limbs?.chains.get(byLimb)?.parts ?? []).map((s) => `"${s}"`).join(', ');
+          c.fail(
+            'CONFIG_LIMB_SET_JOINTS',
+            `${at}.parts[${k}]`,
+            `names "${pn}", which config.limbs.${byLimb} cuts at the base's joints into ${segList}; a gesture set covers the limb chain's segment parts at the base's joints, not the unsplit layer`,
+          );
+        } else if (!validParts.has(pn)) {
           c.fail('CONFIG_NAME_RESOLVES', `${at}.parts[${k}]`, `is ${show(pn)}; a slot of the base rig (or a part made by this alternate's cuts) is required`);
-        } else if (seen.has(pn)) {
+        } else if (seenParts.has(pn)) {
           c.fail('CONFIG_PART_UNIQUE', `${at}.parts[${k}]`, `repeats "${pn}"; each covered part is named once`);
-        } else seen.add(pn);
+        } else seenParts.add(pn);
       });
     }
+    const seenHides = new Set<string>();
     if ('hides' in e && c.array(`${at}.hides`, e.hides, false)) {
-      const seen = new Set<string>();
       (e.hides as Json[]).forEach((hn, k) => {
         if (!c.string(`${at}.hides[${k}]`, hn)) return;
-        if (!allSlots.has(hn)) {
+        const byLimb = limbs?.consumed.get(hn);
+        if (byLimb !== undefined) {
+          const segList = (limbs?.chains.get(byLimb)?.parts ?? []).map((s) => `"${s}"`).join(', ');
+          c.fail(
+            'CONFIG_LIMB_SET_JOINTS',
+            `${at}.hides[${k}]`,
+            `names "${hn}", which config.limbs.${byLimb} cuts at the base's joints into ${segList}; a gesture set covers the limb chain's segment parts at the base's joints, not the unsplit layer`,
+          );
+        } else if (!allSlots.has(hn)) {
           c.fail('CONFIG_NAME_RESOLVES', `${at}.hides[${k}]`, `is ${show(hn)}; a slot of the base rig is required`);
-        } else if (seen.has(hn)) {
+        } else if (seenHides.has(hn)) {
           c.fail('CONFIG_PART_UNIQUE', `${at}.hides[${k}]`, `repeats "${hn}"; each hidden slot is named once`);
-        } else seen.add(hn);
+        } else seenHides.add(hn);
       });
     }
+    if ('parts' in e && limbs !== null) {
+      for (const [limbName, chain] of limbs.chains) {
+        const coveredSegs = chain.parts.filter((sp) => seenParts.has(sp) && !seenHides.has(sp));
+        const hiddenSegs = chain.parts.filter((sp) => seenHides.has(sp));
+        if ((coveredSegs.length > 0 || hiddenSegs.length > 0) && coveredSegs.length !== chain.parts.length) {
+          c.fail(
+            'CONFIG_LIMB_SET_JOINTS',
+            `${at}.parts`,
+            `covers [${coveredSegs.map((s) => `"${s}"`).join(', ')}]${hiddenSegs.length > 0 ? ` (and hides [${hiddenSegs.map((s) => `"${s}"`).join(', ')}])` : ''} of config.limbs.${limbName}, which cuts at the base's joints into [${chain.parts.map((s) => `"${s}"`).join(', ')}]; a gesture set over a limb chain must cover all ${chain.parts.length} of its segment parts so it is cut at the base's joints`,
+          );
+        } else if (coveredSegs.length === chain.parts.length && !cutsConsumedLimb && 'cuts' in e && Array.isArray(e.cuts) && e.cuts.length > 0) {
+          c.fail(
+            'CONFIG_LIMB_SET_JOINTS',
+            `${at}.cuts`,
+            `declares custom polygon cuts on a gesture set covering config.limbs.${limbName}; a gesture set is cut at the base's joints and declares no cuts of its own`,
+          );
+        }
+      }
+    }
+    if ('parts' in e && 'drawn' in e && isPlainObject(e.drawn)) {
+      const activeParts = [...seenParts].filter((pn) => !seenHides.has(pn));
+      const coveredBones = new Set<string>();
+      let allPartsResolved = activeParts.length > 0;
+      for (const pn of activeParts) {
+        const limbSeg = limbs?.parts.get(pn);
+        if (limbSeg !== undefined) {
+          coveredBones.add(limbSeg.bone);
+        } else if (isPlainObject(regions) && typeof regions[pn] === 'string') {
+          coveredBones.add(regions[pn]);
+        } else if (isPlainObject(meshes) && isPlainObject(meshes[pn])) {
+          const m = meshes[pn] as Record<string, Json>;
+          if (Array.isArray(m.segments)) {
+            for (const s of m.segments) {
+              if (typeof s === 'string') {
+                const links = chains?.get(s);
+                if (links !== undefined) {
+                  for (let lk = 0; lk < links; lk++) coveredBones.add(`${s}${lk}`);
+                } else {
+                  coveredBones.add(s);
+                }
+              } else if (Array.isArray(s) && typeof s[0] === 'string') {
+                coveredBones.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') coveredBones.add(rg.bone);
+            }
+            if (isPlainObject(m.contour.bust)) {
+              coveredBones.add(typeof m.contour.bust.bone_r === 'string' ? m.contour.bust.bone_r : DEFAULT_BUST_BONE_R);
+              coveredBones.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') coveredBones.add(rg.bone);
+          }
+        } else {
+          allPartsResolved = false;
+        }
+      }
+      if (allPartsResolved) {
+        const coveredList = [...coveredBones].map((b) => `"${b}"`).join(', ') || 'none';
+        for (const bName of Object.keys(e.drawn)) {
+          if ((bones === null || bones.has(bName)) && !coveredBones.has(bName)) {
+            c.fail(
+              'CONFIG_SET_COVERS_BONE',
+              `${at}.drawn.${bName}`,
+              `names "${bName}", which alternate set "${String(e.name ?? '')}" does not cover (covered bones: ${coveredList}); a subset set may state drawn angles only for the bones its covered parts ride`,
+            );
+          }
+        }
+      }
+    }
   });
 }
 
@@ -2593,6 +2758,7 @@ function checkRegions(c: Check, v: Json, bones: Set<string>): void {
 interface LimbNames {
   parts: Map<string, { bone: string; at: string }>;
   consumed: Map<string, string>;
+  chains: Map<string, { parts: string[]; bones: string[]; froms: string[] }>;
 }
 
 /**
@@ -2618,7 +2784,7 @@ interface LimbNames {
  * resolved. Returns the limb parts and the parts the limbs take.
  */
 function checkLimbs(c: Check, v: Json, made: { parts: string[]; patches: string[]; cuts: string[] }, names: { bones: Set<string>; parents: Map<string, string> } | null): LimbNames {
-  const out: LimbNames = { parts: new Map(), consumed: new Map() };
+  const out: LimbNames = { parts: new Map(), consumed: new Map(), chains: new Map() };
   if (!isPlainObject(v)) {
     c.fail('CONFIG_FIELD_TYPE', 'config.limbs', `is ${show(v)}; an object of limb name -> {"segments": [...]} is required`);
     return out;
@@ -2663,11 +2829,13 @@ function checkLimbs(c: Check, v: Json, made: { parts: string[]; patches: string[
       continue;
     }
     const segs = o.segments as Json[];
+    const segParts: Array<string | null> = [];
     const froms: Array<string | null> = [];
     const bones: Array<string | null> = [];
     segs.forEach((entry, i) => {
       const sat = `${at}.segments[${i}]`;
       const e = c.object(sat, entry, ['part', 'from', 'bone'], ['joint', 'range', 'cap', 'edge', 'cap_shape', 'cut_band']);
+      segParts.push(null);
       froms.push(null);
       bones.push(null);
       if (e === null) return;
@@ -2683,6 +2851,7 @@ function checkLimbs(c: Check, v: Json, made: { parts: string[]; patches: string[
         } else if (firstAt.has(name)) c.fail('CONFIG_PART_UNIQUE', `${sat}.part`, `names the part "${name}" again (first at ${firstAt.get(name)})`);
         else {
           firstAt.set(name, sat);
+          segParts[i] = name;
           if ('bone' in e && typeof e.bone === 'string') out.parts.set(name, { bone: e.bone, at: `config.limbs.${limb} segment ${i}` });
         }
       }
@@ -2727,6 +2896,11 @@ function checkLimbs(c: Check, v: Json, made: { parts: string[]; patches: string[
         }
       }
     });
+    out.chains.set(limb, {
+      parts: segParts.filter((q): q is string => q !== null),
+      bones: bones.filter((q): q is string => q !== null),
+      froms: [...new Set(froms.filter((q): q is string => q !== null))],
+    });
     limbFroms.set(limb, new Set(froms.filter((f): f is string => f !== null)));
     froms.forEach((f, i) => {
       if (f === null || i === 0 || froms[i - 1] === f) return;

package/src/limbs.ts

@@ -125,6 +125,98 @@ export function bonePlaces(bones: readonly BoneEntry[]): Map<string, BonePlace>
   return out;
 }
 
+/**
+ * Issue #476: pose `bones` (in rig pixels, y down) so every bone named in
+ * `drawn` takes that world angle (in Spine degrees, CCW, y up) while keeping
+ * its base length and parent-to-child joint offsets. Used by `assemble` when
+ * an alternate set covers a limb chain at its own `drawn` angles, so `cutLimbs`
+ * cuts the set's painting at the base's joints posed to `drawn`.
+ */
+export function poseBoneEntriesForDrawn(bones: readonly BoneEntry[], drawn: Readonly<Record<string, number>>): BoneEntry[] {
+  if (Object.keys(drawn).length === 0) return [...bones];
+  interface FlatNode {
+    name: string;
+    parent: string;
+    at0: Pt;
+    end0: Pt | null;
+    theta0: number;
+    length: number;
+    inherit?: string;
+  }
+  const flat = new Map<string, FlatNode>();
+  for (const b of bones) {
+    if ('chain' in b) {
+      b.points.forEach((p, k) => {
+        const name = `${b.chain}${k}`;
+        const parent = k === 0 ? b.parent : `${b.chain}${k - 1}`;
+        const at0: Pt = [p[0], p[1]];
+        const end0: Pt = k + 1 < b.points.length ? [b.points[k + 1][0], b.points[k + 1][1]] : [b.tip[0], b.tip[1]];
+        const dx = end0[0] - at0[0];
+        const dy = end0[1] - at0[1];
+        const theta0 = (Math.atan2(-dy, dx) * 180) / Math.PI;
+        const length = Math.sqrt(dx * dx + dy * dy);
+        flat.set(name, { name, parent, at0, end0, theta0, length, inherit: b.link_inherit?.[name] });
+      });
+    } else {
+      const at0: Pt = [b.at[0], b.at[1]];
+      const end0: Pt | null = b.tip === undefined ? null : [b.tip[0], b.tip[1]];
+      const dx = end0 === null ? 0 : end0[0] - at0[0];
+      const dy = end0 === null ? 0 : end0[1] - at0[1];
+      const theta0 = end0 === null ? 0 : (Math.atan2(-dy, dx) * 180) / Math.PI;
+      const length = end0 === null ? 0 : Math.sqrt(dx * dx + dy * dy);
+      flat.set(b.name, { name: b.name, parent: b.parent, at0, end0, theta0, length, inherit: b.inherit });
+    }
+  }
+  const posed = new Map<string, { at: Pt; end: Pt | null; theta: number }>();
+  const solve = (name: string): { at: Pt; end: Pt | null; theta: number } => {
+    const cached = posed.get(name);
+    if (cached !== undefined) return cached;
+    const node = flat.get(name);
+    if (node === undefined) return { at: [0, 0], end: null, theta: 0 };
+    let at: Pt = [node.at0[0], node.at0[1]];
+    let dParent = 0;
+    const pNode = flat.get(node.parent);
+    if (pNode !== undefined) {
+      const pPosed = solve(node.parent);
+      dParent = pPosed.theta - pNode.theta0;
+      const rad = (dParent * Math.PI) / 180;
+      const cos = Math.cos(rad);
+      const sin = Math.sin(rad);
+      const dx0 = node.at0[0] - pNode.at0[0];
+      const dy0 = node.at0[1] - pNode.at0[1];
+      at = [pPosed.at[0] + dx0 * cos + dy0 * sin, pPosed.at[1] - dx0 * sin + dy0 * cos];
+    }
+    const inheritsRot = node.inherit !== 'noRotationOrReflection' && node.inherit !== 'onlyTranslation';
+    const theta = drawn[name] !== undefined ? drawn[name] : node.theta0 + (inheritsRot ? dParent : 0);
+    let end: Pt | null = null;
+    if (node.end0 !== null) {
+      const rad = (theta * Math.PI) / 180;
+      end = [at[0] + node.length * Math.cos(rad), at[1] - node.length * Math.sin(rad)];
+    }
+    const res = { at, end, theta };
+    posed.set(name, res);
+    return res;
+  };
+  for (const name of flat.keys()) solve(name);
+  return bones.map((b): BoneEntry => {
+    if ('chain' in b) {
+      const points = b.points.map((_, k): Pt => {
+        const s = solve(`${b.chain}${k}`);
+        return [s.at[0], s.at[1]];
+      });
+      const last = solve(`${b.chain}${b.points.length - 1}`);
+      const tip: Pt = last.end === null ? [b.tip[0], b.tip[1]] : [last.end[0], last.end[1]];
+      return { ...b, points, tip };
+    }
+    const s = solve(b.name);
+    return {
+      ...b,
+      at: [s.at[0], s.at[1]],
+      ...(b.tip === undefined || s.end === null ? {} : { tip: [s.end[0], s.end[1]] }),
+    };
+  });
+}
+
 /** A limb's polyline: its segments' bone origins in order, then the last bone's end when it has one. */
 export function limbPolyline(limb: Limb, places: ReadonlyMap<string, BonePlace>): Pt[] {
   const pts = limb.segments.map((s) => (places.get(s.bone) as BonePlace).at);