@rig-c/parts 1.34.0 → 1.36.0

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);

package/src/propose.ts

@@ -127,7 +127,8 @@
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { drawText, GLYPH_H } from 'rig-c/tools/font5x7.ts';
-import { type BoneEntry, type ConfigConstraint, type ConfigStop, type Limb, type MeshSpec, parseConfig, type Point, type Segment, type SkeletonSections } from './config.ts';
+import { type BoneEntry, type ConfigConstraint, type ConfigStop, contourRegionsOf, deriveBustRegions, type Limb, type MeshSpec, parseConfig, type Point, type Segment, type SkeletonSections } from './config.ts';
+export { contourRegionsOf, deriveBustRegions };
 import { computeExactFrameTransforms, cropToSpineY, normaliseDegrees, toWorld } from './coords.ts';
 import { PartsError, type Problem, refuseIfAny } from './errors.ts';
 import { eyeLineDegrees, type FrameFeature, headAxes, type HeadAxes, headFrame, type HeadFrame } from './headframe.ts';

package/src/rig.ts

@@ -132,7 +132,7 @@
  * touches the disk, and the same inputs give the same bytes (key order is the
  * order the objects are built in, and every number is rounded by `pyRound`).
  */
-import { type AutoSpec, type BoneEntry, type WeightRule, type CharacterConfig, type ConfigConstraint, type ConfigStop, CONSTRAINT_FOLLOWS, constraintForRig, type ContourSpec, type Point, type RibsSpec, ROOT_BONE, stopForRig, weightsABone } from './config.ts';
+import { type AutoSpec, type BoneEntry, 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, weightsABone } from './config.ts';
 import { type BoneTransform, computeExactFrameTransforms, cropToSpineY, normaliseDegrees, toBoneLocal, toWorld } from './coords.ts';
 import { type Problem, refuseIfAny } from './errors.ts';
 import { eyeLineDegrees } from './headframe.ts';
@@ -164,6 +164,7 @@ import {
 } from './automesh.ts';
 import { type ContourChainRibs, type ContourReport, contourMesh, type ContourRegion, type ContourRib } from './contour.ts';
 import { type LocalInfluence, localInfluences } from './localweights.ts';
+import { edgeLength } from './length.ts';
 import { artCoverage, ART_ALPHA, latticeCells, latticeMesh, latticeStray, ONE_LOOP_PASSES } from './mesh.ts';
 import { bindFaceSurfaceDeform, BLINK, blinkHoldMisses, blinkSpan, CONTROL_SUFFIX, controlledBones, IDLE_FPS, idleMotion, type MotionSpec, moveKeysToControls } from './motion.ts';
 import { type AlternateSetMap, PAINTING_RUN, type PartsFile, readFrom, tagOf } from './parts.ts';
@@ -1006,8 +1007,12 @@ export function deriveAlternateDrawn(
   const limbPairs: ReadonlyArray<readonly [string, readonly [number, number], readonly [number, number]]> = [
     ['sleeve_r0', pts.r_shoulder, pts.r_elbow],
     ['sleeve_r1', pts.r_elbow, pts.r_wrist],
+    ['arm_r0', pts.r_shoulder, pts.r_elbow],
+    ['arm_r1', pts.r_elbow, pts.r_wrist],
     ['sleeve_l0', pts.l_shoulder, pts.l_elbow],
     ['sleeve_l1', pts.l_elbow, pts.l_wrist],
+    ['arm_l0', pts.l_shoulder, pts.l_elbow],
+    ['arm_l1', pts.l_elbow, pts.l_wrist],
     ['leg_r0', pts.r_hip, pts.r_knee],
     ['leg_r1', pts.r_knee, pts.r_ankle],
     ['leg_l0', pts.l_hip, pts.l_knee],
@@ -1161,6 +1166,14 @@ export function buildRig(
       (m.contour.regions ?? []).forEach((rg, i) => {
         if (!B.has(rg.bone)) fail('RIG_NAME_RESOLVES', `config.meshes.${part}.contour.regions[${i}].bone`, `names the bone "${rg.bone}", which config.bones does not declare`);
       });
+      if (m.contour.bust !== undefined) {
+        for (const [k, bone] of [
+          ['bone_r', m.contour.bust.bone_r ?? DEFAULT_BUST_BONE_R],
+          ['bone_l', m.contour.bust.bone_l ?? DEFAULT_BUST_BONE_L],
+        ] as const) {
+          if (!B.has(bone)) fail('RIG_NAME_RESOLVES', `config.meshes.${part}.contour.bust.${k}`, `names the bone "${bone}", which config.bones does not declare`);
+        }
+      }
     }
     if ('auto' in m) {
       (m.auto.regions ?? []).forEach((rg, i) => {
@@ -1274,7 +1287,7 @@ export function buildRig(
   for (const segs of meshSegments.values()) for (const s of segs) meshBones.add(s.bone);
   // A contour region's control bone is weighted to like a segment's bone (issue #84), so the idle's keys on it move
   // to its control under `ctl` as theirs do. A config with no contour region adds nothing here.
-  for (const m of Object.values(cfg.meshes)) if ('contour' in m) for (const rg of m.contour.regions ?? []) meshBones.add(rg.bone);
+  for (const m of Object.values(cfg.meshes)) if ('contour' in m) for (const rg of contourRegionsOf(m.contour)) meshBones.add(rg.bone);
   for (const m of Object.values(cfg.meshes)) if ('auto' in m) for (const rg of m.auto.regions ?? []) if (weightsABone(rg)) meshBones.add(rg.bone);
   const meshKeyed = controlledBones(motion, meshBones);
   const controls = idleKeys === 'ctl' ? meshKeyed : [];
@@ -1600,7 +1613,7 @@ export function buildRig(
     const h = img.height;
     const alpha = new Uint8Array(w * h);
     for (let i = 0; i < alpha.length; i++) alpha[i] = img.data[i * 4 + 3];
-    const regions = spec.regions ?? [];
+    const regions = contourRegionsOf(spec);
     const inPart: ContourRegion[] = regions.map((rg) =>
       rg.shape === 'circle'
         ? { name: rg.name, shape: 'circle', cx: rg.cx - ox, cy: rg.cy - oy, r: rg.r, spacing: rg.spacing, band: rg.band }
@@ -1635,10 +1648,25 @@ export function buildRig(
       const li = localInfluences([wx, wy], vSegs, r, regions, limits, exponent ?? DISTANCE_EXPONENT, heat === null ? undefined : heatInfluences(heat, [vx, vy], limits));
       if ('first' in li) {
         if (!overlapped) {
+          let bustHint = '';
+          if (spec.bust !== undefined) {
+            const need: number[] = [];
+            for (const rg of [regions[li.first], regions[li.second]]) {
+              if (rg.name === 'bust_r' || rg.name === 'bust_l') {
+                const apex = rg.name === 'bust_r' ? spec.bust.apex_r : spec.bust.apex_l;
+                const d = edgeLength(spec.bust.cleavage[0] - apex[0], spec.bust.cleavage[1] - apex[1]);
+                const dist = edgeLength(wx - apex[0], wy - apex[1]);
+                need.push(pyRound(d - dist, 2));
+              }
+            }
+            if (need.length > 0) {
+              bustHint = ` (contour.bust.clearance >= ${Math.min(...need)} clears vertex ${vi})`;
+            }
+          }
           out.push({
             code: 'RIG_CONTOUR_REGIONS_OVERLAP',
             object: `config.meshes.${p.name}.contour.regions`,
-            detail: `vertex ${vi} at rig (${wx}, ${wy}) takes weight ${pyRound(li.g1, 5)} from region "${regions[li.first].name}" and ${pyRound(li.g2, 5)} from region "${regions[li.second].name}"; each vertex may be reached by one region's falloff (its region and band) — move the regions apart or narrow a band`,
+            detail: `vertex ${vi} at rig (${wx}, ${wy}) takes weight ${pyRound(li.g1, 5)} from region "${regions[li.first].name}" and ${pyRound(li.g2, 5)} from region "${regions[li.second].name}"; each vertex may be reached by one region's falloff (its region and band) — move the regions apart or narrow a band${bustHint}`,
           });
         }
         overlapped = true;
@@ -2085,17 +2113,44 @@ export function buildRig(
     for (const [altIdx, alt] of parts.alternates.entries()) {
       const cfgAlt = cfg.alternates?.find((a) => a.name === alt.name);
       const explicitDrawn = alt.drawn ?? cfgAlt?.drawn;
+      const isSubsetSet = alt.parts !== undefined || cfgAlt?.parts !== undefined;
+      let coveredBones: Set<string> | null = null;
+      if (isSubsetSet) {
+        coveredBones = new Set<string>();
+        for (const pName of Object.keys(alt.slots)) {
+          if (pName in cfg.regions) coveredBones.add(cfg.regions[pName]);
+          for (const s of meshSegments.get(pName) ?? []) coveredBones.add(s.bone);
+          const m = cfg.meshes[pName];
+          if (m !== undefined) {
+            if ('contour' in m) for (const rg of contourRegionsOf(m.contour)) coveredBones.add(rg.bone);
+            if ('auto' in m) for (const rg of m.auto.regions ?? []) if (weightsABone(rg)) coveredBones.add(rg.bone);
+          }
+        }
+      }
       if (explicitDrawn !== undefined) {
         for (const boneName of Object.keys(explicitDrawn)) {
           if (!B.has(boneName)) {
             fail('RIG_NAME_RESOLVES', `config.alternates[${altIdx}].drawn.${boneName}`, `names the bone "${boneName}", which config.bones does not declare`);
+          } else if (coveredBones !== null && !coveredBones.has(boneName)) {
+            const coveredList = [...coveredBones].map((b) => `"${b}"`).join(', ') || 'none';
+            fail(
+              'RIG_SET_COVERS_BONE',
+              `config.assemble.alternates[${altIdx}].drawn.${boneName}`,
+              `names "${boneName}", which alternate set "${alt.name}" does not cover (covered bones: ${coveredList}); a subset set may state drawn angles only for the bones its covered parts ride`,
+            );
           }
         }
       }
       refuseIfAny(problems);
-      const derived = alt.skeleton === undefined ? undefined : deriveAlternateDrawn(alt.skeleton, B, turn, CX, H);
+      const rawDerived = alt.skeleton === undefined ? undefined : deriveAlternateDrawn(alt.skeleton, B, turn, CX, H);
+      const derived =
+        rawDerived === undefined
+          ? undefined
+          : coveredBones === null
+            ? rawDerived
+            : Object.fromEntries(Object.entries(rawDerived).filter(([k]) => coveredBones.has(k)));
       const drawn: Record<string, number> | undefined =
-        derived === undefined && explicitDrawn === undefined
+        (derived === undefined || Object.keys(derived).length === 0) && explicitDrawn === undefined
           ? undefined
           : {
               ...(derived ?? {}),
@@ -2299,6 +2354,7 @@ export function buildRig(
   const partAreas: Record<string, number> = {};
   for (const p of parts.parts) partAreas[p.name] = p.opaque_px;
   bindFaceSurfaceDeform(motion, (merged) => {
+    expandSetAttachmentKeys(rig, sets, merged);
     applyFaceSurfaceDeform(rig, merged, {
       imageWidth: faceImg?.width,
       imageHeight: faceImg?.height,
@@ -2334,6 +2390,186 @@ export function buildRig(
   };
 }
 
+/**
+ * Issue #473: expand `{"t": …, "set": "<name>" | null}` keys on slot attachment
+ * tracks in `merged.animations` into `{"t": …, "v": "<attachment>" | null}`
+ * keys against `rig.slots` and `sets.json`. When no key carries `"set"`, nothing
+ * is touched and no byte moves.
+ */
+export function expandSetAttachmentKeys(rig: RigSpec, sets: AttachmentSetsFile | undefined, merged: MotionSpec): void {
+  let hasAnySetKey = false;
+  for (const [animName, anim] of Object.entries(merged.animations)) {
+    if (animName === 'idle' || typeof anim !== 'object' || anim === null || Array.isArray(anim)) continue;
+    const tracks = (anim as Record<string, unknown>).tracks;
+    if (!Array.isArray(tracks)) continue;
+    for (const tr of tracks) {
+      if (typeof tr !== 'object' || tr === null || Array.isArray(tr)) continue;
+      const keys = (tr as Record<string, unknown>).keys;
+      if (!Array.isArray(keys)) continue;
+      for (const k of keys) {
+        if (typeof k === 'object' && k !== null && !Array.isArray(k) && 'set' in k) {
+          hasAnySetKey = true;
+          break;
+        }
+      }
+      if (hasAnySetKey) break;
+    }
+    if (hasAnySetKey) break;
+  }
+  if (!hasAnySetKey) return;
+
+  const baseSlots = new Map<string, string | null>();
+  const slotBoneMap = new Map<string, string>();
+  for (const sl of rig.slots) {
+    baseSlots.set(sl.name, sl.attachment ?? null);
+    const rawBone = sl.bone.startsWith(`${sl.name}__`) ? sl.bone.slice(`${sl.name}__`.length) : sl.bone;
+    slotBoneMap.set(sl.name, rawBone);
+  }
+  const setupRotByBone = new Map<string, number>();
+  for (const b of rig.bones) setupRotByBone.set(b.name, b.rotation ?? 0);
+  const setBoneDeltas = new Map<string, Map<string, number>>();
+  if (sets !== undefined) {
+    for (const [setName, entry] of Object.entries(sets.sets)) {
+      if (entry.drawn === undefined || Object.keys(entry.drawn).length === 0) continue;
+      const posed = poseRigBonesForDrawn(rig.bones, entry.drawn, rig.stops);
+      const deltas = new Map<string, number>();
+      for (const b of posed) {
+        if (Object.hasOwn(entry.drawn, b.name)) {
+          const d = places(normaliseDegrees((b.rotation ?? 0) - (setupRotByBone.get(b.name) ?? 0)));
+          deltas.set(b.name, d);
+        }
+      }
+      setBoneDeltas.set(setName, deltas);
+    }
+  }
+  const declaredSets =
+    sets === undefined || Object.keys(sets.sets).length === 0
+      ? 'none'
+      : Object.keys(sets.sets)
+          .map((n) => `"${n}"`)
+          .join(', ');
+  const problems: Problem[] = [];
+
+  for (const [animName, anim] of Object.entries(merged.animations)) {
+    if (animName === 'idle' || typeof anim !== 'object' || anim === null || Array.isArray(anim)) continue;
+    const tracks = (anim as Record<string, unknown>).tracks;
+    if (!Array.isArray(tracks)) continue;
+    const existingRotateBones = new Set<string>();
+    for (const tr of tracks) {
+      if (typeof tr === 'object' && tr !== null && !Array.isArray(tr)) {
+        const r = tr as Record<string, unknown>;
+        if (r.property === 'rotate' && typeof r.bone === 'string') existingRotateBones.add(r.bone);
+      }
+    }
+    const synthesizedRotate = new Map<string, Array<Record<string, unknown>>>();
+    tracks.forEach((tr, ti) => {
+      if (typeof tr !== 'object' || tr === null || Array.isArray(tr)) return;
+      const trRec = tr as Record<string, unknown>;
+      const keys = trRec.keys;
+      if (!Array.isArray(keys)) return;
+      const slot = typeof trRec.slot === 'string' && trRec.slot !== '' ? trRec.slot : null;
+      const isAttachmentTrack = trRec.property === 'attachment' && slot !== null;
+      const slotBone = slot === null ? undefined : slotBoneMap.get(slot);
+      let trackTouchesDrawnBone = false;
+      const rawSetKeysForBone: Array<{ t: unknown; setVal: string | null }> = [];
+      keys.forEach((k, ki) => {
+        if (typeof k !== 'object' || k === null || Array.isArray(k) || !('set' in k)) return;
+        const kRec = k as Record<string, unknown>;
+        const keyAt = `animations.${animName}.tracks[${ti}].keys[${ki}].set`;
+        if (!isAttachmentTrack || slot === null) {
+          problems.push({
+            code: 'CONFIG_SET_COVERS_SLOT',
+            object: keyAt,
+            detail: `is ${JSON.stringify(kRec.set)} on a ${JSON.stringify(trRec.property)} track${slot === null ? '' : ` for slot "${slot}"`}; a "set" key belongs on a slot attachment track ({"slot": "<part>", "property": "attachment", "keys": [{"t": …, "set": "<name>" | null}]})`,
+          });
+          return;
+        }
+        if ('v' in kRec) {
+          problems.push({
+            code: 'CONFIG_FIELD_TYPE',
+            object: keyAt,
+            detail: `is declared beside v (${JSON.stringify(kRec.v)}); state either "set": "<name>" | null or "v": "<attachment>" | null on an attachment key, not both`,
+          });
+          return;
+        }
+        const setVal = kRec.set;
+        let resolvedV: string | null = null;
+        if (setVal === null) {
+          if (!baseSlots.has(slot)) {
+            problems.push({
+              code: 'CONFIG_SET_COVERS_SLOT',
+              object: keyAt,
+              detail: `restores the base attachment on slot "${slot}", which is not a declared slot of the rig (declared slots: ${[...baseSlots.keys()].map((s) => `"${s}"`).join(', ')})`,
+            });
+            return;
+          }
+          resolvedV = baseSlots.get(slot) ?? null;
+          rawSetKeysForBone.push({ t: kRec.t, setVal: null });
+        } else if (typeof setVal !== 'string' || setVal === '') {
+          problems.push({
+            code: 'CONFIG_FIELD_TYPE',
+            object: keyAt,
+            detail: `is ${JSON.stringify(setVal)}; a non-empty alternate set name or null (the base pose) is required`,
+          });
+          return;
+        } else {
+          const entry = sets?.sets[setVal];
+          if (entry === undefined) {
+            problems.push({
+              code: 'CONFIG_SET_COVERS_SLOT',
+              object: keyAt,
+              detail: `names alternate set "${setVal}" for slot "${slot}", which config.assemble.alternates does not declare (declared sets: ${declaredSets})`,
+            });
+            return;
+          }
+          if (Object.hasOwn(entry.slots, slot)) {
+            resolvedV = entry.slots[slot];
+          } else if (entry.hides?.includes(slot) === true) {
+            resolvedV = null;
+          } else {
+            const covered = [...Object.keys(entry.slots), ...(entry.hides ?? [])].map((s) => `"${s}"`).join(', ') || 'none';
+            problems.push({
+              code: 'CONFIG_SET_COVERS_SLOT',
+              object: keyAt,
+              detail: `names alternate set "${setVal}" on slot "${slot}", which set "${setVal}" does not cover (set "${setVal}" covers: ${covered}); add "${slot}" to that set's parts (or hides) in config.assemble.alternates, or key a slot the set covers`,
+            });
+            return;
+          }
+          if (slotBone !== undefined && setBoneDeltas.get(setVal)?.has(slotBone) === true) {
+            trackTouchesDrawnBone = true;
+          }
+          rawSetKeysForBone.push({ t: kRec.t, setVal });
+        }
+        const expanded: Record<string, unknown> = {};
+        for (const [prop, val] of Object.entries(kRec)) {
+          if (prop === 'set') expanded.v = resolvedV;
+          else expanded[prop] = val;
+        }
+        keys[ki] = expanded;
+      });
+      if (
+        problems.length === 0 &&
+        trackTouchesDrawnBone &&
+        slotBone !== undefined &&
+        !existingRotateBones.has(slotBone) &&
+        !synthesizedRotate.has(slotBone)
+      ) {
+        const rotKeys = rawSetKeysForBone.map((rk, idx) => {
+          const d = rk.setVal === null ? 0 : (setBoneDeltas.get(rk.setVal)?.get(slotBone) ?? 0);
+          return idx + 1 < rawSetKeysForBone.length ? { t: rk.t, v: [d], curve: 'stepped' } : { t: rk.t, v: [d] };
+        });
+        synthesizedRotate.set(slotBone, rotKeys);
+      }
+    });
+    if (problems.length === 0) {
+      for (const [boneName, rotKeys] of synthesizedRotate) {
+        tracks.push({ bone: boneName, property: 'rotate', keys: rotKeys });
+      }
+    }
+  }
+  refuseIfAny(problems);
+}
+
 /**
  * Re-parent every bone that hangs from a stopped link onto that link's drawn
  * link `<link>_d`, move slots and mesh weights from a stopped link onto

package/src/structure.ts

@@ -72,7 +72,7 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { CompileError } from 'rig-c/src/errors.ts';
 import { parseRigSpec, RIG_SPEC_VERSION, type RigBone as RigcBone, type RigSpec as RigcSpec, splitRigSkin } from 'rig-c/src/rig.ts';
-import { type ConfigConstraint, CONSTRAINT_FOLLOWS, parseConfig, parseProposalSections, type Point, ROOT_BONE, type SkeletonSections, weightsABone } from './config.ts';
+import { type ConfigConstraint, CONSTRAINT_FOLLOWS, contourRegionsOf, parseConfig, parseProposalSections, type Point, ROOT_BONE, type SkeletonSections, weightsABone } from './config.ts';
 import { computeExactFrameTransforms, cropToSpineY, normaliseDegrees, toWorld } from './coords.ts';
 import { PartsError, type Problem, refuseIfAny } from './errors.ts';
 import { edgeLength } from './length.ts';
@@ -183,8 +183,11 @@ export function configRoles(s: SkeletonSections & { constraints?: readonly Confi
       if (typeof sp === 'string') for (const b of chains.get(sp) ?? [sp]) push(bound, b, at);
       else push(bound, sp[0], at);
     });
-    // A contour mesh's region bone is weighted to, like a segment's (issue #84).
-    if ('contour' in m) (m.contour.regions ?? []).forEach((rg, i) => push(bound, rg.bone, `meshes.${part}.contour.regions[${i}]`));
+    // A contour mesh's region bone is weighted to, like a segment's (issue #84; including contour.bust, issue #475).
+    if ('contour' in m) {
+      const explicitCount = (m.contour.regions ?? []).length;
+      contourRegionsOf(m.contour).forEach((rg, i) => push(bound, rg.bone, i < explicitCount ? `meshes.${part}.contour.regions[${i}]` : `meshes.${part}.contour.bust`));
+    }
     if ('auto' in m) (m.auto.regions ?? []).forEach((rg, i) => {
         // A density-only region binds no bone (issue #155).
         if (weightsABone(rg)) push(bound, rg.bone, `meshes.${part}.auto.regions[${i}]`);