@rig-c/parts 1.30.0 → 1.32.0

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, 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';
@@ -71,18 +71,19 @@ import {
   untestedIntervals,
 } from './autoreplay.ts';
 import { besideIdleLine, FOLD_LINE, type FoldsLine, LEVEL_LINE, type LevelLine, LIMB_LINE, type LimbLine, STRESS_LINE, SWEEP_LINE, type SweepLine, buildGateLines, causeLines, IDLE_FPS, IDLE_MAX_PX, maxRgbDiff, REQUIREMENTS_DIR, type CheckReport, type PackLine, DEFAULT_PACK_SHAPE, DEFAULT_PAGE_EDGES, GATE_PROFILE, JUDGEMENT_LINES, type JudgementLine, packedBuildArgs, packedBuildLabel, type PackMode, type PackShape, type PageEdges, readFrameSet, rigcFailed, rigcIdentity, rigcRanClause, REPORTED_LINES, type ReportedLine, type RigcRunner, runCheck, SEAM_DIR, SEAM_MEAN_BAR, seamPairText, seamRigPxText, SOURCE_LINE, SEAM_PX_BAR, SEAM_PX_LEVEL, SEAM_PX_LEVEL_HIGH, SPINEBOY_YARDSTICK, STILL_DIR } from './check.ts';
-import { type Cut, type Limb, loadConfig, loadConfigAndAnimations, loadEarlyConfig } from './config.ts';
+import { type Cut, type Extend, type Limb, loadConfig, loadConfigAndAnimations, loadEarlyConfig, type Patch, type PlanEntry } from './config.ts';
 import { failLine, PartsError, type Problem, refuseIfAny } from './errors.ts';
 import type { MeshQualityReport, MotionSchedule } from 'rig-c/mesh';
 import { encodeGif } from './gif.ts';
 import { CONTROL_SUFFIX, withAnimations } from './motion.ts';
 import type { PaletteError } from './palette.ts';
 import { type LayerSet, readLayers } from './layers.ts';
-import { type PartRecord, readParts, type SingleRunPad, tagOf, writeParts } from './parts.ts';
+import { type AlternatePartsRecord, type PartRecord, readParts, type RecompositeRecord, type SingleRunPad, tagOf, writeParts } from './parts.ts';
 import { encodePngBytes, readPng, writePng } from './raster/png.ts';
 import type { Raster } from './raster/types.ts';
 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, type StrayCleared, type TurnRow } from './rig.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';
@@ -130,6 +131,14 @@ export function readRuns(full: string, head: string | null): { full: LayerSet; h
   return { full: f as LayerSet, head: h as LayerSet, single: head === null };
 }
 
+/** One `--alt <name>=<source>:<full>[:<head>]` argument (issue #454). */
+export interface AlternateCliInput {
+  name: string;
+  source: string;
+  full: string;
+  head?: string;
+}
+
 export interface AssembleStageInput {
   source: string;
   full: string;
@@ -138,6 +147,8 @@ export interface AssembleStageInput {
   config: string;
   seam: SeamRule;
   project: ProjectRule;
+  /** `--alt` entries, merged with `config.assemble.alternates` by set name (issue #454). */
+  alts?: readonly AlternateCliInput[];
 }
 
 /** Where the assemble stage writes: `parts.json`, the directory of part PNGs, the recomposite, and its error map. */
@@ -246,6 +257,250 @@ export function assembleStage(input: AssembleStageInput, outs: AssembleOutputs,
   const under = readUnders(input.config, fields.cuts);
   const caps = fields.limbs === undefined ? undefined : readCaps(input.config, fields.limbs);
   const result = assemble({ source: src, full: runs.full, head: runs.head, ...fields, under, ...(caps === undefined ? {} : { caps }), seamRule: input.seam, projectRule: input.project });
+
+  // Issue #454: alternate painting sets, assembled before any file is written.
+  const configDir = dirname(resolve(input.config));
+  const cliAlts = input.alts ?? [];
+  const cfgAlts = cfg.assemble.alternates ?? [];
+  const cliByName = new Map<string, AlternateCliInput>();
+  for (const a of cliAlts) cliByName.set(a.name, a);
+  const mergedAlts: Array<{
+    name: string;
+    at: string;
+    source?: string;
+    full?: string;
+    head?: string;
+    parts?: string[];
+    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);
+    return {
+      name: a.name,
+      at: `config.assemble.alternates[${i}] (set "${a.name}")`,
+      source: cli?.source ?? (a.source === undefined ? undefined : resolve(configDir, a.source)),
+      full: cli?.full ?? (a.full === undefined ? undefined : resolve(configDir, a.full)),
+      head: cli !== undefined ? cli.head : a.head === undefined ? undefined : resolve(configDir, a.head),
+      parts: a.parts,
+      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()) {
+    mergedAlts.push({
+      name: cli.name,
+      at: `--alt ${cli.name}`,
+      source: cli.source,
+      full: cli.full,
+      head: cli.head,
+    });
+  }
+
+  const altProblems: Problem[] = [];
+  const altBuilt: Array<{ record: AlternatePartsRecord; images: Array<{ name: string; image: Raster }> }> = [];
+  const baseSlots = result.parts.parts.map((p) => p.name);
+  for (const alt of mergedAlts) {
+    if (alt.source === undefined || alt.full === undefined) {
+      altProblems.push({
+        code: 'ASSEMBLE_ALT_INPUT_PRESENT',
+        object: alt.at,
+        detail: 'is missing source or full; declare source and full on the alternate set in config.assemble.alternates, or supply --alt <name>=<source>:<full>[:<head>]',
+      });
+      continue;
+    }
+    if (!existsSync(alt.source)) {
+      altProblems.push({
+        code: 'ASSEMBLE_ALT_INPUT_PRESENT',
+        object: `${alt.source} (alternate set "${alt.name}")`,
+        detail: 'no such file; the alternate painting is required',
+      });
+      continue;
+    }
+    if (!existsSync(alt.full)) {
+      altProblems.push({
+        code: 'ASSEMBLE_ALT_INPUT_PRESENT',
+        object: `${alt.full} (alternate set "${alt.name}")`,
+        detail: 'no such file or directory; the alternate full run is required',
+      });
+      continue;
+    }
+    if (alt.head !== undefined && !existsSync(alt.head)) {
+      altProblems.push({
+        code: 'ASSEMBLE_ALT_INPUT_PRESENT',
+        object: `${alt.head} (alternate set "${alt.name}")`,
+        detail: 'no such file or directory; the alternate head run is required when named',
+      });
+      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({
+        code: 'ASSEMBLE_ALT_CANVAS_SIZE',
+        object: `${alt.source} (alternate set "${alt.name}")`,
+        detail: `is ${altSrc.width}x${altSrc.height}, while the primary painting ${input.source} is ${src.width}x${src.height}; an alternate painting must share the primary painting's canvas size so its parts land in the same rig frame`,
+      });
+      continue;
+    }
+    const altRuns = readRuns(alt.full, alt.head ?? null);
+    const hidesSet = new Set(alt.hides ?? []);
+    const declaredSlots = alt.parts !== undefined ? alt.parts.filter((p) => !hidesSet.has(p)) : baseSlots.filter((p) => !hidesSet.has(p));
+    const coveredSet = new Set(declaredSlots);
+    const rawCuts = alt.cuts !== undefined ? alt.cuts : fields.cuts.filter((c) => coveredSet.has(c.into) && coveredSet.has(c.from)).map((c) => ({ ...c, under: undefined }));
+    const altLimbs: Record<string, Limb> = {};
+    if (fields.limbs !== undefined) {
+      for (const [ln, limb] of Object.entries(fields.limbs)) {
+        if (limb.segments.every((sg) => coveredSet.has(sg.part))) {
+          altLimbs[ln] = { ...limb, segments: limb.segments.map((sg) => ({ ...sg, cap: undefined })) };
+        }
+      }
+    }
+    const neededPlan = new Set<string>();
+    for (const [name] of fields.plan) {
+      if (
+        coveredSet.has(name) ||
+        rawCuts.some((c) => c.from === name) ||
+        Object.values(altLimbs).some((l) => l.segments.some((sg) => sg.from === name))
+      ) {
+        neededPlan.add(name);
+      }
+    }
+    const altPlan: PlanEntry[] = fields.plan
+      .filter(([name]) => neededPlan.has(name))
+      .map(([name, run, tag]): PlanEntry => (altRuns.single ? [name, 'full', tag] : [name, run, tag]));
+    let missingLayer = false;
+    for (const [name, run, tag] of altPlan) {
+      const l = altRuns[run].layers.find((x) => x.name === tag);
+      if (l === undefined || l.opaquePx === 0) {
+        altProblems.push({
+          code: 'ASSEMBLE_ALT_INPUT_PRESENT',
+          object: `alternate set "${alt.name}" (part "${name}")`,
+          detail: `takes ${run}:${tag}, which ${l === undefined ? 'is absent' : 'has 0 opaque pixels'} in ${altRuns[run].source}; every covered part of the alternate set must be present in its runs, or listed in hides`,
+        });
+        missingLayer = true;
+      }
+    }
+    if (missingLayer) continue;
+    const altPlanNames = new Set(altPlan.map((e) => e[0]));
+    const remapDraw = (d: Patch['draw']): Patch['draw'] => {
+      if (typeof d !== 'object') return d;
+      if (altPlanNames.has(d.before)) return d;
+      const baseIdx = fields.plan.findIndex((e) => e[0] === d.before);
+      for (let i = Math.max(0, baseIdx); i < fields.plan.length; i++) {
+        if (altPlanNames.has(fields.plan[i][0])) return { before: fields.plan[i][0] };
+      }
+      return 'front';
+    };
+    const altExtend: Extend[] = altRuns.single ? [] : fields.extend.filter((e) => altPlanNames.has(e.part));
+    const altPatches: Patch[] = fields.patches.filter((p) => coveredSet.has(p.name)).map((p) => ({ ...p, draw: remapDraw(p.draw) }));
+    const altCuts: Cut[] = rawCuts.map((c) => ({ ...c, draw: remapDraw(c.draw) }));
+    const altUnder = alt.cuts !== undefined ? readUnders(input.config, altCuts) : altCuts.map(() => null);
+    const altHeadBox = alt.head_box ?? (altRuns.single ? singleRunHeadBox(altSrc.width, altSrc.height, fields.resolution) : fields.headBox);
+    const altRes = assemble({
+      source: altSrc,
+      full: altRuns.full,
+      head: altRuns.head,
+      resolution: fields.resolution,
+      headBox: altHeadBox,
+      rigScale: fields.rigScale,
+      plan: altPlan,
+      extend: altExtend,
+      patches: altPatches,
+      cuts: altCuts,
+      under: altUnder,
+      ...(Object.keys(altLimbs).length > 0 ? { limbs: altLimbs, bones: fields.bones } : {}),
+      ...(fields.scene === undefined ? {} : { scene: fields.scene }),
+      ...(fields.armSplit !== undefined && altPlan.some((e) => e[1] === 'full' && (e[2] === 'handwear-r' || e[2] === 'handwear-l')) ? { armSplit: fields.armSplit } : {}),
+      seamRule: input.seam,
+      projectRule: input.project,
+    });
+    const keptImages = altRes.images
+      .filter(({ record }) => coveredSet.has(record.name))
+      .map(({ record, image }) => ({ name: `${alt.name}_${record.name}`, image }));
+    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,
+        ...(alt.parts === undefined ? {} : { parts: [...alt.parts] }),
+        ...(alt.hides === undefined || alt.hides.length === 0 ? {} : { hides: [...alt.hides] }),
+        slots,
+        records: keptRecords,
+        ghost_px: altRes.parts.ghost_px,
+        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,
+    });
+  }
+  refuseIfAny(altProblems);
+  if (altBuilt.length > 0) {
+    result.parts.alternates = altBuilt.map((b) => b.record);
+  }
+
   // Emit only after green: every refusal above has already thrown.
   mkdirSync(outs.partsDir, { recursive: true });
   mkdirSync(dirname(outs.partsJson), { recursive: true });
@@ -253,6 +508,9 @@ export function assembleStage(input: AssembleStageInput, outs: AssembleOutputs,
   mkdirSync(dirname(outs.errorMap), { recursive: true });
   writeParts(outs.partsJson, result.parts);
   for (const { record, image } of result.images) writePng(join(outs.partsDir, `${record.name}.png`), image);
+  for (const b of altBuilt) {
+    for (const { name, image } of b.images) writePng(join(outs.partsDir, `${name}.png`), image);
+  }
   writePng(outs.recomposite, result.recomposite);
   writePng(outs.errorMap, result.errorMap);
   // Issue #242: under config.scene, the figure the recomposite was read inside, beside the recomposite.
@@ -820,11 +1078,19 @@ export function rigStage(input: RigStageInput, rigc: RigcRunner, scratch: string
     const png = join(input.parts, 'parts', `${p.name}.png`);
     if (existsSync(png)) images.set(p.name, readPng(png));
   }
+  for (const alt of parts.alternates ?? []) {
+    for (const p of alt.records) {
+      const attName = `${alt.name}_${p.name}`;
+      const png = join(input.parts, 'parts', `${attName}.png`);
+      if (existsSync(png)) images.set(attName, readPng(png));
+    }
+  }
   const first = buildRig(cfg, parts, images, undefined, input.idleKeys ?? DEFAULT_IDLE_KEYS, input.reduce);
   const textsOf = (r: RigOutput): Array<[string, string]> => [
     ['rig.json', rigJsonText(r.rig)],
     ['motion.json', rigJsonText(withAnimations(r.motion, from === null ? null : from.table))],
     ['mesh_report.json', rigJsonText(r.meshReport)],
+    ...(r.sets === undefined ? [] : [[SETS_FILE, rigJsonText(r.sets)] as [string, string]]),
   ];
   const firstTexts = textsOf(first);
   // The gate runs before the lines are printed, and its lines print where they always did: an automatic part's motion
@@ -855,7 +1121,7 @@ export function rigStage(input: RigStageInput, rigc: RigcRunner, scratch: string
   const replays = new Map<string, ReplayRow | MultiIntervalRow>();
   if (settled) {
     const swapped = JSON.parse(rigJsonText(first.rig)) as RigSpec;
-    for (const k of chosen) swapped.skins.default[k.part] = { [k.part]: k.candidate.attachment };
+    for (const k of chosen) swapped.skins.default[k.part] = { ...swapped.skins.default[k.part], [k.part]: k.candidate.attachment };
     rig = { ...first, rig: swapped, meshReport: first.meshReport.map((m) => chosen.find((k) => k.part === m.part)?.candidate.row ?? m) };
     texts = textsOf(rig);
     let model: string | null = null;
@@ -1004,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;
 }
 
 /**
@@ -1183,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}`);
@@ -1201,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];
@@ -1214,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) {
@@ -1499,6 +1784,12 @@ export interface BuildInput {
   seamPairs?: boolean;
   /** `--keep-stills`, forwarded to the check as `check` takes it (issue #257): the setup-pose still under `check/setup_still/`; absent, nothing moves. */
   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. */
@@ -1521,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' },
 };
@@ -1617,7 +1910,7 @@ export function build(input: BuildInput, run: BuildRunners, log: Log): BuildResu
     // The same for the requirements file's own shape; its names resolve against the rig, in the check, before it builds.
     if (input.requirements !== undefined) readRequirements(input.requirements);
     assembleStage(
-      { source: input.source, full: input.full, head: input.head, config: input.config, seam: input.seam, project: input.project },
+      { source: input.source, full: input.full, head: input.head, config: input.config, seam: input.seam, project: input.project, ...(input.alts === undefined ? {} : { alts: input.alts }) },
       { partsJson: join(out, 'parts.json'), partsDir: join(out, 'parts'), recomposite: join(out, 'recomposite_rig.png'), errorMap: join(out, ERROR_MAP_FILE) },
       prefixed('assemble'),
     );
@@ -1633,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);
   }