@rig-c/parts 1.31.0 → 1.32.0

package/cli.ts

@@ -335,6 +335,7 @@ usage:
   rig-parts check --rig <dir> --out <dir> [--parts <dir>] [--source <painting.png>]
                     [--page-edges pot|free] [--pack-shape rect|polygon]
                     [--requirements <file.json>] [--seam-pairs] [--keep-stills]
+                    [--set <name> | --all-sets]
       Build, gate, render and measure a rig through rig-c's CLI (the rigc at
       node_modules/.bin/rigc, or on PATH). --rig holds rig.json and motion.json:
       a rig spec, which rigc build compiles, not a compiled skeleton.json.
@@ -567,7 +568,7 @@ usage:
                     [--project core|visible] [--page-edges pot|free]
                     [--pack-shape rect|polygon] [--loop] [--requirements <file.json>]
                     [--idle-keys ctl|direct] [--lead-in <periods>] [--seam-pairs] [--keep-stills]
-                    [--alt <name>=<source>:<full>[:<head>]]
+                    [--alt <name>=<source>:<full>[:<head>]] [--set <name> | --all-sets]
       assemble, then rig, then check, in one process, each stage's own lines
       printed under [assemble], [rig] and [check]; the first stage that refuses
       stops the build with its own FAIL lines. The config must already carry
@@ -785,13 +786,13 @@ const TAKES = {
   rig: { valued: ['--config', '--parts', '--out', '--idle-keys', '--page-edges', '--pack-shape'], switches: [] },
   propose: { valued: ['--parts', '--source', '--out', '--from-config', '--compare', '--full', '--head', '--canvas', '--keypoints', '--person', '--wrist-snap', '--grid-rule', '--cloth'], switches: ['--head-box', '--no-back-hair'] },
   compare: { valued: ['--left', '--right', '--map'], switches: [] },
-  check: { valued: ['--rig', '--out', '--parts', '--source', '--page-edges', '--pack-shape', '--requirements'], switches: ['--seam-pairs', '--keep-stills'] },
+  check: { valued: ['--rig', '--out', '--parts', '--source', '--page-edges', '--pack-shape', '--requirements', '--set'], switches: ['--seam-pairs', '--keep-stills', '--all-sets'] },
   loop: { valued: ['--frames', '--out'], switches: ['--palette'] },
   assemble: { valued: ['--source', '--full', '--head', '--config', '--out', '--seam', '--project', '--alt'], switches: ['--propose-plan'] },
   'comfy seethrough': { valued: ['--image', '--out', '--resolution', '--steps', '--seed', '--prefix', '--host', '--wait', '--timeout', '--poll'], switches: ['--offload', '--lama', '--nf4'] },
   'comfy paint': { valued: ['--config', '--out', '--seeds', '--seed0', '--host', '--wait', '--timeout', '--poll'], switches: [] },
   inputs: { valued: ['--source', '--config', '--out'], switches: [] },
-  build: { valued: ['--config', '--source', '--full', '--head', '--out', '--seam', '--project', '--page-edges', '--pack-shape', '--requirements', '--idle-keys', '--lead-in', '--alt'], switches: ['--loop', '--seam-pairs', '--keep-stills'] },
+  build: { valued: ['--config', '--source', '--full', '--head', '--out', '--seam', '--project', '--page-edges', '--pack-shape', '--requirements', '--idle-keys', '--lead-in', '--alt', '--set'], switches: ['--loop', '--seam-pairs', '--keep-stills', '--all-sets'] },
   compose: { valued: ['--scene', '--out', '--requirements', '--accept'], switches: [] },
   'mesh-draft': { valued: ['--config', '--parts', '--out', '--requirements', '--idle-keys', '--page-edges', '--pack-shape'], switches: ['--more-triangles'] },
   painting: { valued: ['--keypoints', '--person'], switches: [] },
@@ -1037,17 +1038,20 @@ function flags(args: string[], command: Command, required: readonly string[]): M
 }
 
 function cmdCheck(args: string[]): number {
-  // The two switches check takes (issues #202, #209): they carry no value, so they are taken out before the valued flags are read.
+  // The switches check takes (issues #202, #209, #454): they carry no value, so they are taken out before the valued flags are read.
   const seamPairs = args.filter((a) => a === '--seam-pairs').length;
   if (seamPairs > 1) return usage('--seam-pairs is given twice');
   const keepStills = args.filter((a) => a === '--keep-stills').length;
   if (keepStills > 1) return usage('--keep-stills is given twice');
+  const allSets = args.filter((a) => a === '--all-sets').length;
+  if (allSets > 1) return usage('--all-sets is given twice');
   const f = flags(
-    args.filter((a) => a !== '--seam-pairs' && a !== '--keep-stills'),
+    args.filter((a) => a !== '--seam-pairs' && a !== '--keep-stills' && a !== '--all-sets'),
     'check',
     ['--rig', '--out'],
   );
   if (typeof f === 'string') return usage(f);
+  if (allSets === 1 && f.has('--set')) return usage('--set and --all-sets are two modes; give one');
   const rig = f.get('--rig') as string;
   const out = f.get('--out') as string;
   const edges = pageEdgesOf(f.get('--page-edges'));
@@ -1057,7 +1061,7 @@ function cmdCheck(args: string[]): number {
   try {
     const bin = findRigc(import.meta.dir, process.env.PATH ?? '');
     const r = checkStage(
-      { rig, parts: f.get('--parts'), source: f.get('--source'), out, pageEdges: edges, packShape: shape, requirements: f.get('--requirements'), seamPairs: seamPairs === 1, keepStills: keepStills === 1 },
+      { rig, parts: f.get('--parts'), source: f.get('--source'), out, pageEdges: edges, packShape: shape, requirements: f.get('--requirements'), seamPairs: seamPairs === 1, keepStills: keepStills === 1, ...(f.has('--set') ? { set: f.get('--set') as string } : {}), allSets: allSets === 1 },
       rigcRunner(bin),
       bin,
       console.log,
@@ -1503,6 +1507,7 @@ function cmdBuild(args: string[]): number {
   }
   // --head is optional (issue #359), as for assemble.
   for (const f of ['--config', '--source', '--full', '--out']) if (!flags.has(f)) return usage(`build needs ${f}`);
+  if (on.has('--all-sets') && flags.has('--set')) return usage('--set and --all-sets are two modes; give one');
   const seam = flags.get('--seam') ?? DEFAULT_SEAM_RULE;
   if (!(SEAM_RULES as readonly string[]).includes(seam)) return usage(`--seam ${seam}; one of ${SEAM_RULES.join(', ')} is required`);
   const project = flags.get('--project') ?? DEFAULT_PROJECT_RULE;
@@ -1528,7 +1533,7 @@ function cmdBuild(args: string[]): number {
   const scratch = mkdtempSync(join(tmpdir(), 'rig-parts-build-'));
   try {
     const r = build(
-      { config, source, full, head, out, seam: seam as SeamRule, project: project as ProjectRule, loop, pageEdges: edges, packShape: shape, ...(flags.has('--requirements') ? { requirements: flags.get('--requirements') as string } : {}), idleKeys: keys, ...(leadText === undefined ? {} : { leadIn: Number(leadText) }), seamPairs: on.has('--seam-pairs'), keepStills: on.has('--keep-stills'), ...(alts.length === 0 ? {} : { alts }) },
+      { config, source, full, head, out, seam: seam as SeamRule, project: project as ProjectRule, loop, pageEdges: edges, packShape: shape, ...(flags.has('--requirements') ? { requirements: flags.get('--requirements') as string } : {}), idleKeys: keys, ...(leadText === undefined ? {} : { leadIn: Number(leadText) }), seamPairs: on.has('--seam-pairs'), keepStills: on.has('--keep-stills'), ...(alts.length === 0 ? {} : { alts }), ...(flags.has('--set') ? { set: flags.get('--set') as string } : {}), allSets: on.has('--all-sets') },
       { rig: rigcRunner(bin), check: rigcRunner(bin), checkBin: bin, scratch: join(scratch, 'rig-gate') },
       console.log,
     );

package/docs/AUTHORING.md

@@ -108,6 +108,7 @@ read by no CPU stage).
 | `assemble.extend_below_crop` | assemble | **proposed** with the plan: `{part, run, tag}` — a head-run part that reaches the bottom of the head crop is continued from a full-run layer, whole connected components |
 | `assemble.patches` | assemble; `meshes`/`regions` keys may name them too | **authored**, optional: `[{name, box, alpha, draw}]` — an extra part cut from the **painting** itself, for figure no See-through layer holds (a hem both runs dropped). `box` is `[x0, y0, x1, y1]` in **rig** pixels, `x1`/`y1` exclusive — the space of `parts.json` and `recomposite_rig.png`, where the hole is found; `alpha` is `"silhouette"` (the painting's figure silhouette inside the box, the one `--seam silhouette` uses) or `"box"` (the whole box); `draw` is `"back"`, `"front"` or `{"before": "<plan part>"}`. A patch is always a region: its bone is `regions.<name>`, in the one place every region's bone lives, and a `meshes` entry for it is refused. See §5 for how to place one |
 | `assemble.cuts` | assemble; `meshes`/`regions` keys may name the new parts too, and must (each is a part like any other) | **authored**, optional (issue #170): `[{from, into, polygon, draw, overlap, under, under_fill}]`, `under` and `under_fill` optional — a plan part's layer cut by a polygon the author draws: the pixels of plan part `from` whose **centre** lies inside `polygon` (even-odd; a centre exactly on an edge is outside) leave `from` and make the new part `into`, colour and alpha, so every pixel of the layer ends in exactly one of the two. `polygon` is `[[x, y], …]`, at least three points, non-negative integer **rig** pixels — the space of `parts.json` and of the patches' boxes. The file that shows the layer in those coordinates is `assemble`'s own `rig/parts/<from>.png`, placed at its `parts.json` `x`, `y` (the PNG's pixel `(i, j)` is rig pixel `(x + i, y + j)`), or `render/recomposite_rig.png`, the whole rig 1:1; the contact sheets (`sheet`) are scaled and carry no coordinates. `draw` is `"back"`, `"front"` or `{"before": "<plan part>"}`, as for a patch (to keep the setup pose, draw the piece immediately in front of `from` — `{"before": "<the plan part after from>"}`, or `"front"` when `from` is the last plan part; `{"before": "<from>"}` draws it behind `from`, which `under` refuses as `ASSEMBLE_UNDER_DRAW` because the fill would hide it). `from` must be a plan part (`CONFIG_NAME_RESOLVES`; a patch or another cut's piece is refused), `into` a new name (`CONFIG_PART_UNIQUE`), the polygon three or more integer points (`CONFIG_FIELD_TYPE`). The piece's `parts.json` record carries `from`'s `<run>:<tag>` and its own counts, each split from the layer's by where the pixel lies; it is a mesh or a region under its own name, and the coverage rule holds it like a plan part. What the config cannot know the stage refuses: a polygon point past the rig (`ASSEMBLE_CUT_INSIDE`), two cuts of one part sharing a pixel (`ASSEMBLE_CUT_OVERLAP`), a cut that takes none of the layer's opaque pixels or leaves `from` none (`ASSEMBLE_CUT_PIXELS`). `overlap` is required, a non-negative integer of rig pixels with no default (`CONFIG_FIELD_TYPE`): the **band** — the polygon's pixels within `overlap` px of its edge by Chebyshev distance (the polygon's mask less its erosion by a `2 * overlap + 1` square) — stays in `from` as well as going to the piece, so the piece's resampled edge has art under it; the counts stay a strict partition and the band is the base's extra copy, printed on the `cut:` line. At `0` the two abut and `check`'s seam bar judges the edge between them (`CHECK_SEAM_WITHIN_BAR`, §5). A band only covers the edge at rest: a piece that swings well clear of where it was painted shows the hole it leaves, and a thin piece's band shows a ghost of the piece. `under` (issue #193), optional, is the author's image of what lies under the piece: a PNG path relative to the config's directory (`CONFIG_FIELD_TYPE` unless a non-empty string), in rig pixels over the polygon's **bounding box** — the least and greatest polygon x and y, so the image is `max x − min x` by `max y − min y` and its pixel `(i, j)` is rig pixel `(min x + i, min y + j)`. Where the cut removed pixels from `from` — the piece's pixels (alpha above 0) less the band — `from` takes the image's pixel, colour and alpha wherever the image's alpha is at least the alpha the cut removed there (**filled**); elsewhere `from` stays empty there (**left empty**): a transparent pixel is the author's statement that nothing lies under it (the background, or a part drawn behind), and a less opaque one is not half-filled. The image is read nowhere else, so its pixels over the band, over the box outside the polygon or where the layer had no art never change `from`. The `cut:` line then ends `; under <n> px filled, <m> px left empty` (`n + m` is every removed pixel), so an unintended hole is a number in the log, not a guess; the filled pixels count in `from`'s `opaque_px` and `occluded_px` (the piece is drawn over them), never as visible or projected. The stage refuses: a file that is not there (`ASSEMBLE_UNDER_PRESENT`) or not a PNG (`ASSEMBLE_UNDER_DECODES`), an image not exactly the box's size (`ASSEMBLE_UNDER_SIZE`, both sizes given), an image that fills none of the removed pixels — all transparent there, or another file (`ASSEMBLE_UNDER_EMPTY`; to leave the whole hole, drop `under`), and a piece drawn behind `from` (`ASSEMBLE_UNDER_DRAW`: the fill would hide it; draw it `"front"` or `{"before": "<the plan part after from>"}`). Producing the image is the author's, by whatever means; absent, `from` keeps only its band. `under_fill` (issue #360), optional, is the one value `"colour"` (`CONFIG_FIELD_TYPE` on any other): the same pixels are filled and left empty, and a filled pixel takes the image's **colour** at the alpha the cut removed there instead of the image's alpha, so `from`'s alpha is the uncut layer's wherever the image fills and its silhouette does not grow — an opaque image over a soft edge leaves the edge soft. It applies to the part's hidden-art layer as well as to a file; a cut with neither is refused (`ASSEMBLE_UNDER_FILL_SOURCE`). The `cut:` line's filled count then says how many took the colour only: `; under 190 px filled (190 colour only, at the alpha the cut removed), 0 px left empty`. Absent, a filled pixel takes the image's colour and alpha, as above |
+| `assemble.alternates` | assemble, rig, check (`--set`, `--all-sets`) | **authored**, optional (issues #454, #465): `[{name, source?, full?, head?, head_box?, parts?, hides?, cuts?, skeleton?, drawn?}]` — alternate painting sets assembled into `<out>/rig/parts/<set>_<part>.png` (`parts.json` `alternates`), attached on each covered slot in `rig.json` as `<set>_<part>` beside the base attachment, and indexed in `<out>/rig/sets.json` (`rig-parts-sets/1`: `sets.<set>.slots`, `.hides`, and `.drawn` when present). `source`, `full` and `head` may instead be given on the CLI with `--alt <name>=<source>:<full>[:<head>]`. `parts` lists the subset of parts the set replaces (default: every part not in `hides`); `hides` lists slots the set hides (`null` in `sets.json`). `skeleton` (a pose file path relative to the config's directory, `{"width": W, "height": H, "points": {…}}` with all 18 body-18 keypoints on the canvas, validated by the same rules as `generation.control.skeleton`: `CONFIG_FILE_PRESENT`, `CONFIG_IS_JSON`, `CONFIG_FIELD_TYPE`, `CONFIG_KEY_KNOWN`, `CONFIG_KEY_UNIQUE`, `CONFIG_POSE_CANVAS`, `CONFIG_POSE_KEYPOINTS`, `CONFIG_POSE_IN_CANVAS`) or `drawn` (`{<bone>: <worldDegrees>}`, each bone resolved against `bones`, `CONFIG_NAME_RESOLVES`) declares the posed angles the alternate was painted at (issue #465); when `skeleton` is given, `assemble` derives `drawn` from its 18 keypoints (with `drawn` overriding any bone named in both), records both `skeleton` (scaled by `assemble.rig_scale` to rig px) and `drawn` in `parts.json` `alternates`, and the `rig` stage writes `<set>_*` region and mesh attachments in the bone-local frame of `poseRigBonesForDrawn(bones, drawn)` (weighting limb segments directly from `skeleton`'s joint endpoints when `skeleton` is present) and emits `drawn` in `sets.json` so `rig-pose` and `check --set <name>` / `--all-sets` pose the bones at `drawn` without rotating the already-posed art a second time |
 | `limbs` | assemble (the cut and the caps), rig (through `regions`), check (`LIMB_ONE_BONE`) | **proposed** by `propose --keypoints` (issue #349), then checked: `{<limb>: {segments: [{part, from, bone}, {part, from, bone, joint, range?, cap?, edge?, cap_shape?, cut_band?}, …]}}`, the upper segment first. The rule is *Limbs: cut at their joints* below the table. `part` is a new part (`CONFIG_PART_NAME`, `CONFIG_PART_UNIQUE` against the plan, patches, cuts and every other limb part); `from` a plan part or a cut's piece (`CONFIG_NAME_RESOLVES`) — the layer the segment's pixels come from, which is cut into the limb parts and is not itself made: a `meshes` or `regions` entry for it is `CONFIG_NAME_RESOLVES`, and the segments of one limb that take one part are consecutive (`CONFIG_LIMB_FROM_RUN`); `bone` a declared bone, each segment's the child of the one before (`CONFIG_LIMB_BONES_CHAIN`); the upper segment names no `joint`, `range`, `cap`, `edge`, `cap_shape` or `cut_band` (`CONFIG_KEY_KNOWN`), every other names its `joint` (`CONFIG_FIELD_PRESENT`) — the joint is its bone's origin; `range` is `[min, max]` degrees from rest with `min <= 0 <= max` (`CONFIG_LIMB_RANGE`), which `assemble` writes into the lower part's `parts.json` record and `check` poses the joint at — its two ends and its middle — reading the seam there (`SEAM_OVER_RANGE`, issue #360; rig-c needs no rotation limit); `cap` a PNG path relative to the config's directory (`CONFIG_FIELD_TYPE`); `edge` `"feather"` and `cap_shape` `"disc"` (issue #360), each the one value its field takes (`CONFIG_FIELD_TYPE` on any other) — the cut's geometry at that joint, *Limbs: cut at their joints* below; absent, the cut is hard and the cap the layer's half-disc of half the limb's width; `cut_band` a whole number of px, 1 or more (`CONFIG_FIELD_TYPE`), on a segment that takes the segment above's part — between two layers nothing is cut, so a band there is `CONFIG_KEY_KNOWN` — places the cut within that many px of the joint line (issue #360, *Limbs: cut at their joints*); absent, the cut is the joint line. Each limb part is attached like any part — `regions.<part>`, which must be the segment's `bone` (`CONFIG_LIMB_BONE`), or a mesh, which `check` holds to that bone alone (`LIMB_ONE_BONE`). With `limbs`, `assemble` reads `bones` too (`CONFIG_FIELD_PRESENT` without it). Absent, nothing is cut at a joint and no byte of any output moves |
 | `bones` | rig; `propose --from-config` | **proposed** by `propose`, then corrected. A single bone `{name, parent, at, tip?}` or a chain `{chain, parent, points, tip, link_inherit?}` whose links are named `<chain>0 … <chain>n`. Parents come before children. In `rig.json` each link is **turned along its chain** — `rotation` is the direction from its origin to the next link's (the last link's to `tip`) and `length` that distance (issue #73), so a physics constraint added downstream finds a lever; under `--idle-keys ctl` the link's `<link>_ctl` carries the turn and the length and the link sits at local rotation 0 beneath it. A single bone with a `tip` is turned the same way, towards its tip, with that distance as its length (issue #239); a tip on the bone's own origin is refused (`RIG_TIP_DISTINCT`). The five face bones `eye_r`, `eye_l`, `brow_r`, `brow_l` and `mouth` (by name, when one has no tip of its own) are turned to the eye line — the line through the origins of `eye_r` and `eye_l` as `bones` writes them, read image-left to image-right, drawn when parts.json holds both an `eyewhite-r` and an `eyewhite-l` part — so the blink's `scaley` squashes across the eye line on a tilted head; move an eye bone and the line moves with it. With one eyewhite or none, or an eye bone missing, the rig stage's `face axis:` line says so and they keep the page's axes. A bone under a face bone keeps the face's axis. With the line, `rig.json` also declares `invariants.axes` — one entry, `"face"`, through `eye_r` and `eye_l`, holding the turned face bones (and their controls) — so rig-c's gate holds the build to the line; the line is the one rigc draws through the same two bones, so the tolerance is only the float floor — the largest gap the emitted (float32) bones have to it, rounded up to 6 places plus one 6-place unit — and the `face axis:` line prints it. With the line the rig stage also adds `head_up` (issue #250): a slotless bone under `head`, at head's origin, turned to the eye line + 90 degrees and as long as the eye midpoint lies from head's origin along that axis — the head's frame, which a rule that needs it reads; `head` keeps its own frame, so no key on it or under it changes meaning, and a config bone of that name is refused (`RIG_HEAD_UP_NAME_FREE`). A face bone with its own `tip` is held too (issue #258), in a second entry, `"face_tips"`, when its tip lies along the line within whole-pixel rounding — a tip written in whole pixels sits at most sqrt(2)/2 px off the point of the line it stands for, so its direction may sit up to asin((sqrt(2)/2) / length) degrees off — with its tolerance measured the same way; a tip further off is the bone's own axis, and the `face axis:` line names it with its gap and that bound. A failure is rig-c's `A51_BONES_LIE_ALONG_THEIR_DECLARED_AXIS` line, which names the bone and the fix (rig-c's `docs/AUTHORING.md` §3.7 and §5.2); with no line no entry is written and A51 reports SKIP. Every region on a turned bone is turned back, so the setup pose does not move. Any other single bone keeps world rotation 0; one whose parent is a link is turned back upright. A single bone may declare `inherit` (issue #348): what it takes from its parent's transform, one of rig-c's own mode names exactly as rig-c's table spells them — `normal`, `onlyTranslation`, `noRotationOrReflection`, `noScale`, `noScaleOrReflection` (rig-c's `RigBone.inherit`) — written to that bone in `rig.json` as declared; any other spelling, `"NoScale"` included (the runtime would fold its first letter; nothing here folds or maps), is refused (`CONFIG_BONE_INHERIT`), and a chain takes no `inherit` (`CONFIG_KEY_KNOWN`). A chain may instead declare `link_inherit` (issue #369), an object mapping its own expanded link names to those same modes, for example `"link_inherit": {"leg_r1": "noScale"}`. Only the named link changes; omitted links inherit normally. A key outside this chain is `CONFIG_NAME_RESOLVES`, with this chain's valid link names in the detail; a non-object or non-string mode is `CONFIG_FIELD_TYPE`, and another mode spelling is `CONFIG_BONE_INHERIT`. The mode is forwarded to the expanded link, or to its control under `--idle-keys ctl`, by the same rule as a single bone. This is an authored opt-in: `propose` does not add it. Its setup rotation is the turn from where rig-c's own poser puts the bone with no rotation of its own under that mode, so it still stands upright (or along its tip) at the setup pose. Where the idle gives the bone a `<bone>_ctl`, the mode goes on the control: the control is the bone the parent's rotation reaches, and the bone under it inherits normally, so the idle's keys moved onto the control still turn it. A foot that does not take its shin's rotation (`noRotationOrReflection` or `onlyTranslation`) keeps its shoe level while the leg is posed (`FEET_STAY_LEVEL`, §7); which mode is the author's. `noScale` keeps a shin or shoe's shape under a scaled parent but still takes the parent's rotation: a shoe that must also stay level needs a separate rotation constraint, for example a transform constraint from an unrotated bone. This does not change the proposed feet's existing inheritance or `FEET_STAY_LEVEL` default. An automatic mesh weighted through a bone with a mode other than `normal` gets no derived amplitude (its row names the bone) and no residual envelope (rig-c's `SKINNING_RANGE_UNSUPPORTED`). Absent, `rig.json` carries no `inherit` and no byte moves |
 | `meshes.<part>` | rig | **proposed**, then corrected. Exactly one of `grid` (the lattice: cell size, px — what `propose` writes: by default one spacing for the figure, round(H / 37) rig px with H the height of every part's box together, a part whose tenth of its short side is already coarser keeping that, and under `propose --grid-rule part` the reference's tenth of the part's short side clamped to 5..36, issue #265), `contour` (the outline mode, authored; the next row and "A contour mesh" below) or `auto` (the automatic mode, authored; "An automatic mesh" below) — two, or none, is `CONFIG_MESH_MODE`. In every mode: `r` (added to every distance before weighting: `w = 1/(d + r)²`), `segments` (a chain name, a bone name with a `tip`, or `[bone, [x0,y0], [x1,y1]]`), and, **authored**, optional, `exponent` (issue #161): a number above 0 that replaces the 2 in that rule, `w = 1/(d + r)^exponent` — a larger one hands each vertex more fully to its nearest bone; absent is 2 and changes no byte, a value that is not a number above 0 is `CONFIG_FIELD_TYPE` at `meshes.<part>.exponent`, and a declared one is echoed as `exponent` in the mesh's `mesh_report.json` row; the exponent is the distance rule's, so declared beside `rule: "heat"` it is refused (`CONFIG_FIELD_TYPE` at `meshes.<part>.exponent`). The segment list is the one authored decision about a layer: which bones may pull it. The slot's bone is the first segment's. Optional `rule` (issue #161): `"distance"` — the rule above, and what an absent `rule` means (every byte is the same) — or `"heat"`, bone heat over the part's own silhouette, in every mode: the lattice's art (alpha above 8, less any island a declared `stray` left out) with holes filled, or for `contour` and `auto` the silhouette their outline is traced from (that mode's art — alpha above 8 for `contour`, alpha 1 and above for `auto` — less any island a declared `stray` left out, holes filled, grown by its `margin`); each bound bone's sources are the silhouette pixels whose centre lies within 0.75 px of its segment (a pixel two bones reach goes to the nearer, a tie to the first listed), held at 1 for that bone and 0 for the others; the field is solved by row-major Gauss–Seidel over-relaxation to a sweep change under 1e-7 within 20000 sweeps; a vertex reads the nearest silhouette pixel and takes the same cap and floor (and `regions`) as the distance rule; `r` is not read. The mesh's `mesh_report.json` row gains `heat` (the constants, each bone's sources and sweeps, the residual). Any other value is `CONFIG_FIELD_TYPE`; a bound bone with no source pixel is `RIG_HEAT_BONE_SOURCE`, an island no bone has a source in `RIG_HEAT_ISLAND_SOURCE`, a solve past its sweep bound `RIG_HEAT_CONVERGED` — none is weighted 0. The rule is chosen per mesh, so `RIG_HEAT_BONE_SOURCE` names three remedies: move the segment onto the art, take the bone out of `segments`, or keep this part on the distance rule — the one to take when the bone anchors the part from outside its art (a torso bone under a neck), since the first moves a bone another part placed and the second drops the anchor (issue #303). On a lattice, `RIG_HEAT_ISLAND_SOURCE` on an island that is dust — at most 4 px and at most 0.1 % of the part's art px, `mesh-draft`'s line — names `meshes.<part>.stray` and the figure that leaves it out, with the value declared; an island above that line keeps the segment remedy, a real piece being a real authoring question |
@@ -2729,6 +2730,7 @@ says why each requirement exists and what breaks without it.
 | <a id="ASSEMBLE_HIDDEN_ONE_SOURCE"></a>`ASSEMBLE_HIDDEN_ONE_SOURCE` | a cut's `under`, or a limb segment's `cap`, names a file, and the part it reads also has a hidden-art layer (`<layer>:hidden`, issue #359): reading either would be a guess | remove the file from the config, or the hidden-art layer from the input |
 | <a id="ASSEMBLE_ALT_INPUT_PRESENT"></a>`ASSEMBLE_ALT_INPUT_PRESENT` | an alternate painting set (`assemble.alternates` or `--alt`, issue #454) is missing `source` or `full`, names a file or directory that is not on disk, or lacks a covered part's layer in its runs | give `source` and `full` on the alternate set, or list an occluded part in `hides` |
 | <a id="ASSEMBLE_ALT_CANVAS_SIZE"></a>`ASSEMBLE_ALT_CANVAS_SIZE` | an alternate painting's canvas size differs from the primary painting's (issue #454; the detail gives both sizes) | the alternate painting: the primary painting's canvas size, so its parts land in the same rig frame |
+| <a id="ASSEMBLE_ALT_SKELETON"></a>`ASSEMBLE_ALT_SKELETON` | an alternate set's `skeleton` file (`assemble.alternates[i].skeleton`, issue #465) is not JSON or does not hold `{"width": W, "height": H, "points": {…the 18 body-18 keypoints}}` | that set's `skeleton` file |
 | <a id="ASSEMBLE_COUNTS_ADD_UP"></a>`ASSEMBLE_COUNTS_ADD_UP` | a part's visible and occluded counts do not add up to its opaque pixels, or a projected pixel is not visible, or a cut part's pieces do not add up to it — an assembler bug, not an input problem | report it with the part named; nothing was written |
 
 ### propose
@@ -2829,7 +2831,7 @@ documents do not ship). Each is an input this package built; none is an author's
 | --- | --- | --- |
 | <a id="CHECK_RIGC_PRESENT"></a>`CHECK_RIGC_PRESENT` | no `rigc` binary found (every place looked is listed) | `bun install` |
 | <a id="CHECK_RIGC_PACKAGE"></a>`CHECK_RIGC_PACKAGE` | `node_modules/.bin/rigc` is missing under the package root named: this lookup (the selftest's, issue #337) takes this package's own rigc and no other — no directory above, no `PATH` | `bun install` in that root |
-| <a id="CHECK_INPUT_PRESENT"></a><a id="CHECK_INPUT_IS_JSON"></a><a id="CHECK_PART_PNG_PRESENT"></a><a id="CHECK_PART_PNG_MATCHES_BOX"></a><a id="CHECK_PART_SLOT_PRESENT"></a><a id="CHECK_RIG_STAGE_PRESENT"></a><a id="CHECK_RIG_STAGE_IS_THE_CANVAS"></a><a id="CHECK_RIG_ROOT_BONE"></a><a id="CHECK_IDLE_PRESENT"></a>`CHECK_INPUT_PRESENT`, `CHECK_INPUT_IS_JSON`, `CHECK_PART_PNG_PRESENT`, `CHECK_PART_PNG_MATCHES_BOX`, `CHECK_PART_SLOT_PRESENT`, `CHECK_RIG_STAGE_PRESENT`, `CHECK_RIG_STAGE_IS_THE_CANVAS`, `CHECK_RIG_ROOT_BONE`, `CHECK_IDLE_PRESENT` | the rig directory is incomplete or disagrees with `parts.json` (`CHECK_PART_SLOT_PRESENT`: a part with no slot of its own name, which the judgement lines render it by). `motion.json` is required even with no animation in it, because `rigc build` takes `--motion` (a spec with `"animations": {}` builds green); `CHECK_IDLE_PRESENT` is an `idle` that is there with no positive `duration` — an absent `idle` is measured around (§7). `CHECK_INPUT_PRESENT` on `…/parts.json`: `--parts` named a directory without `parts.json` — most often `parts/` itself — or, without `--parts`, the rig directory has none while the directory above it does (build's layout, `<out>/rig` under `<out>/parts.json`). The detail says it: "--parts names the directory holding parts.json and parts/, not parts/ itself (after build, that is build's --out, whose rig is <out>/rig); without --parts it is --rig", and names the parent when the parent holds `parts.json`. With neither (no `--parts`, and no `parts.json` beside `rig.json` or above it), the rig is measured without parts and nothing is refused (§7) | re-run rig (`build` does both); for `…/parts.json`, `--parts` — the directory above `parts/` |
+| <a id="CHECK_INPUT_PRESENT"></a><a id="CHECK_INPUT_IS_JSON"></a><a id="CHECK_PART_PNG_PRESENT"></a><a id="CHECK_PART_PNG_MATCHES_BOX"></a><a id="CHECK_PART_SLOT_PRESENT"></a><a id="CHECK_RIG_STAGE_PRESENT"></a><a id="CHECK_RIG_STAGE_IS_THE_CANVAS"></a><a id="CHECK_RIG_ROOT_BONE"></a><a id="CHECK_IDLE_PRESENT"></a>`CHECK_INPUT_PRESENT`, `CHECK_INPUT_IS_JSON`, `CHECK_PART_PNG_PRESENT`, `CHECK_PART_PNG_MATCHES_BOX`, `CHECK_PART_SLOT_PRESENT`, `CHECK_RIG_STAGE_PRESENT`, `CHECK_RIG_STAGE_IS_THE_CANVAS`, `CHECK_RIG_ROOT_BONE`, `CHECK_IDLE_PRESENT` | the rig directory is incomplete or disagrees with `parts.json` (`CHECK_PART_SLOT_PRESENT`: a part with no slot of its own name, which the judgement lines render it by; `CHECK_INPUT_PRESENT` on `--set` / `--all-sets`: no `parts.json`, no `alternates`, or the named set is not in `alternates`). `motion.json` is required even with no animation in it, because `rigc build` takes `--motion` (a spec with `"animations": {}` builds green); `CHECK_IDLE_PRESENT` is an `idle` that is there with no positive `duration` — an absent `idle` is measured around (§7). `CHECK_INPUT_PRESENT` on `…/parts.json`: `--parts` named a directory without `parts.json` — most often `parts/` itself — or, without `--parts`, the rig directory has none while the directory above it does (build's layout, `<out>/rig` under `<out>/parts.json`). The detail says it: "--parts names the directory holding parts.json and parts/, not parts/ itself (after build, that is build's --out, whose rig is <out>/rig); without --parts it is --rig", and names the parent when the parent holds `parts.json`. With neither (no `--parts`, and no `parts.json` beside `rig.json` or above it), the rig is measured without parts and nothing is refused (§7) | re-run rig (`build` does both); for `…/parts.json`, `--parts` — the directory above `parts/` |
 | <a id="CHECK_SOURCE_SIZE"></a>`CHECK_SOURCE_SIZE` | the painting `--source` names is not this rig's: no single `rig_scale` takes its width and height to the stage's (assemble makes the canvas `trunc(w × rig_scale)` x `trunc(h × rig_scale)`), or, with `parts.json` read, its `scale_rig_per_source` does not; or the stage is not whole pixels. Refused before anything is built | the painting the rig was made from — the stage's own size, or the painting `assemble` was given |
 | <a id="CHECK_SOURCE_PNG"></a>`CHECK_SOURCE_PNG` | `--source` names a file that does not read as a PNG | a PNG |
 | <a id="CHECK_SOURCE_GRID"></a>`CHECK_SOURCE_GRID` | the setup-pose still and its black-tinted twin (the coverage `SETUP_POSE_VS_SOURCE` reads) did not come back on one grid over one opaque background | a rigc problem; report it |
@@ -2838,7 +2840,7 @@ documents do not ship). Each is an input this package built; none is an author's
 | <a id="CHECK_RIGC_GREEN"></a>`CHECK_RIGC_GREEN` | a rigc step failed; its line is quoted | as `RIG_RIGC_GREEN` |
 | <a id="CHECK_LOOP_LAST_FRAME_AT_DURATION"></a>`CHECK_LOOP_LAST_FRAME_AT_DURATION` | the idle's last frame does not sit at `duration` | `motion.duration` — a whole number of 1/12 s |
 | <a id="CHECK_LOOP_CLOSES"></a>`CHECK_LOOP_CLOSES` | frame 0 and the frame at `duration` differ (max and first pixel quoted); with a physics constraint, the frames of the rig with every physics constraint left out, and the object says so (§7, *loop*) | a track whose last key is not its first |
-| <a id="CHECK_SEAM_WITHIN_BAR"></a>`CHECK_SEAM_WITHIN_BAR` | the setup pose does not reproduce the flat stack of parts | read the `seam pair` lines and `check/seam/` pictures (§7; magenta = a counted pixel, cyan = the box round them): the pair, its boxes and the pixels counted. Usually a region or mesh placed off its part; compare with `recomposite_rig.png`. A pair of one layer cut in two with `differing_copies_px` is the cut line: move the polygon's edge, not `overlap` |
+| <a id="CHECK_SEAM_WITHIN_BAR"></a>`CHECK_SEAM_WITHIN_BAR` | the setup pose (or, under `--set <name>` / `--all-sets`, an alternate set's setup pose posed at its `drawn` bone angles with its `<set>_*` attachments and `hides` applied, issue #465) does not reproduce the flat stack of parts (`recomposite_rig.png`, or `recomposite_rig_<set>.png`) | read the `seam pair` lines and `check/seam/` (`check/seam_<set>/`) pictures (§7; magenta = a counted pixel, cyan = the box round them): the pair, its boxes and the pixels counted. Usually a region or mesh placed off its part; compare with `recomposite_rig.png` (`recomposite_rig_<set>.png`). A pair of one layer cut in two with `differing_copies_px` is the cut line: move the polygon's edge, not `overlap` |
 | <a id="CHECK_BREATH_VISIBLE"></a>`CHECK_BREATH_VISIBLE` | the breath alone barely moves the torso (`topwear`, rendered alone, the idle with and without its breath tracks — issue #411; the whole idle's figure is printed beside it, and motion that is not the breath's is not counted), or the idle has no breath track at all — or the feet (`footwear`), rendered alone, move at all | the chest's breath tracks (`motion.tracks` on `chest`), or the torso mesh's `segments`; for the feet, the bone their region rides (`regions.<part>`, `root` in both examples) |
 | <a id="CHECK_BLINK_NO_HOLE"></a>`CHECK_BLINK_NO_HOLE` | with the blink held shut, the eyewhite box shows the page where the open eye had art | the layer under the eye: the `face` part has no art there. Take the face from the other run, or add a part under the eye; `motion.blink.squash` only hides the hole less |
 | <a id="CHECK_CHAIN_LAG"></a>`CHECK_CHAIN_LAG` | a rotate track leads (or does not lag) the keyed bone above it, or a chain link swings less than the link above — or, in a chain that carries a part the scene file declares `rests`, more than the link above (issue #245; the object names the part and the file) | that chain track's `phase`/`lag` (a positive `lag`, a child `phase` above its parent's) or its `amps` (non-decreasing toward the tip; non-increasing on a chain declared resting) |

package/docs/STABILITY.md

@@ -56,9 +56,9 @@ defaults are the help's too, and none is guessed from the art.
 | `propose` | `--parts`, `--source`, `--out`; optional `--compare` or `--from-config` (one of them), `--keypoints`, `--person` and `--wrist-snap` (each with `--keypoints`), `--full`, `--head` (the turn control's depths; not with `--from-config`), `--grid-rule` (`figure` or `part`, the drafted lattice's spacing; not with `--from-config`), `--cloth` (a config whose `cloth` block is the recipe, issue #364; not with `--from-config`) |
 | `compare` | `--left`, `--right`; optional `--map` |
 | `rig` | `--config`, `--parts`, `--out`; optional `--idle-keys` (ctl, direct), `--page-edges` (pot, free), `--pack-shape` (rect, polygon) |
-| `check` | `--rig`, `--out`; optional `--parts`, `--source`, `--page-edges`, `--pack-shape`, `--requirements`, `--seam-pairs`, `--keep-stills` |
+| `check` | `--rig`, `--out`; optional `--parts`, `--source`, `--page-edges`, `--pack-shape`, `--requirements`, `--seam-pairs`, `--keep-stills`, `--set` or `--all-sets` (issue #454) |
 | `loop` | `--frames`, `--out`; optional `--palette` |
-| `build` | `--config`, `--source`, `--full`, `--out`; optional `--head` (as for `assemble`), `--seam`, `--project`, `--page-edges`, `--pack-shape`, `--loop`, `--lead-in`, `--requirements`, `--idle-keys`, `--seam-pairs`, `--keep-stills`, `--alt` (as for `assemble`, issue #454) |
+| `build` | `--config`, `--source`, `--full`, `--out`; optional `--head` (as for `assemble`), `--seam`, `--project`, `--page-edges`, `--pack-shape`, `--loop`, `--lead-in`, `--requirements`, `--idle-keys`, `--seam-pairs`, `--keep-stills`, `--alt` (as for `assemble`, issue #454), `--set` or `--all-sets` (as for `check`, issue #454) |
 | `compose` | `--scene`, `--out`; optional `--requirements`, `--accept` |
 | `mesh-draft` | `--config`, `--parts`, `--out`; optional `--requirements`, `--idle-keys` (ctl, direct), `--page-edges` (pot, free), `--pack-shape` (rect, polygon), `--more-triangles` |
 | `painting` | one positional path, the painting; `--keypoints`; optional `--person` |
@@ -121,7 +121,7 @@ part name, `[i]` an entry of a list):
 - **seethrough** — required: `resolution`, `steps`, `seed`, `offload`; optional: `head_box`, `arm_split`
 - **seethrough.arm_split** — required: `order`, and one of `x` or `line` (issue #439)
 - **assemble** — required: `rig_scale`, `plan` (from plain `assemble` on); optional: `extend_below_crop`, `patches`, `cuts`, `alternates`
-- **assemble.alternates[i]** — required: `name`; optional: `source`, `full`, `head`, `parts`, `hides`, `head_box`, `cuts` (issue #454)
+- **assemble.alternates[i]** — required: `name`; optional: `source`, `full`, `head`, `parts`, `hides`, `head_box`, `cuts`, `skeleton`, `drawn` (issues #454, #465)
 - **assemble.extend_below_crop[i]** — required: `part`, `run`, `tag`
 - **assemble.patches[i]** — required: `name`, `box`, `alpha`, `draw`
 - **assemble.patches[i].draw**, when an object — required: `before`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rig-c/parts",
-  "version": "1.31.0",
+  "version": "1.32.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/build.ts

@@ -43,7 +43,7 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { type AnimFrame, EncodeError, encodeApng, encodeIndexedApng, INDEXED_DEFAULTS } from './apng.ts';
-import { assemble, type AssembleResult, cutLines, hiddenLines, SINGLE_RUN_FACE_TAGS, singleRunHeadBox, driftLine, limbLines, FIGURE_MASK_FILE, figuresLine, holeKindsLine, holeLines, type ProjectRule, scenePhrase, type SeamRule, stageFields, uncoveredLine } from './assemble.ts';
+import { assemble, type AssembleResult, cutLines, hiddenLines, SINGLE_RUN_FACE_TAGS, singleRunHeadBox, driftLine, limbLines, FIGURE_MASK_FILE, figuresLine, holeKindsLine, holeLines, measureRecomposite, type ProjectRule, recomposite, recompositeRecord, scenePhrase, type SeamRule, sourceInRig, stageFields, uncoveredLine } from './assemble.ts';
 import { allocationClause, type Reducer, stageBClause, unboundedClause } from './automesh.ts';
 import { residualClause } from './autoenvelope.ts';
 import { type AutoMotionCase, failingRows, idleSchedule, localRow, motionClause, motionDeformation, motionDocument, motionInput, motionRowText, motionStimulus, motionVerdict, noStimulusProblem, type ReplayCandidate, runComparison, sourceSelfFailure, stimulusMotion, withStimulus } from './automotion.ts';
@@ -83,6 +83,7 @@ import { encodePngBytes, readPng, writePng } from './raster/png.ts';
 import type { Raster } from './raster/types.ts';
 import { readRequirements, type RequirementLine, summaryText } from './requirements.ts';
 import { type AutoMeshReport, buildRig, DEFAULT_IDLE_KEYS, type FaceAxis, type IdleKeys, type MeshReport, type RigCommand, rigJsonText, type RigOutput, type RigSpec, SETS_FILE, type StrayCleared, type TurnRow } from './rig.ts';
+import { KEYPOINT_NAMES, type KeypointName, type PosePoints } from './skeleton.ts';
 import { AUTHOR_NO_ROLE, isAuthorTag } from './tags.ts';
 import { TURN_BONE } from './turn.ts';
 import { pyRound } from './round.ts';
@@ -273,6 +274,8 @@ export function assembleStage(input: AssembleStageInput, outs: AssembleOutputs,
     hides?: string[];
     head_box?: [number, number, number, number];
     cuts?: Cut[];
+    skeleton?: string;
+    drawn?: Record<string, number>;
   }> = cfgAlts.map((a, i) => {
     const cli = cliByName.get(a.name);
     if (cli !== undefined) cliByName.delete(a.name);
@@ -286,6 +289,8 @@ export function assembleStage(input: AssembleStageInput, outs: AssembleOutputs,
       hides: a.hides,
       head_box: a.head_box,
       cuts: a.cuts,
+      skeleton: a.skeleton === undefined ? undefined : resolve(configDir, a.skeleton),
+      drawn: a.drawn,
     };
   });
   for (const cli of cliByName.values()) {
@@ -334,6 +339,48 @@ export function assembleStage(input: AssembleStageInput, outs: AssembleOutputs,
       });
       continue;
     }
+    let altSkeleton: PosePoints | undefined;
+    if (alt.skeleton !== undefined) {
+      if (!existsSync(alt.skeleton) || !statSync(alt.skeleton).isFile()) {
+        altProblems.push({
+          code: 'ASSEMBLE_ALT_INPUT_PRESENT',
+          object: `${alt.skeleton} (alternate set "${alt.name}")`,
+          detail: 'no such file; the alternate pose skeleton is required when named',
+        });
+        continue;
+      }
+      try {
+        const rawSkel: unknown = JSON.parse(readFileSync(alt.skeleton, 'utf8'));
+        const skObj = typeof rawSkel === 'object' && rawSkel !== null && !Array.isArray(rawSkel) ? (rawSkel as Record<string, unknown>) : null;
+        const sw = skObj !== null && typeof skObj.width === 'number' && skObj.width > 0 ? skObj.width : null;
+        const sh = skObj !== null && typeof skObj.height === 'number' && skObj.height > 0 ? skObj.height : null;
+        const spts = skObj !== null && typeof skObj.points === 'object' && skObj.points !== null && !Array.isArray(skObj.points) ? (skObj.points as Record<string, unknown>) : null;
+        if (sw === null || sh === null || spts === null || KEYPOINT_NAMES.some((k) => !Array.isArray(spts[k]) || (spts[k] as unknown[]).length !== 2)) {
+          altProblems.push({
+            code: 'ASSEMBLE_ALT_SKELETON',
+            object: `${alt.skeleton} (alternate set "${alt.name}")`,
+            detail: 'must hold {"width": W, "height": H, "points": {…the 18 body-18 keypoints}}',
+          });
+          continue;
+        }
+        const [rW, rH] = result.parts.rig_size;
+        const sx = rW / sw;
+        const sy = rH / sh;
+        const scaled = {} as Record<KeypointName, readonly [number, number]>;
+        for (const k of KEYPOINT_NAMES) {
+          const [px, py] = spts[k] as [number, number];
+          scaled[k] = [pyRound(px * sx, 6), pyRound(py * sy, 6)];
+        }
+        altSkeleton = scaled;
+      } catch (err) {
+        altProblems.push({
+          code: 'ASSEMBLE_ALT_SKELETON',
+          object: `${alt.skeleton} (alternate set "${alt.name}")`,
+          detail: `does not parse as JSON: ${(err as Error).message}`,
+        });
+        continue;
+      }
+    }
     const altSrc = readSource(alt.source);
     if (altSrc.width !== src.width || altSrc.height !== src.height) {
       altProblems.push({
@@ -421,6 +468,17 @@ export function assembleStage(input: AssembleStageInput, outs: AssembleOutputs,
     const keptRecords = altRes.parts.parts.filter((p) => coveredSet.has(p.name));
     const slots: Record<string, string> = {};
     for (const r of keptRecords) slots[r.name] = `${alt.name}_${r.name}`;
+    let altRecomposite = altRes.parts.recomposite as RecompositeRecord;
+    if (alt.parts !== undefined) {
+      const [rW, rH] = result.parts.rig_size;
+      const altByName = new Map(altRes.images.map((x) => [x.record.name, x]));
+      const fullSetPlaced = result.images
+        .filter(({ record }) => !hidesSet.has(record.name))
+        .map((baseItem) => altByName.get(baseItem.record.name) ?? baseItem);
+      const altSrcRig = sourceInRig(altSrc, rW, rH);
+      const altCan = recomposite(fullSetPlaced, rW, rH);
+      altRecomposite = recompositeRecord(measureRecomposite(altCan, altSrcRig, fullSetPlaced));
+    }
     altBuilt.push({
       record: {
         name: alt.name,
@@ -429,9 +487,11 @@ export function assembleStage(input: AssembleStageInput, outs: AssembleOutputs,
         slots,
         records: keptRecords,
         ghost_px: altRes.parts.ghost_px,
-        recomposite: altRes.parts.recomposite as RecompositeRecord,
+        recomposite: altRecomposite,
         ...(altRes.parts.scene === undefined ? {} : { scene: altRes.parts.scene }),
         ...(altRes.parts.single_run_pad === undefined ? {} : { single_run_pad: altRes.parts.single_run_pad }),
+        ...(altSkeleton === undefined ? {} : { skeleton: altSkeleton }),
+        ...(alt.drawn === undefined ? {} : { drawn: { ...alt.drawn } }),
       },
       images: keptImages,
     });
@@ -1210,6 +1270,10 @@ export interface CheckStageInput {
   seamPairs?: boolean;
   /** `check --keep-stills` (issue #209): leave the setup-pose still and its `frames.json` under {@link STILL_DIR}. */
   keepStills?: boolean;
+  /** `check --set <name>` (issue #454): measure one declared alternate set's setup-pose seam and recomposite figures. */
+  set?: string;
+  /** `check --all-sets` (issue #454): measure every declared alternate set's setup-pose seam and recomposite figures. */
+  allSets?: boolean;
 }
 
 /**
@@ -1389,7 +1453,7 @@ export function checkStage(input: CheckStageInput, rigc: RigcRunner, bin: string
   const entryLine = versionLines.find((l) => l.startsWith('entry:'));
   log(`  ${rigcIdentity(bin, v)}${entryLine === undefined ? '' : `; ${entryLine}`}`);
   const mode: PackMode = { pageEdges: input.pageEdges ?? DEFAULT_PAGE_EDGES, packShape: input.packShape ?? DEFAULT_PACK_SHAPE };
-  const r = runCheck(input.rig, input.out, rigc, input.parts, mode, input.source, input.requirements, input.seamPairs === true, input.keepStills === true);
+  const r = runCheck(input.rig, input.out, rigc, input.parts, mode, input.source, input.requirements, input.seamPairs === true, input.keepStills === true, input.set, input.allSets === true);
   log(`  gate rig-play (rigc ${packedBuildLabel(mode)}), verbatim:`);
   for (const l of r.gateHtml) log(l);
   for (const l of packLines(r)) log(`  ${l}`);
@@ -1407,6 +1471,16 @@ export function checkStage(input: CheckStageInput, rigc: RigcRunner, bin: string
     );
     const pairs = fig.seam_pairs ?? [];
     pairs.forEach((row, i) => log(`  seam pair ${i + 1} of ${pairs.length}: ${seamPairText(row)}`));
+    if (fig.sets !== undefined) {
+      for (const [setName, setFig] of Object.entries(fig.sets)) {
+        log(
+          `  seam (${setName})${setFig.seam_border === undefined ? '' : ` (config.scene: ${setFig.seam_border.frame_px_left_out} frame px on the painting's border rows and columns left out, ${setFig.seam_border.px_over_40_left_out} of them over ${SEAM_PX_LEVEL})`}: setup pose at ${setFig.render_px}, scale ${setFig.seam_frame_scale.toFixed(4)}: mean |d| ${setFig.seam_mean} (<= ${SEAM_MEAN_BAR.toFixed(1)}), ` +
+            `${setFig.seam_px_over_40} px over ${SEAM_PX_LEVEL}, ${seamRigPxText(setFig.seam_px_over_40, setFig.seam_frame_scale)} rig px (the count / s²; <= ${SEAM_PX_BAR}), ${setFig.seam_px_over_80} px over ${SEAM_PX_LEVEL_HIGH} (reported)`,
+        );
+        const setPairs = setFig.seam_pairs ?? [];
+        setPairs.forEach((row, i) => log(`  seam pair (${setName}) ${i + 1} of ${setPairs.length}: ${seamPairText(row)}`));
+      }
+    }
   }
   for (const name of JUDGEMENT_LINES) log(`  ${judgementLine(name, fig[name])}`);
   const folds = fig[FOLD_LINE];
@@ -1420,6 +1494,11 @@ export function checkStage(input: CheckStageInput, rigc: RigcRunner, bin: string
   const sweep = fig[SWEEP_LINE];
   if (sweep !== undefined) for (const [i, l] of sweepCheckLines(sweep).entries()) log(`  ${i === 0 ? '' : '  '}${l}`);
   for (const name of REPORTED_LINES) log(`  ${judgementLine(name, fig[name])}`);
+  if (fig.sets !== undefined) {
+    for (const [setName, setFig] of Object.entries(fig.sets)) {
+      log(`  ${judgementLine(`RECOMPOSITE_HOLES (${setName})`, setFig.RECOMPOSITE_HOLES)}`);
+    }
+  }
   const vsSource = fig[SOURCE_LINE];
   if (vsSource !== undefined) log(`  ${judgementLine(SOURCE_LINE, vsSource)}`);
   if (r.requirements !== null) {
@@ -1707,6 +1786,10 @@ export interface BuildInput {
   keepStills?: boolean;
   /** `--alt`, forwarded to the assemble stage as `assemble` takes it (issue #454). */
   alts?: readonly AlternateCliInput[];
+  /** `--set <name>`, forwarded to the check as `check` takes it (issue #454). */
+  set?: string;
+  /** `--all-sets`, forwarded to the check as `check` takes it (issue #454). */
+  allSets?: boolean;
 }
 
 /** What `build` does with one flag `check` takes: hands it to its check stage, takes it as its own, or refuses it because build supplies the value itself. */
@@ -1729,6 +1812,8 @@ export const CHECK_FLAGS_IN_BUILD: Readonly<Record<string, CheckFlagInBuild>> =
   '--page-edges': { as: 'forwarded' },
   '--pack-shape': { as: 'forwarded' },
   '--requirements': { as: 'forwarded' },
+  '--set': { as: 'forwarded' },
+  '--all-sets': { as: 'forwarded' },
   '--seam-pairs': { as: 'forwarded' },
   '--keep-stills': { as: 'forwarded' },
 };
@@ -1841,7 +1926,7 @@ export function build(input: BuildInput, run: BuildRunners, log: Log): BuildResu
 
   let report: CheckReport;
   try {
-    report = checkStage({ rig: join(out, 'rig'), parts: out, out: join(out, 'check'), pageEdges: input.pageEdges, packShape: input.packShape, ...(input.requirements === undefined ? {} : { requirements: input.requirements }), seamPairs: input.seamPairs === true, keepStills: input.keepStills === true }, run.check, run.checkBin, prefixed('check'));
+    report = checkStage({ rig: join(out, 'rig'), parts: out, out: join(out, 'check'), pageEdges: input.pageEdges, packShape: input.packShape, ...(input.requirements === undefined ? {} : { requirements: input.requirements }), seamPairs: input.seamPairs === true, keepStills: input.keepStills === true, ...(input.set === undefined ? {} : { set: input.set }), allSets: input.allSets === true }, run.check, run.checkBin, prefixed('check'));
   } catch (err) {
     return refused('check', err);
   }

package/src/check.ts

@@ -125,7 +125,8 @@ import {
   type Toward,
   type WorldBox,
 } from './instruments.ts';
-import { type PartRecord, type PartsFile, readParts } from './parts.ts';
+import { type AlternatePartsRecord, type PartRecord, type PartsFile, readParts } from './parts.ts';
+import { poseRigBonesForDrawn, type RigBone, SETS_FILE } from './rig.ts';
 import { turnTwin } from './turn.ts';
 import {
   aimLine,
@@ -622,7 +623,7 @@ function readJson(path: string, problems: Problem[]): Record<string, unknown> |
  * duration. `sourcePath` is `--source`, read and held to the stage here, so a
  * painting that is not this rig's is refused before anything is built.
  */
-export function readCheckInputs(rigDir: string, partsHome?: string, sourcePath?: string): CheckInputs {
+export function readCheckInputs(rigDir: string, partsHome?: string, sourcePath?: string, set?: string, allSets = false): CheckInputs {
   const dir = resolve(rigDir);
   const named = partsHome !== undefined;
   const home = resolve(partsHome ?? rigDir);
@@ -674,6 +675,43 @@ export function readCheckInputs(rigDir: string, partsHome?: string, sourcePath?:
         problems.push({ code: 'CHECK_PART_PNG_MATCHES_BOX', object: `part "${p.name}"`, detail: `${png} is ${im.width}x${im.height}; parts.json's box is ${p.w}x${p.h}` });
       }
     }
+    for (const alt of parts.alternates ?? []) {
+      for (const r of alt.records) {
+        const png = join(partsDir, `${alt.name}_${r.name}.png`);
+        if (!existsSync(png)) {
+          problems.push({ code: 'CHECK_PART_PNG_PRESENT', object: `set "${alt.name}" part "${r.name}"`, detail: `${png} does not exist; parts.json lists it` });
+          continue;
+        }
+        const im = readPng(png);
+        if (im.width !== r.w || im.height !== r.h) {
+          problems.push({ code: 'CHECK_PART_PNG_MATCHES_BOX', object: `set "${alt.name}" part "${r.name}"`, detail: `${png} is ${im.width}x${im.height}; parts.json's box is ${r.w}x${r.h}` });
+        }
+      }
+    }
+  }
+  if (set !== undefined || allSets) {
+    if (parts === null) {
+      problems.push({
+        code: 'CHECK_INPUT_PRESENT',
+        object: set !== undefined ? `--set ${set}` : '--all-sets',
+        detail: `${partsPath} was not read; alternate sets are read from parts.json's "alternates"`,
+      });
+    } else {
+      const alts = parts.alternates ?? [];
+      if (set !== undefined && !alts.some((a) => a.name === set)) {
+        problems.push({
+          code: 'CHECK_INPUT_PRESENT',
+          object: `--set ${set}`,
+          detail: `${partsPath} has no alternate set "${set}" in "alternates" (${alts.length === 0 ? 'none declared' : alts.map((a) => `"${a.name}"`).join(', ')})`,
+        });
+      } else if (allSets && alts.length === 0) {
+        problems.push({
+          code: 'CHECK_INPUT_PRESENT',
+          object: '--all-sets',
+          detail: `${partsPath} declares no alternate sets in "alternates"`,
+        });
+      }
+    }
   }
   let stage: StageBox | null = null;
   let rootBone: string | null = null;
@@ -1195,6 +1233,72 @@ export function flatComposite(parts: PartsFile, partsDir: string, background: re
   return canvas;
 }
 
+/**
+ * The flat stack of parts for an alternate set (issue #454), in `parts.parts`
+ * slot order: hidden slots skipped, covered slots drawn from `alt.records` at
+ * their box, uncovered base slots drawn at their base box.
+ */
+export function flatCompositeForSet(parts: PartsFile, alt: AlternatePartsRecord, partsDir: string, background: readonly [number, number, number, number]): Raster {
+  const [W, H] = parts.rig_size;
+  let canvas = newRaster(W, H);
+  for (let i = 0; i < W * H; i++) canvas.data.set(background, i * 4);
+  const hides = new Set(alt.hides ?? []);
+  const byName = new Map(alt.records.map((r) => [r.name, r]));
+  for (const p of parts.parts) {
+    if (hides.has(p.name)) continue;
+    const rec = byName.get(p.name);
+    const pngName = rec === undefined ? p.name : `${alt.name}_${rec.name}`;
+    const box = rec ?? p;
+    canvas = alphaComposite(canvas, readPng(join(partsDir, `${pngName}.png`)), box.x, box.y);
+  }
+  return canvas;
+}
+
+/**
+ * The setup-pose rig spec with an alternate set applied (issues #454, #465):
+ * hidden slots (and `<slot>_still` for any hidden or covered slot) have no
+ * setup attachment, covered slots have `alt.slots[slot]`, and when the set
+ * carries `drawn` bone rotations its bones are posed at those world rotations
+ * so the throwaway still renders the alternate in the pose it was painted in.
+ */
+export function stillRigForSet(
+  rig: Record<string, unknown>,
+  alt: AlternatePartsRecord,
+  drawn: Readonly<Record<string, number>> | undefined = alt.drawn,
+): Record<string, unknown> {
+  const hides = new Set(alt.hides ?? []);
+  const slots = (Array.isArray(rig.slots) ? rig.slots : []).map((s) => {
+    if (!isRecord(s) || typeof s.name !== 'string') return s;
+    const stillBase = s.name.endsWith('_still') ? s.name.slice(0, -'_still'.length) : null;
+    if (hides.has(s.name) || (stillBase !== null && (hides.has(stillBase) || Object.hasOwn(alt.slots, stillBase)))) {
+      return { ...s, attachment: null };
+    }
+    if (Object.hasOwn(alt.slots, s.name)) return { ...s, attachment: alt.slots[s.name] };
+    return s;
+  });
+  if (drawn === undefined || Object.keys(drawn).length === 0) return { ...rig, slots };
+  const rawBones = (Array.isArray(rig.bones) ? rig.bones : []).filter(isRecord).map((b) => ({
+    name: String(b.name),
+    ...(typeof b.parent === 'string' && b.parent !== '' ? { parent: b.parent } : {}),
+    ...(typeof b.length === 'number' ? { length: b.length } : {}),
+    ...(typeof b.rotation === 'number' ? { rotation: b.rotation } : {}),
+    x: typeof b.x === 'number' ? b.x : 0,
+    y: typeof b.y === 'number' ? b.y : 0,
+    ...(typeof b.inherit === 'string' ? { inherit: b.inherit as RigBone['inherit'] } : {}),
+  }));
+  const stops = (Array.isArray(rig.stops) ? rig.stops : []).filter(isRecord).map((s) => ({
+    links: Array.isArray(s.links) ? s.links.filter((l): l is string => typeof l === 'string') : [],
+  }));
+  const bones = poseRigBonesForDrawn(rawBones, drawn, stops);
+  const out: Record<string, unknown> = { ...rig, bones, slots };
+  if (isRecord(out.invariants)) {
+    const { axes: _axes, ...rest } = out.invariants;
+    if (Object.keys(rest).length > 0) out.invariants = rest;
+    else delete out.invariants;
+  }
+  return out;
+}
+
 /**
  * The map from rig (crop) pixel indices to frame pixel indices that the seam
  * and the source line warp by: frame = (sx u + tx, sy v + ty).
@@ -1770,11 +1874,26 @@ export interface CheckFigures {
    * the keys it always wrote.
    */
   skipped?: { loop?: string; seam?: string };
+  /** Written only under `--set` or `--all-sets` (issue #454): each checked alternate set's setup-pose seam and recomposite figures, keyed by set name. */
+  sets?: Record<string, SetCheckFigures>;
   /** Written only under `--requirements` (issue #93): the file's fps, the summary, and one line per declared requirement, by name. */
   requirements?: RequirementsBlock;
   PASS: boolean;
 }
 
+/** One alternate set's setup-pose check record under `--set` or `--all-sets` (issue #454). */
+export interface SetCheckFigures {
+  render_px: string;
+  seam_mean: number;
+  seam_px_over_40: number;
+  seam_px_over_80: number;
+  seam_frame_scale: number;
+  seam_border?: { frame_px_left_out: number; px_over_40_left_out: number };
+  seam_pairs?: SeamPairRow[];
+  RECOMPOSITE_HOLES: ReportedLine;
+  PASS: boolean;
+}
+
 /** `check.json`'s `requirements` block: the fps every named animation was sampled at, the summary, and each line by its name, in the file's order. */
 export interface RequirementsBlock {
   fps: number;
@@ -1959,7 +2078,10 @@ export function barsNotMet(fig: Readonly<Record<string, unknown>>): string[] {
   if (typeof fig.loop_max_diff === 'number' && fig.loop_max_diff !== LOOP_MAX_BAR) out.push('loop');
   // A check.json written before issue #216 has no seam_frame_scale; it is read by the frame count, the bar it was written under.
   const scale = typeof fig.seam_frame_scale === 'number' ? fig.seam_frame_scale : 1;
-  if (typeof fig.seam_mean === 'number' && typeof fig.seam_px_over_40 === 'number' && seamFails(fig.seam_mean, fig.seam_px_over_40, scale)) out.push('seam');
+  const setFailed =
+    isRecord(fig.sets) &&
+    Object.values(fig.sets).some((s) => isRecord(s) && typeof s.seam_mean === 'number' && typeof s.seam_px_over_40 === 'number' && seamFails(s.seam_mean, s.seam_px_over_40, typeof s.seam_frame_scale === 'number' ? s.seam_frame_scale : 1));
+  if ((typeof fig.seam_mean === 'number' && typeof fig.seam_px_over_40 === 'number' && seamFails(fig.seam_mean, fig.seam_px_over_40, scale)) || setFailed) out.push('seam');
   for (const n of [...JUDGEMENT_LINES, FOLD_LINE, LEVEL_LINE, STRESS_LINE, LIMB_LINE, SWEEP_LINE]) {
     const l = fig[n];
     if (typeof l === 'object' && l !== null && (l as { status?: unknown }).status === 'FAIL') out.push(n);
@@ -3072,11 +3194,11 @@ export function rigcFailed(what: string, call: RigcCall, lines: readonly string[
  * MEASURABLE is a problem. Without it nothing here reads, writes or prints
  * anything it did not before.
  */
-export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, partsHome?: string, mode: PackMode = DEFAULT_PACK_MODE, source?: string, requirements?: string, seamPairsAsked = false, keepStills = false): CheckReport {
+export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, partsHome?: string, mode: PackMode = DEFAULT_PACK_MODE, source?: string, requirements?: string, seamPairsAsked = false, keepStills = false, set?: string, allSets = false): CheckReport {
   let inp: CheckInputs;
   let reqFile: RequirementsFile | null = null;
   let seams: Map<string, SeamPair[]> | null = null;
-  if (requirements === undefined) inp = readCheckInputs(rigDir, partsHome, source);
+  if (requirements === undefined) inp = readCheckInputs(rigDir, partsHome, source, set, allSets);
   else {
     // Both readers collect every problem; one refusal names both sets.
     const refused: Problem[] = [];
@@ -3089,7 +3211,7 @@ export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, parts
         return null;
       }
     };
-    const got = take(() => readCheckInputs(rigDir, partsHome, source));
+    const got = take(() => readCheckInputs(rigDir, partsHome, source, set, allSets));
     reqFile = take(() => readRequirements(requirements));
     refuseIfAny(refused);
     inp = got as CheckInputs;
@@ -3436,6 +3558,7 @@ export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, parts
   let seamViewport: Viewport | null = null;
   let blink: JudgementLine = skip(lacking);
   let sourceRead: ReportedLine | null = null;
+  const setsFigures: Record<string, SetCheckFigures> = {};
   if (inp.parts !== null || inp.source !== null) {
     try {
       mkdirSync(stillDir, { recursive: true });
@@ -3475,6 +3598,71 @@ export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, parts
           for (const { row, pixels } of split) writePng(join(out, row.picture), seamPicture(stillSet.frames[0].image, row, pixels));
           seamPairs = split.map((x) => x.row);
         }
+        if (set !== undefined || allSets) {
+          const alts = allSets ? (inp.parts.alternates ?? []) : (inp.parts.alternates ?? []).filter((a) => a.name === set);
+          const setStillAnimations: Record<string, unknown> = { still: animations.still };
+          const setStillBase = { ...withoutSliders(inp.rig, setStillAnimations), images };
+          const setsJsonPath = join(inp.rigDir, SETS_FILE);
+          const setsJsonRaw = existsSync(setsJsonPath) ? readJson(setsJsonPath, []) : null;
+          const setsMap = setsJsonRaw !== null && isRecord(setsJsonRaw.sets) ? setsJsonRaw.sets : null;
+          for (const alt of alts) {
+            const setEntry: Record<string, unknown> | null =
+              setsMap !== null && isRecord(setsMap[alt.name]) ? (setsMap[alt.name] as Record<string, unknown>) : null;
+            const setDrawn: Record<string, number> | undefined =
+              setEntry !== null && isRecord(setEntry.drawn)
+                ? Object.fromEntries(
+                    Object.entries(setEntry.drawn).filter((entry): entry is [string, number] => typeof entry[1] === 'number' && Number.isFinite(entry[1])),
+                  )
+                : alt.drawn;
+            const setDir = join(stillDir, `set_${alt.name}`);
+            mkdirSync(setDir, { recursive: true });
+            writeFileSync(join(setDir, 'rig.json'), JSON.stringify(stillRigForSet(setStillBase, alt, setDrawn)));
+            writeFileSync(join(setDir, 'motion.json'), JSON.stringify({ ...inp.motion, animations: setStillAnimations }));
+            const asb = rigc(['build', '--rig', join(setDir, 'rig.json'), '--motion', join(setDir, 'motion.json'), '--out', join(setDir, 'build'), '--profile', 'spine']);
+            if (asb.status !== 0) refuseIfAny(rigcFailed(`build (the setup-pose still of set "${alt.name}")`, asb, buildGateLines(asb.out)));
+            const asr = rigc(['render', '--candidate', join(setDir, 'build'), '--animation', 'still', '--fps', String(STILL_FPS), '--max', String(maxSide), '--out', join(setDir, 'render')]);
+            if (asr.status !== 0) refuseIfAny(rigcFailed(`render (the setup-pose still of set "${alt.name}")`, asr, asr.out.split('\n').filter((l) => l.includes('FAIL'))));
+            const altStillSet = readFrameSet(join(setDir, 'render'));
+            if (keepStills) cpSync(join(setDir, 'render'), join(keptDir, alt.name), { recursive: true });
+            const altComposite = flatCompositeForSet(inp.parts, alt, inp.partsDir, altStillSet.background);
+            const altSeam = seamFigures(altComposite, altStillSet.frames[0].image, inp.stage, altStillSet.viewport, altStillSet.background, undefined, alt.scene !== undefined);
+            const altMean = round3(altSeam.mean);
+            const altScale = round6(altStillSet.viewport.scale);
+            const altFailed = seamFails(altMean, altSeam.over40, altScale);
+            let altPairs: SeamPairRow[] | null = null;
+            if (seamPairsAsked || altFailed) {
+              const hides = new Set(alt.hides ?? []);
+              const byName = new Map(alt.records.map((r) => [r.name, r]));
+              const placed = inp.parts.parts
+                .filter((p) => !hides.has(p.name))
+                .map((p) => {
+                  const rec = byName.get(p.name);
+                  const pngName = rec === undefined ? p.name : `${alt.name}_${rec.name}`;
+                  const box = rec ?? p;
+                  return { name: p.name, from: box.from, x: box.x, y: box.y, image: readPng(join(inp.partsDir, `${pngName}.png`)) };
+                });
+              const split = seamPairRows(altSeam, placed, inp.parts.rig_size, altStillSet.viewport);
+              const altSeamDir = join(seamDir, alt.name);
+              mkdirSync(altSeamDir, { recursive: true });
+              for (const { row, pixels } of split) {
+                row.picture = `${SEAM_DIR}/${alt.name}/${basename(row.picture)}`;
+                writePng(join(out, row.picture), seamPicture(altStillSet.frames[0].image, row, pixels));
+              }
+              altPairs = split.map((x) => x.row);
+            }
+            setsFigures[alt.name] = {
+              render_px: `${altStillSet.viewport.pixelWidth}x${altStillSet.viewport.pixelHeight}`,
+              seam_mean: altMean,
+              seam_px_over_40: altSeam.over40,
+              seam_px_over_80: altSeam.over80,
+              seam_frame_scale: altScale,
+              ...(altSeam.border === null ? {} : { seam_border: { frame_px_left_out: altSeam.border.framePx, px_over_40_left_out: altSeam.border.over40 } }),
+              ...(altPairs === null ? {} : { seam_pairs: altPairs }),
+              RECOMPOSITE_HOLES: altHolesLine(inp.parts, alt),
+              PASS: !altFailed,
+            };
+          }
+        }
       }
       if (inp.source !== null) {
         // The same pose with every slot tinted black, built with the same animations so rigc fits the same grid.
@@ -3545,6 +3733,7 @@ export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, parts
     RECOMPOSITE_HOLES: inp.parts === null ? { status: 'SKIP', reason: inp.noParts ?? '' } : holesLine(inp.parts),
     ...(sourceRead === null ? {} : { [SOURCE_LINE]: sourceRead }),
     ...(Object.keys(skipped).length === 0 ? {} : { skipped }),
+    ...(Object.keys(setsFigures).length === 0 ? {} : { sets: setsFigures }),
     ...(reqBlock === null ? {} : { requirements: reqBlock }),
     PASS: false,
   };
@@ -3570,6 +3759,20 @@ export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, parts
           : `; worst of ${(seamPairs as SeamPairRow[]).length} pair(s): ${seamPairText(worst)} — every pair is a \`seam pair\` line above and a row of check.json's seam_pairs`),
     });
   }
+  for (const [setName, setFig] of Object.entries(setsFigures)) {
+    if (!setFig.PASS) {
+      const worst = setFig.seam_pairs === undefined || setFig.seam_pairs.length === 0 ? null : setFig.seam_pairs[0];
+      barProblems.push({
+        code: 'CHECK_SEAM_WITHIN_BAR',
+        object: `the setup-pose render of set "${setName}" vs the flat composite of parts/`,
+        detail:
+          `mean |d| ${setFig.seam_mean}/255 and ${setFig.seam_px_over_40} frame px over ${SEAM_PX_LEVEL} (${setFig.seam_px_over_80} over ${SEAM_PX_LEVEL_HIGH}) at frame scale ${setFig.seam_frame_scale}, ${seamRigPxText(setFig.seam_px_over_40, setFig.seam_frame_scale)} rig px (the count / s²); mean <= ${SEAM_MEAN_BAR.toFixed(1)} and <= ${SEAM_PX_BAR} rig px over ${SEAM_PX_LEVEL} are required` +
+          (worst === null
+            ? `; no pixel is over ${SEAM_PX_LEVEL}, so the mean alone fails and there is no pair to name`
+            : `; worst of ${(setFig.seam_pairs as SeamPairRow[]).length} pair(s): ${seamPairText(worst)}`),
+      });
+    }
+  }
   const rank = (q: Problem): number => JUDGEMENT_LINES.findIndex((n) => q.code === `CHECK_${n}`);
   problems.sort((a, b) => rank(a) - rank(b));
   problems.unshift(...barProblems);
@@ -3775,6 +3978,20 @@ export function holesLine(parts: PartsFile): ReportedLine {
   };
 }
 
+/** `RECOMPOSITE_HOLES` for an alternate set (issue #454), carrying its assemble `mean_abs` and hole figures. */
+export function altHolesLine(parts: PartsFile, alt: AlternatePartsRecord): ReportedLine {
+  const r = alt.recomposite;
+  return {
+    status: 'REPORTED',
+    ...(alt.scene === undefined ? {} : { declared_scene: scenePhrase(alt.scene, parts.rig_size[0] * parts.rig_size[1]) }),
+    mean_abs: r.mean_abs,
+    error_px: r.error_px,
+    uncovered_error_px: r.uncovered_error_px,
+    hole_count: r.hole_count,
+    largest: r.holes.length === 0 ? null : { px: r.holes[0].px, box: boxText(r.holes[0]), borders: r.holes[0].borders.map((b) => `${b.part} ${b.px} px`) },
+  };
+}
+
 function boxText(h: { x: number; y: number; w: number; h: number }): string {
   return `${h.x},${h.y} ${h.w}x${h.h}`;
 }

package/src/config.ts

@@ -254,6 +254,8 @@ export interface AlternateSetConfig {
   hides?: string[];
   head_box?: [number, number, number, number];
   cuts?: Cut[];
+  skeleton?: string;
+  drawn?: Record<string, number>;
 }
 
 export interface Assemble {
@@ -773,6 +775,8 @@ export interface CharacterConfig {
   cloth?: ClothRecipes;
   /** The `assemble.rig_scale` (`parts.json`'s `scale_rig_per_source`) `propose` drafted the rig sections at (issue #354): absent on a hand-authored config, held equal to `assemble.rig_scale` when present. */
   proposed_rig_scale?: number;
+  /** Alternate painting sets (issue #454): absent, no alternate sets are assembled or emitted. */
+  alternates?: AlternateSetConfig[];
 }
 
 /** `config.scene` (issue #242): the declaration that the painting is a scene. It holds no field today. */
@@ -1141,7 +1145,7 @@ function parseEarlyConfigFrom(raw: Json, door: EarlyDoor, base: string | null):
       limbs = checkLimbs(c, t.limbs, made, names);
     }
     if (isPlainObject(t.assemble) && 'alternates' in t.assemble) {
-      checkAlternates(c, t.assemble.alternates, made, limbs);
+      checkAlternates(c, t.assemble.alternates, made, limbs, null);
     }
   }
   if ('cloth' in t) checkCloth(c, t.cloth);
@@ -1293,7 +1297,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);
+    checkAlternates(c, t.assemble.alternates, { parts, patches, cuts }, limbs, names.bones);
   }
   if ('meshes' in t) checkMeshes(c, t.meshes, names.bones, names.chains);
   if ('regions' in t) checkRegions(c, t.regions, names.bones);
@@ -1820,6 +1824,7 @@ function checkAlternates(
   v: Json,
   made: { parts: string[]; patches: string[]; cuts: string[] },
   limbs: LimbNames | null,
+  bones: Set<string> | null = null,
 ): void {
   const p = 'config.assemble.alternates';
   if (!c.array(p, v, true)) return;
@@ -1827,16 +1832,29 @@ function checkAlternates(
   const seenNames = new Map<string, number>();
   (v as Json[]).forEach((entry, i) => {
     const at = `${p}[${i}]`;
-    const e = c.object(at, entry, ['name'], ['source', 'full', 'head', 'parts', 'hides', 'head_box', 'cuts']);
+    const e = c.object(at, entry, ['name'], ['source', 'full', 'head', 'parts', 'hides', 'head_box', 'cuts', 'skeleton', 'drawn']);
     if (e === null) return;
     if ('name' in e && c.string(`${at}.name`, e.name)) {
       if (!partNameOk(e.name)) c.fail('CONFIG_PART_NAME', `${at}.name`, `names the set ${show(e.name)}; a set name is a file prefix, so it may not be empty, start with "." or hold a slash`);
       if (seenNames.has(e.name)) c.fail('CONFIG_PART_UNIQUE', `${at}.name`, `names the set "${e.name}" again (first at alternates[${seenNames.get(e.name)}])`);
       else seenNames.set(e.name, i);
     }
-    for (const k of ['source', 'full', 'head'] as const) {
+    for (const k of ['source', 'full', 'head', 'skeleton'] as const) {
       if (k in e) c.string(`${at}.${k}`, e[k]);
     }
+    if ('drawn' in e) {
+      const d = e.drawn;
+      if (!isPlainObject(d) || Object.keys(d).length === 0) {
+        c.fail('CONFIG_FIELD_TYPE', `${at}.drawn`, `is ${show(d)}; a non-empty object of bone name -> drawn world angle in Spine degrees is required`);
+      } else {
+        for (const [bName, deg] of Object.entries(d)) {
+          if (bones !== null && !bones.has(bName)) {
+            c.fail('CONFIG_NAME_RESOLVES', `${at}.drawn.${bName}`, `names "${bName}", which config.bones does not declare`);
+          }
+          c.number(`${at}.drawn.${bName}`, deg);
+        }
+      }
+    }
     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`) : [];
     const validParts = new Set<string>([...allSlots, ...altCuts]);

package/src/parts.ts

@@ -83,6 +83,7 @@
  */
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { type Problem, refuseIfAny } from './errors.ts';
+import { KEYPOINT_NAMES, type PosePoints } from './skeleton.ts';
 import { readLayerTag } from './tags.ts';
 
 export interface PartRecord {
@@ -244,6 +245,7 @@ export interface RecompositeRecord {
 export interface AlternateSetMap {
   slots: Record<string, string>;
   hides?: string[];
+  drawn?: Record<string, number>;
 }
 
 export interface AlternatePartsRecord {
@@ -256,6 +258,8 @@ export interface AlternatePartsRecord {
   recomposite: RecompositeRecord;
   scene?: SceneRecord;
   single_run_pad?: SingleRunPad;
+  skeleton?: PosePoints;
+  drawn?: Record<string, number>;
 }
 
 export interface PartsFile {
@@ -400,6 +404,8 @@ export function serializeParts(file: PartsFile): string {
             recomposite: serializeRecomposite(a.recomposite),
             ...(a.scene === undefined ? {} : { scene: Object.fromEntries(SCENE_KEYS.map((k) => [k, (a.scene as SceneRecord)[k]])) }),
             ...(a.single_run_pad === undefined ? {} : { single_run_pad: Object.fromEntries(SINGLE_RUN_PAD_KEYS.map((k) => [k, (a.single_run_pad as SingleRunPad)[k]])) }),
+            ...(a.skeleton === undefined ? {} : { skeleton: Object.fromEntries(KEYPOINT_NAMES.map((k) => [k, (a.skeleton as PosePoints)[k]])) }),
+            ...(a.drawn === undefined ? {} : { drawn: a.drawn }),
           })),
         }),
   };

package/src/rig.ts

@@ -164,13 +164,14 @@ 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 { artCoverage, ART_ALPHA, latticeMesh, latticeStray, ONE_LOOP_PASSES } from './mesh.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';
 import { EYE_GROUP_TAGS } from './propose.ts';
 import { alphaAbove, crop, pad, type Raster } from './raster/index.ts';
 import { pyRound } from './round.ts';
 import { boneHeat, type HeatDust, heatInfluences, HEAT_LIMITS, heatRow, type HeatRow, latticeSilhouette, tracedSilhouette } from './heat.ts';
+import type { PosePoints } from './skeleton.ts';
 import { applyFaceSurfaceDeform, TURN_BONE, type TurnSpec, turnConstraintName, turnFractions, turnTwin } from './turn.ts';
 import { DISTANCE_EXPONENT, type FloorForm, type Influence, influences, type InfluenceLimits, type MeshInfluences, meshLimits, type Segment } from './weights.ts';
 
@@ -933,6 +934,93 @@ export interface RigOutput {
   sets?: AttachmentSetsFile;
 }
 
+/**
+ * Issue #465: pose a rig's bones so each bone named in `drawn` reaches that
+ * world rotation (in Spine degrees, CCW, y up), adjusting its local `rotation`
+ * from its parent's posed transform. Bones are walked in parent-first order.
+ */
+export function poseRigBonesForDrawn(
+  bones: readonly RigBone[],
+  drawn: Readonly<Record<string, number>>,
+  stops?: ReadonlyArray<{ links: readonly string[] }>,
+): RigBone[] {
+  const undrawn = new Map<string, string>();
+  for (const s of stops ?? []) for (const l of s.links) undrawn.set(`${l}_d`, l);
+  const realBone = (n: string): string => undrawn.get(n) ?? n;
+  const posed: RigBone[] = [];
+  const posedRead: RigBone[] = [];
+  for (const b of bones) {
+    const readB: RigBone = { ...b, ...(b.parent === undefined ? {} : { parent: realBone(b.parent) }) };
+    const target = drawn[b.name];
+    if (target === undefined) {
+      posed.push({ ...b });
+      posedRead.push(readB);
+      continue;
+    }
+    const m0 = computeExactFrameTransforms([...posedRead, { ...readB, rotation: 0 }]).get(b.name) as BoneTransform;
+    const rotation = places(normaliseDegrees(target - normaliseDegrees(m0.worldRotation)));
+    posed.push({ ...b, rotation });
+    posedRead.push({ ...readB, rotation });
+  }
+  return posed;
+}
+
+/**
+ * Issue #465: derive the alternate's `drawn` bone world rotations (in Spine
+ * degrees, CCW, y up) from its body-18 skeleton read (`pts`, in rig pixels, y
+ * down) against the base rig's setup bone origins (`B`) and setup world turns
+ * (`turn`).
+ */
+export function deriveAlternateDrawn(
+  pts: PosePoints,
+  B: ReadonlyMap<string, { x: number; y: number }>,
+  turn: ReadonlyMap<string, number>,
+  CX: number,
+  H: number,
+): Record<string, number> {
+  const sx = (x: number): number => x - CX;
+  const sy = (y: number): number => cropToSpineY(y, H);
+  const deg = (a: readonly [number, number], b: readonly [number, number]): number =>
+    (Math.atan2(sy(b[1]) - sy(a[1]), sx(b[0]) - sx(a[0])) * 180) / Math.PI;
+  const mid = (a: readonly [number, number], b: readonly [number, number]): [number, number] => [
+    (a[0] + b[0]) / 2,
+    (a[1] + b[1]) / 2,
+  ];
+  const out: Record<string, number> = {};
+  if (B.has('chest') && B.has('hip') && B.has('sleeve_r0') && B.has('sleeve_l0')) {
+    const hip = B.get('hip') as { x: number; y: number };
+    const sr0 = B.get('sleeve_r0') as { x: number; y: number };
+    const sl0 = B.get('sleeve_l0') as { x: number; y: number };
+    const setupTrunkAim = deg([hip.x, hip.y], mid([sr0.x, sr0.y], [sl0.x, sl0.y]));
+    const altTrunkAim = deg(mid(pts.r_hip, pts.l_hip), mid(pts.r_shoulder, pts.l_shoulder));
+    out.chest = places(normaliseDegrees((turn.get('chest') ?? 0) + (altTrunkAim - setupTrunkAim)));
+  }
+  if (B.has('head') && B.has('eye_r') && B.has('eye_l')) {
+    const er = B.get('eye_r') as { x: number; y: number };
+    const el = B.get('eye_l') as { x: number; y: number };
+    const setupEyeAim = deg([er.x, er.y], [el.x, el.y]);
+    const altEyeAim = deg(pts.r_eye, pts.l_eye);
+    out.head = places(normaliseDegrees((turn.get('head') ?? 0) + (altEyeAim - setupEyeAim)));
+  }
+  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],
+    ['sleeve_l0', pts.l_shoulder, pts.l_elbow],
+    ['sleeve_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],
+    ['leg_l1', pts.l_knee, pts.l_ankle],
+  ];
+  for (const [bone, a, b] of limbPairs) {
+    if (B.has(bone)) out[bone] = places(normaliseDegrees(deg(a, b)));
+  }
+  for (const foot of ['foot_r', 'foot_l'] as const) {
+    if (B.has(foot)) out[foot] = places(normaliseDegrees(turn.get(foot) ?? 0));
+  }
+  return out;
+}
+
 /**
  * `RIG_BLINK_HOLD_SPANS_A_FRAME` (issue #32): the eyes' hold must put an
  * idle frame inside the closed window for every `blink.t`, or the idle
@@ -1982,15 +2070,51 @@ export function buildRig(
     });
   }
   refuseIfAny(problems);
-  // ---- alternate painting sets (issue #454) -------------------------------
+  // ---- alternate painting sets (issues #454, #465) ------------------------
   // Only when `parts.alternates` is present: each alternate set's `<set>_<part>`
   // attachments are added to `skins.default[<part>]` on the existing bones and
   // slots before `applyStops` and `applyTurn`, so stopped links and turn twins
-  // carry the alternate attachments alongside the base ones.
+  // carry the alternate attachments alongside the base ones. When the alternate
+  // carries a skeleton read (`alt.skeleton`) or explicit `drawn` angles, its
+  // attachments are bound in the posed bone frames (`altWorld`) and `sets.json`
+  // records `drawn` so a retarget does not pose the art a second time.
   let sets: AttachmentSetsFile | undefined;
   if (parts.alternates !== undefined && parts.alternates.length > 0) {
     const setEntries: Record<string, AlternateSetMap> = {};
-    for (const alt of parts.alternates) {
+    for (const [altIdx, alt] of parts.alternates.entries()) {
+      const cfgAlt = cfg.alternates?.find((a) => a.name === alt.name);
+      const explicitDrawn = alt.drawn ?? cfgAlt?.drawn;
+      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`);
+          }
+        }
+      }
+      refuseIfAny(problems);
+      const derived = alt.skeleton === undefined ? undefined : deriveAlternateDrawn(alt.skeleton, B, turn, CX, H);
+      const drawn: Record<string, number> | undefined =
+        derived === undefined && explicitDrawn === undefined
+          ? undefined
+          : {
+              ...(derived ?? {}),
+              ...Object.fromEntries(Object.entries(explicitDrawn ?? {}).map(([k, v]) => [k, places(normaliseDegrees(v))])),
+            };
+      const posedBones = drawn === undefined ? null : poseRigBonesForDrawn(bones, drawn);
+      const altWorld = posedBones === null ? world : computeExactFrameTransforms(posedBones);
+      const altTurn = new Map<string, number>();
+      if (posedBones !== null) {
+        for (const b of posedBones) {
+          altTurn.set(b.name, places(normaliseDegrees((altWorld.get(b.name) as BoneTransform).worldRotation)));
+        }
+      } else {
+        for (const [k, v] of turn) altTurn.set(k, v);
+      }
+      const altRegion = (image: string, bone: string, cx: number, cy: number): RegionAttachment => {
+        const [x, y] = toBoneLocal(altWorld.get(bone) as BoneTransform, spineX(cx), spineY(cy));
+        const deg = altTurn.get(bone) as number;
+        return deg === 0 ? { image, x: places(x), y: places(y) } : { image, x: places(x), y: places(y), rotation: places(normaliseDegrees(-deg)) };
+      };
       for (const p of alt.records) {
         const attName = `${alt.name}_${p.name}`;
         const rawImg = images.get(attName);
@@ -2001,14 +2125,45 @@ export function buildRig(
         const mesh = cfg.meshes[p.name];
         if (mesh === undefined) {
           const bone = B.get(cfg.regions[p.name]) as Bone;
-          skin[p.name][attName] = region(file, bone.name, p.x + p.w / 2, p.y + p.h / 2);
+          skin[p.name][attName] = altRegion(file, bone.name, p.x + p.w / 2, p.y + p.h / 2);
           continue;
         }
         const fullSegs = meshSegments.get(p.name) as Segment[];
         const baseAtt = skin[p.name]?.[p.name];
         const baseBones = baseAtt !== undefined && 'type' in baseAtt ? new Set(baseAtt.weights.flatMap((v) => v.map((e) => e.bone))) : null;
         const filteredSegs = baseBones !== null && baseBones.size > 0 ? fullSegs.filter((s) => baseBones.has(s.bone)) : fullSegs;
-        const segs = filteredSegs.length > 0 ? filteredSegs : fullSegs;
+        let segs = filteredSegs.length > 0 ? filteredSegs : fullSegs;
+        if (drawn !== undefined) {
+          const movePt = (bone: string, pt0: Point): Point => {
+            const m0 = world.get(bone) as BoneTransform;
+            const m1 = altWorld.get(bone) as BoneTransform;
+            const [lx, ly] = toBoneLocal(m0, spineX(pt0[0]), spineY(pt0[1]));
+            const [wx, wy] = toWorld(m1, lx, ly);
+            return [wx + CX, cropToSpineY(wy, H)];
+          };
+          const pt = (q: readonly [number, number]): Point => [q[0], q[1]];
+          const skSegs: Record<string, [Point, Point]> | null =
+            alt.skeleton === undefined
+              ? null
+              : {
+                  sleeve_r0: [pt(alt.skeleton.r_shoulder), pt(alt.skeleton.r_elbow)],
+                  sleeve_r1: [pt(alt.skeleton.r_elbow), pt(alt.skeleton.r_wrist)],
+                  sleeve_l0: [pt(alt.skeleton.l_shoulder), pt(alt.skeleton.l_elbow)],
+                  sleeve_l1: [pt(alt.skeleton.l_elbow), pt(alt.skeleton.l_wrist)],
+                  leg_r0: [pt(alt.skeleton.r_hip), pt(alt.skeleton.r_knee)],
+                  leg_r1: [pt(alt.skeleton.r_knee), pt(alt.skeleton.r_ankle)],
+                  leg_l0: [pt(alt.skeleton.l_hip), pt(alt.skeleton.l_knee)],
+                  leg_l1: [pt(alt.skeleton.l_knee), pt(alt.skeleton.l_ankle)],
+                };
+          segs = segs.map((s) => {
+            const skPair = skSegs?.[s.bone];
+            return skPair !== undefined ? { bone: s.bone, a: skPair[0], b: skPair[1] } : { bone: s.bone, a: movePt(s.bone, s.a), b: movePt(s.bone, s.b) };
+          });
+          const nonSkirt = segs.filter((s) => !hipChainLinks.has(s.bone));
+          if (nonSkirt.length > 0) segs = nonSkirt;
+          const yOverlapping = segs.filter((s) => Math.max(s.a[1], s.b[1]) >= p.y && Math.min(s.a[1], s.b[1]) <= p.y + p.h);
+          segs = yOverlapping.length > 0 ? yOverlapping : [segs[0]];
+        }
         const allArt = alphaAbove(img, ART_ALPHA);
         const strayVal = 'auto' in mesh ? mesh.auto.source.stray : ('contour' in mesh ? mesh.contour.stray : mesh.stray);
         const stray = strayVal === undefined ? null : latticeStray(allArt, strayVal);
@@ -2017,7 +2172,7 @@ export function buildRig(
         const r = 'r' in mesh ? mesh.r : 80;
         const lm = latticeMesh(attName, art, grid, maxLoopPasses);
         if ('code' in lm) {
-          skin[p.name][attName] = region(file, segs[0].bone, p.x + p.w / 2, p.y + p.h / 2);
+          skin[p.name][attName] = altRegion(file, segs[0].bone, p.x + p.w / 2, p.y + p.h / 2);
           continue;
         }
         const ox = p.x - PAD;
@@ -2027,6 +2182,22 @@ export function buildRig(
         const limits: InfluenceLimits = meshLimits('influences' in mesh ? mesh.influences : undefined);
         const segsAt = dressSegsAt(p, segs);
         const exponent = mesh.exponent ?? DISTANCE_EXPONENT;
+        let touchesArt: boolean[] | null = null;
+        if (drawn !== undefined && limits.maxInfluences === 1) {
+          const lc = latticeCells(art, grid);
+          touchesArt = lm.vertices.map(([vx0, vy0]) => {
+            const ii = Math.round(vx0 / grid);
+            const jj = Math.round(vy0 / grid);
+            for (const di of [-1, 0]) {
+              for (const dj of [-1, 0]) {
+                const ci = ii + di;
+                const cj = jj + dj;
+                if (ci >= 0 && ci < lc.nx && cj >= 0 && cj < lc.ny && lc.cells.data[cj * lc.nx + ci] === 1) return true;
+              }
+            }
+            return false;
+          });
+        }
         const rawShares: Influence[][] = [];
         for (const [vx0, vy0] of lm.vertices) {
           const wx = vx0 + ox;
@@ -2038,12 +2209,26 @@ export function buildRig(
           }
           rawShares.push(limits.floor === 'continuous' ? roundShares(shares) : latticeShares(shares));
         }
+        if (touchesArt !== null) {
+          let firstArtBone: string | null = null;
+          for (let vi = 0; vi < lm.vertices.length; vi++) {
+            if (touchesArt[vi] && rawShares[vi].length > 0) {
+              firstArtBone = rawShares[vi][0].bone;
+              break;
+            }
+          }
+          if (firstArtBone !== null) {
+            for (let vi = 0; vi < lm.vertices.length; vi++) {
+              if (!touchesArt[vi]) rawShares[vi] = [{ bone: firstArtBone, weight: 1 }];
+            }
+          }
+        }
         const weights: WeightEntry[][] = [];
         for (const [vi, [vx0, vy0]] of lm.vertices.entries()) {
           const wx = vx0 + ox;
           const wy = vy0 + oy;
           const ent: WeightEntry[] = rawShares[vi].map(({ bone, weight }) => {
-            const [x, y] = toBoneLocal(world.get(bone) as BoneTransform, spineX(wx), spineY(wy));
+            const [x, y] = toBoneLocal(altWorld.get(bone) as BoneTransform, spineX(wx), spineY(wy));
             return { bone, x: places(x), y: places(y), weight };
           });
           weights.push(ent);
@@ -2065,6 +2250,7 @@ export function buildRig(
       setEntries[alt.name] = {
         slots: slotMap,
         ...(hideList.length > 0 ? { hides: hideList } : {}),
+        ...(drawn === undefined ? {} : { drawn }),
       };
     }
     sets = { spec: SETS_SPEC, sets: setEntries };