@rig-c/parts 1.14.0 → 1.16.0

package/src/guide.ts

@@ -0,0 +1,255 @@
+/**
+ * `rig-parts guide`: a slice of `docs/AUTHORING.md`, read at the moment of the
+ * call (issue #343).
+ *
+ * The guide is one file, and it is the only copy. An agent building a rig
+ * reads a failure line, `FAIL  RULE: object — detail (see rig-parts guide
+ * RULE)`, and needs the row that maps RULE to what has to change. It should
+ * not need the other 330 KB around that row. Every function here takes the
+ * guide's text and returns lines cut from it. Nothing is generated or kept
+ * apart from the file, so there is nothing to drift.
+ *
+ * Four readings, each defined on the text alone:
+ *
+ * - **A ledger table** is a Markdown table, outside a code fence, whose header's
+ *   first cell is exactly `rule` (a refusal or a warning) or `line` (a line
+ *   `check` prints). Other tables are not read.
+ * - **A row's names** are the backticked tokens in its first cell that are
+ *   rule names ({@link RULE_NAME}). A wildcard such as `PARTS_*` names
+ *   nothing. Each name sits on exactly one row in the whole guide; the
+ *   selftest's `TY16` holds that against every name the source can print.
+ * - **A row's anchors** are the `<a id="NAME"></a>` tags at the start of its
+ *   first cell, one per name. github.com keeps them as `user-content-<name>`,
+ *   and its script lowercases a link's fragment before it looks one up, so
+ *   `AUTHORING.md#NAME` lands on the row.
+ * - **`§n`** is the `## n.` heading and everything up to the next `##`.
+ *   **`§n.m`** is the m-th `###` under it, and **`§n.m.k`** the k-th `####`
+ *   under that, each counted at read time, up to the next heading of its level
+ *   or above. The guide's headings carry no number. `guide §n` and `guide
+ *   §n.m` print the numbers they counted beside each child's size.
+ *
+ * A refusal and the bar it enforces are two names, each with its own row:
+ * `CHECK_<LINE>` in a `rule` table, `<LINE>` in a `line` table. `guide` prints
+ * the asked name's row first, then `paired with <OTHER>:` and the other one's.
+ *
+ * The printed form is the one HQ settled for both packages on issue #343:
+ * `docs/AUTHORING.md §<addr>, line <N> — under "<heading>"` over each row;
+ * `docs/AUTHORING.md §<addr> "<title>", lines <a>–<b>, <X.X> KB` over a
+ * section, its children listed beneath in rig-c's columns; an unknown name or
+ * section one coded FAIL line on stderr, with rig-c's three-name ranking.
+ */
+import type { Problem } from './errors.ts';
+
+/** The guide's path inside the package, beside `cli.ts`. */
+export const GUIDE_DOC = 'docs/AUTHORING.md';
+
+/** A rule name: upper-case words joined by underscores (`USAGE` and `CHECK_LOOP_CLOSES` alike). */
+export const RULE_NAME = /^[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)*$/;
+
+/** How many of the nearest names an unknown name's refusal lists (the form shared with rig-c). */
+export const NEAREST_LISTED = 3;
+
+/** The two header words that make a table a ledger table, and what its rows are. */
+export const LEDGER_HEADS = ['rule', 'line'] as const;
+export type LedgerKind = (typeof LEDGER_HEADS)[number];
+
+/** A `##` section, a `###` or a `####`: its number, its title, its lines (1-based, end exclusive) and its size. */
+export interface GuideSection {
+  /** `"6"` for `## 6.`, `"6.3"` for the third `###` under it, `"3.6.1"` for the first `####` under §3.6. */
+  number: string;
+  /** The heading's text as written (a `##` keeps its `n. `). */
+  title: string;
+  start: number;
+  end: number;
+  /** UTF-8 bytes from the heading's line to the next heading of its level or above, each line with its newline. */
+  bytes: number;
+}
+
+/** One ledger row. */
+export interface LedgerRow {
+  kind: LedgerKind;
+  /** The row's line, 1-based. */
+  line: number;
+  /** The table's header line and its separator line, as written. */
+  header: [string, string];
+  /** The row as written. */
+  text: string;
+  /** The rule names in the first cell, in the order written. */
+  names: string[];
+  /** The ids of the `<a id="…"></a>` tags at the start of the first cell, in order. */
+  anchors: string[];
+  /** The deepest numbered section the row sits in (`§n`, `§n.m` or `§n.m.k`). */
+  section: GuideSection | null;
+  /** The nearest heading above the row, its text as written. */
+  heading: string;
+}
+
+function utf8Bytes(s: string): number {
+  return new TextEncoder().encode(s).length;
+}
+
+/** Each line, with whether it sits inside a code fence (a fence's own lines count as inside). */
+function fenced(lines: readonly string[]): boolean[] {
+  let inside = false;
+  return lines.map((l) => {
+    if (l.startsWith('```')) {
+      inside = !inside;
+      return true;
+    }
+    return inside;
+  });
+}
+
+/** Every `## n.` section, every `###` under one, and every `####` under those, numbered as {@link GuideSection} says. */
+export function guideSections(text: string): GuideSection[] {
+  const lines = text.split('\n');
+  const inFence = fenced(lines);
+  const heads: Array<{ level: number; title: string; line: number }> = [];
+  lines.forEach((l, i) => {
+    const h = inFence[i] ? null : /^(#{1,6}) (.*)$/.exec(l);
+    if (h !== null) heads.push({ level: h[1].length, title: h[2], line: i + 1 });
+  });
+  const out: GuideSection[] = [];
+  const counts = [0, 0, 0];
+  let chapter: string | null = null;
+  heads.forEach((h, k) => {
+    if (h.level <= 2) {
+      chapter = h.level === 2 ? (/^(\d+)\. /.exec(h.title)?.[1] ?? null) : null;
+      counts.fill(0);
+    } else if (h.level === 3) {
+      counts[1]++;
+      counts[2] = 0;
+    } else if (h.level === 4) counts[2]++;
+    if (chapter === null || h.level > 4 || (h.level === 4 && counts[1] === 0)) return;
+    const number = h.level === 2 ? chapter : h.level === 3 ? `${chapter}.${counts[1]}` : `${chapter}.${counts[1]}.${counts[2]}`;
+    const next = heads.slice(k + 1).find((x) => x.level <= h.level);
+    const end = next === undefined ? lines.length + 1 : next.line;
+    const title = h.title;
+    const body = lines.slice(h.line - 1, end - 1).join('\n');
+    out.push({ number, title, start: h.line, end, bytes: utf8Bytes(body) + (next === undefined ? 0 : 1) });
+  });
+  return out;
+}
+
+/** The ledger rows, in the order written. */
+export function ledgerRows(text: string): LedgerRow[] {
+  const lines = text.split('\n');
+  const inFence = fenced(lines);
+  const sections = guideSections(text);
+  const rows: LedgerRow[] = [];
+  let heading = '';
+  let header: [string, string] | null = null;
+  let kind: LedgerKind | null = null;
+  let inTable = false;
+  lines.forEach((l, i) => {
+    if (!inFence[i] && /^#{1,6} /.test(l)) heading = l.replace(/^#{1,6} /, '');
+    if (inFence[i] || !l.startsWith('|')) {
+      inTable = false;
+      return;
+    }
+    const first = (l.split('|')[1] ?? '').trim();
+    if (!inTable) {
+      inTable = true;
+      kind = (LEDGER_HEADS as readonly string[]).includes(first) ? (first as LedgerKind) : null;
+      header = [l, lines[i + 1] ?? ''];
+      return;
+    }
+    if (kind === null || header === null || /^:?-+:?$/.test(first)) return;
+    const names = [...first.matchAll(/`([^`]+)`/g)].map((x) => x[1]).filter((t) => RULE_NAME.test(t));
+    if (names.length === 0) return;
+    const lead = /^((?:<a id="[^"]*"><\/a>)*)/.exec(first)?.[1] ?? '';
+    const anchors = [...lead.matchAll(/<a id="([^"]*)"><\/a>/g)].map((x) => x[1]);
+    const line = i + 1;
+    const holding = sections.filter((s) => s.start <= line && line < s.end).sort((a, b) => b.number.split('.').length - a.number.split('.').length);
+    rows.push({ kind, line, header, text: l, names, anchors, section: holding[0] ?? null, heading });
+  });
+  return rows;
+}
+
+function editDistance(a: string, b: string): number {
+  let prev = Array.from({ length: b.length + 1 }, (_, j) => j);
+  for (let i = 1; i <= a.length; i++) {
+    const cur = [i];
+    for (let j = 1; j <= b.length; j++) cur[j] = Math.min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+    prev = cur;
+  }
+  return prev[b.length];
+}
+
+/**
+ * The {@link NEAREST_LISTED} names of `known` nearest `asked`, case aside — rig-c's ranking, the one the shared form
+ * fixes: a name `asked` is the start of (or, from three characters, a part of) first; then by edit distance less the
+ * prefix the two share; then by name. A list, never a substitute.
+ */
+export function nearestNames(known: readonly string[], asked: string): string[] {
+  const key = asked.toUpperCase();
+  const shared = (name: string): number => {
+    let k = 0;
+    while (k < key.length && k < name.length && key[k] === name[k]) k++;
+    return k;
+  };
+  const score = (name: string): number => {
+    const up = name.toUpperCase();
+    return up.startsWith(key) || (key.length >= 3 && up.includes(key)) ? -Infinity : editDistance(key, up) - shared(up);
+  };
+  return [...new Set(known)]
+    .map((name) => ({ name, d: score(name) }))
+    .sort((a, b) => a.d - b.d || (a.name < b.name ? -1 : a.name > b.name ? 1 : 0))
+    .slice(0, NEAREST_LISTED)
+    .map((x) => x.name);
+}
+
+/** A size as the shared form prints it: KB to one decimal. */
+export function kb(bytes: number): string {
+  return `${(bytes / 1024).toFixed(1)} KB`;
+}
+
+/** One row's block: where it is, then the row as written. */
+function rowBlock(row: LedgerRow): string[] {
+  return [`${GUIDE_DOC}${row.section === null ? '' : ` §${row.section.number}`}, line ${row.line} — under "${row.heading}"`, row.text];
+}
+
+/** The other half of a refusal–bar pair: `CHECK_<LINE>` and `<LINE>`, each when the guide has its row. */
+function pairOf(name: string, rows: readonly LedgerRow[]): { row: LedgerRow; name: string } | null {
+  const other = name.startsWith('CHECK_') ? name.slice('CHECK_'.length) : `CHECK_${name}`;
+  const want: LedgerKind = name.startsWith('CHECK_') ? 'line' : 'rule';
+  const row = rows.find((r) => r.kind === want && r.names.includes(other));
+  return row === undefined ? null : { row, name: other };
+}
+
+/** What `guide` answers: the lines to print, or the refusal. */
+export type GuideAnswer = { lines: string[] } | { problem: Problem };
+
+/** `guide <RULE>`: the row naming it, then `paired with <OTHER>:` and its pair's; or `GUIDE_RULE_KNOWN` with the nearest names. */
+export function guideRule(text: string, name: string): GuideAnswer {
+  const rows = ledgerRows(text);
+  const own = rows.find((r) => r.names.includes(name));
+  if (own === undefined) {
+    return { problem: { code: 'GUIDE_RULE_KNOWN', object: `"${name}"`, detail: `no row in ${GUIDE_DOC} names it; the nearest: ${nearestNames(rows.flatMap((r) => r.names), name).join(', ')}` } };
+  }
+  const pair = pairOf(name, rows);
+  return { lines: [...rowBlock(own), ...(pair === null ? [] : [`paired with ${pair.name}:`, ...rowBlock(pair.row)])] };
+}
+
+/** `guide §n`, `§n.m` or `§n.m.k`: a line naming the slice, its children's listing when it has children, then the slice. */
+export function guideSection(text: string, ask: string): GuideAnswer {
+  const sections = guideSections(text);
+  const depth = (s: GuideSection): number => s.number.split('.').length;
+  const childrenOf = (n: string | null): GuideSection[] => sections.filter((s) => (n === null ? depth(s) === 1 : s.number.startsWith(`${n}.`) && depth(s) === n.split('.').length + 1));
+  const m = /^§(\d+(?:\.\d+){0,2})$/.exec(ask);
+  const hit = m === null ? undefined : sections.find((s) => s.number === m[1]);
+  if (hit === undefined) {
+    // The deepest address the asked one shares, and what it holds: never a section put in its place.
+    const asked = m === null ? [] : m[1].split('.');
+    let parent: GuideSection | undefined;
+    for (let d = asked.length - 1; d >= 1 && parent === undefined; d--) parent = sections.find((s) => s.number === asked.slice(0, d).join('.'));
+    const kids = childrenOf(parent?.number ?? null);
+    const list = kids.length === 0 ? 'none' : kids.map((s) => `§${s.number}`).join(', ');
+    const deepest = parent === undefined ? `the guide itself, ${GUIDE_DOC}` : `§${parent.number} "${parent.title}"`;
+    return { problem: { code: 'GUIDE_SECTION_KNOWN', object: `"${ask}"`, detail: `no such section; the deepest that exists is ${deepest}, whose sections are: ${list}` } };
+  }
+  const lines = text.split('\n');
+  const head = [`${GUIDE_DOC} §${hit.number} "${hit.title}", lines ${hit.start}–${hit.end - 1}, ${kb(hit.bytes)}`];
+  for (const s of childrenOf(hit.number)) head.push(`§${s.number.padEnd(6)} ${kb(s.bytes).padStart(9)}  ${s.title}`);
+  return { lines: [...head, '', lines.slice(hit.start - 1, hit.end - 1).join('\n').replace(/\n+$/, '')] };
+}

package/src/meshdraft.ts

@@ -70,7 +70,7 @@ import { BARS, type CheckReport, type PackShape, type PageEdges, type RigcRunner
 import { type CharacterConfig, type ContourMeshSpec, type LatticeMeshSpec, loadConfigAndAnimations, type Segment } from './config.ts';
 import { PartsError, type Problem, problemLine } from './errors.ts';
 import { IDLE_FPS } from './motion.ts';
-import type { ContourBridges } from './contour.ts';
+import { type ContourBridges, FAINT_ALPHA } from './contour.ts';
 import { ART_ALPHA, DUST_MAX_PX, DUST_MAX_SHARE, isDust } from './mesh.ts';
 import { type PartsFile, readParts } from './parts.ts';
 import { alphaAbove, connectedComponents } from './raster/index.ts';
@@ -607,6 +607,12 @@ export interface BridgeFigure {
   area_px2: number;
   /** That area over the part's art px: the share of the candidate's overdraw the bridges draw (4 decimals). */
   overdraw: number;
+  /**
+   * Only when one was left out (HQ's ruling on #326): each faint island — every pixel's alpha under `FAINT_ALPHA`
+   * (`src/contour.ts`) — with its art px, its brightest pixel's alpha and its box in part-image px. Not meshed, so not
+   * drawn.
+   */
+  faint?: Array<{ art_px: number; max_alpha: number; box: [number, number, number, number] }>;
 }
 
 export interface PartRow {
@@ -637,7 +643,13 @@ export function bridgesOf(rigDir: string, part: string, art: number): BridgeFigu
   const b = rows.find((r) => r.part === part)?.contour?.bridges;
   if (b === undefined) return null;
   const area = b.joins.reduce((t, j) => t + j.area, 0);
-  return { units: b.units, joins: b.joins.map((j) => ({ span: j.span, area_px2: j.area })), area_px2: area, overdraw: art === 0 ? 0 : pyRound(area / art, 4) };
+  return {
+    units: b.units,
+    joins: b.joins.map((j) => ({ span: j.span, area_px2: j.area })),
+    area_px2: area,
+    overdraw: art === 0 ? 0 : pyRound(area / art, 4),
+    ...(b.faint === undefined ? {} : { faint: b.faint.map((f) => ({ art_px: f.art, max_alpha: f.maxAlpha, box: f.box })) }),
+  };
 }
 
 /** The mesh's area over the art's: the triangles' area in image px over the image's art px. */
@@ -772,11 +784,20 @@ export function meshDraftStage(input: MeshDraftInput, rigc: RigcRunner, checkBin
     return d === null || 'keep' in d || d.dust.length === 0 ? 'no dust' : `stray ${d.stray as number} leaves out ${d.dust.length} dust island(s) of ${d.dust.join(', ')} px`;
   };
   const row = (part: string): PartRow => rows.get(part) as PartRow;
+  const faintText = (faint: NonNullable<BridgeFigure['faint']>): string =>
+    `LEFT OUT as faint, every pixel under alpha ${FAINT_ALPHA}: ${faint.map((f) => `${f.art_px} px (brightest alpha ${f.max_alpha}, at part-image px ${f.box[0]},${f.box[1]} ${f.box[2]}x${f.box[3]})`).join('; ')} — not meshed, so not drawn; if those pixels matter to you, keep the lattice for this part`;
   const bridgeText = (r: PartRow): string => {
     const j = joined.get(r.part) as { real: number[]; bone: string };
     const b = r.candidate?.bridges;
-    const joins = b === undefined ? 'its bridges were not read' : `${b.joins.length} bridge(s) of ${b.joins.map((x) => `${x.span[0]} and ${x.span[1]} px`).join('; ')} span, ${b.area_px2} px² over no art (overdraw ${b.overdraw} of the candidate's ${r.candidate?.overdraw})`;
-    return `its ${j.real.length} real islands (${j.real.join(', ')} px) traced as ${b === undefined ? 'its' : b.units.length} grown silhouette(s) and joined into one outline by ${joins}, every vertex bound to the one bone "${j.bone}" (issue #326)`;
+    const joins =
+      b === undefined
+        ? 'its bridges were not read'
+        : b.joins.length === 0
+          ? 'no bridge'
+          : `${b.joins.length} bridge(s) of ${b.joins.map((x) => `${x.span[0]} and ${x.span[1]} px`).join('; ')} span, ${b.area_px2} px² over no art (overdraw ${b.overdraw} of the candidate's ${r.candidate?.overdraw}; overdraw is reported, never a reason to leave art out)`;
+    const faint = b?.faint ?? [];
+    const visible = j.real.length - faint.length;
+    return `its ${j.real.length} real islands (${j.real.join(', ')} px)${faint.length === 0 ? '' : `: ${faintText(faint)}; the ${visible} visible`} traced as ${b === undefined ? 'its' : b.units.length} grown silhouette(s) and joined into one outline by ${joins}, every vertex bound to the one bone "${j.bone}" (issue #326)`;
   };
 
   // 3. The drafted rig must build: a refusal laid on a part keeps that part's lattice.
@@ -933,7 +954,8 @@ export function meshDraftStage(input: MeshDraftInput, rigc: RigcRunner, checkBin
       drafted.set(row.part, { ...cand, note: row.note });
     } else if (row.note === '') {
       const failed = row.gate.filter((x) => !x.pass);
-      row.note = `keeps its lattice at grid ${row.lattice.grid}: ${failed.length === 0 ? 'no candidate was read' : failed.map((x) => `${x.reading} — ${x.text}`).join('; ')}`;
+      const faint = row.candidate?.bridges?.faint ?? [];
+      row.note = `keeps its lattice at grid ${row.lattice.grid}: ${failed.length === 0 ? 'no candidate was read' : failed.map((x) => `${x.reading} — ${x.text}`).join('; ')}${faint.length === 0 ? '' : `; on the bridged candidate those readings read: ${faintText(faint)}`}`;
     }
   }
   const configText = splicedConfig(text, drafted);
@@ -972,7 +994,7 @@ export function meshDraftStage(input: MeshDraftInput, rigc: RigcRunner, checkBin
   writeFileSync(written[0], configText);
   writeFileSync(written[1], `${JSON.stringify(report, null, 2)}\n`);
   for (const r of rowsOut) {
-    const cand = r.candidate === null ? '' : `; candidate ${r.candidate.triangles} triangle(s), overdraw ${r.candidate.overdraw}${r.candidate.bridges === undefined ? '' : ` (${r.candidate.bridges.joins.length} bridge(s), ${r.candidate.bridges.area_px2} px² over no art: overdraw ${r.candidate.bridges.overdraw} of it)`}`;
+    const cand = r.candidate === null ? '' : `; candidate ${r.candidate.triangles} triangle(s), overdraw ${r.candidate.overdraw}${r.candidate.bridges === undefined ? '' : ` (${r.candidate.bridges.joins.length} bridge(s), ${r.candidate.bridges.area_px2} px² over no art: overdraw ${r.candidate.bridges.overdraw} of it${(r.candidate.bridges.faint ?? []).map((f) => `; LEFT OUT faint ${f.art_px} px, brightest alpha ${f.max_alpha} < ${FAINT_ALPHA}`).join('')})`}`;
     log(`  ${r.mode === 'contour' ? 'DRAFTED' : 'LATTICE'}  ${r.part}: lattice grid ${r.lattice.grid} ${r.lattice.triangles} triangle(s), overdraw ${r.lattice.overdraw}${cand}`);
     for (const g of r.gate) log(`    ${g.pass ? 'pass' : 'FAIL'}  ${g.reading}: ${g.text}`);
     if (r.mode === 'grid' && r.gate.length === 0) log(`    ${r.note}`);

package/src/requirements.ts

@@ -181,8 +181,9 @@ export interface RequirementsFile {
   rests: string[];
   /**
    * Issue #320: the folds the scene means — a slot whose mesh turns a triangle
-   * over in a named animation on purpose (a sleeve hidden behind the body as
-   * the arm crosses it), each by slot and animation with the author's why.
+   * over in an animation, the idle included (issue #333), on purpose (a sleeve
+   * hidden behind the body as the arm crosses it), each by slot and animation
+   * with the author's why.
    * `ANIMATIONS_DO_NOT_FOLD` names each such fold with its why and does not
    * hold it to the bar, and fails an entry whose slot does not fold in that
    * animation, as rig-c refuses an exemption that exempts nothing. Empty when
@@ -581,11 +582,11 @@ export function resolveRequirements(file: RequirementsFile, rig: Record<string,
     }
   }
 
-  // Issue #320: each declared fold names a slot that holds a mesh and an animation beside the idle, the ones ANIMATIONS_DO_NOT_FOLD reads.
+  // Issues #320, #333: each declared fold names a slot that holds a mesh and an animation motion.json declares — the idle
+  // included, since ANIMATIONS_DO_NOT_FOLD reads every animation.
   file.may_fold.forEach((m, i) => {
     const object = `may_fold[${i}] (slot "${m.slot}", animation "${m.animation}")`;
-    if (m.animation === 'idle') problems.push({ code: 'REQUIREMENTS_MAY_FOLD', object, detail: 'names the idle, which ANIMATIONS_DO_NOT_FOLD does not read — it reads the animations beside the idle, so declaring it excepts nothing' });
-    else if (!(m.animation in anims)) unresolved(object, `names animation "${m.animation}", which motion.json does not declare; it declares ${listed(animNames)}`);
+    if (!(m.animation in anims)) unresolved(object, `names animation "${m.animation}", which motion.json does not declare; it declares ${listed(animNames)}`);
     const slots = (Array.isArray(rig.slots) ? rig.slots : []).filter(isRecord).map((s) => s.name);
     if (!slots.includes(m.slot)) {
       unresolved(object, `names slot "${m.slot}", which rig.json does not declare`);

package/src/rig.ts

@@ -1455,7 +1455,7 @@ export function buildRig(
         bones: [...bones].sort(),
         max_influences: maxInfl,
         mean_influences: pyRound(infl / cm.vertices.length, 2),
-        art_coverage: pyRound(rep.coveredArtPixels / (rep.artPixels + rep.strayPixels), 5),
+        art_coverage: pyRound(rep.coveredArtPixels / (rep.artPixels + rep.strayPixels + (rep.bridges?.faint ?? []).reduce((t, f) => t + f.art, 0)), 5),
         mode: 'contour',
         ...(exponent === undefined ? {} : { exponent }),
         ...(declared === undefined ? {} : { influences: declared }),

package/src/scene.ts

@@ -95,7 +95,7 @@ import { checkStage, gateThroughRigc, type Log } from './build.ts';
 import { ACCEPTABLE_BARS, barsNotMet, type CheckReport, DEFAULT_PACK_SHAPE, DEFAULT_PAGE_EDGES, type PackMode, requirementsNotPass, type RigcRunner } from './check.ts';
 import { CONSTRAINT_BONE_FIELDS, ROOT_BONE } from './config.ts';
 import { cropToSpineY } from './coords.ts';
-import { PartsError, type Problem, problemLine, refuseIfAny } from './errors.ts';
+import { failLine, PartsError, type Problem, refuseIfAny } from './errors.ts';
 import type { MotionSpec } from './motion.ts';
 import { readPng } from './raster/png.ts';
 import { readRequirements, type RequirementsFile } from './requirements.ts';
@@ -1353,7 +1353,7 @@ export function composeStage(input: ComposeInput, run: ComposeRunners, log: Log)
   const refused = (stage: ComposeStage, err: unknown, composed: ComposedScene | null = null): ComposeResult => {
     if (!(err instanceof PartsError)) throw err;
     const p = prefix(stage);
-    for (const x of err.problems) p(`  FAIL  ${problemLine(x)}`);
+    for (const x of err.problems) p(failLine(x));
     p(`refused: ${err.problems.length} problem(s)`);
     log(`compose: stopped at ${stage}; nothing ${stage === 'compose' ? 'was written' : 'after the check was written'}`);
     return { stoppedAt: stage, composed, check: null };