@rig-c/parts 1.20.0 → 1.22.0

package/src/assemble.ts

@@ -93,7 +93,9 @@
  * - **What lies under a piece** (`cuts[].under`, `fillUnder`, issue #193) is
  *   this port's: an authored image the base takes where the cut removed its
  *   pixels, so a piece that swings away leaves no hole. The stage reads that
- *   image only there and never invents a pixel.
+ *   image only there and never invents a pixel. With `under_fill: "colour"`
+ *   (issue #360) the base takes the image's colour only and keeps the alpha
+ *   the cut removed, so the part's silhouette is the uncut layer's.
  *
  * Pure: no clock, no randomness, no file access. The CLI reads and writes.
  */
@@ -102,7 +104,7 @@ import { type Problem, refuseIfAny } from './errors.ts';
 import { figuresPhrase, implausibleRules, type Layer, type LayerFigures, layerFigures, type LayerSet, NEAR_WHITE_MIN, OPAQUE_ALPHA_ABOVE, ruleSummary } from './layers.ts';
 import { padToSquare, squarePad } from './inputs.ts';
 import { type CapRecord, type LimbRecord, PAINTING_RUN, type PartRecord, type PartsFile, type RecompositeRecord, type SceneRecord, type SingleRunPad } from './parts.ts';
-import { type BonePlace, bonePlaces, capBox, inDisc, type JointLine, jointLine, limbPolyline, limbWidth, nearestLimb, pastJoint, segmentOf } from './limbs.ts';
+import { type BonePlace, bonePlaces, capBox, coveredRadius, type CutPlacement, featherWeight, halfWidthAbout, inDisc, jointLine, type JointLine, jointOffsets, limbPolyline, limbRun, luma601, nearestLimb, pastJoint, placeCut, segmentOf } from './limbs.ts';
 import {
   alphaComposite,
   connectedComponents,
@@ -1726,22 +1728,28 @@ export interface CutCount {
   under?: number;
   /** With `under` only: the removed pixels the image left empty (its alpha below the alpha removed); `under + underEmpty` is the removed count. */
   underEmpty?: number;
+  /** With `under_fill: "colour"` only (issue #360): the `under` pixels took the image's colour at the alpha the cut removed; absent without it. */
+  underFill?: 'colour';
 }
 
 /**
  * The cut lines the assemble stage prints, one per plan part with cuts, in
  * the `pixels:` line's shape: `  cut: "<from>" opaque <before> = "<from>"
  * <kept> + "<into>" <taken> …`. Empty without cuts, so a config with none
- * prints what it printed before.
+ * prints what it printed before. With a cut of `under_fill: "colour"`
+ * (issue #360) the filled count says how many of its pixels took the colour
+ * only; without one the line is issue #193's.
  */
 export function cutLines(cuts: readonly CutCount[]): string[] {
   const byFrom = new Map<string, CutCount[]>();
   for (const c of cuts) byFrom.set(c.from, [...(byFrom.get(c.from) ?? []), c]);
-  return [...byFrom.entries()].map(
-    ([from, cs]) =>
+  return [...byFrom.entries()].map(([from, cs]) => {
+    const colour = cs.some((c) => c.underFill === 'colour') ? ` (${cs.reduce((a, c) => a + (c.underFill === 'colour' ? (c.under ?? 0) : 0), 0)} colour only, at the alpha the cut removed)` : '';
+    return (
       `  cut: "${from}" opaque ${cs[0].before} = "${from}" ${cs[0].kept} + ${cs.map((c) => `"${c.into}" ${c.taken}`).join(' + ')}; band ${cs.reduce((a, c) => a + c.band, 0)} px held by both` +
-      (cs.some((c) => c.under !== undefined) ? `; under ${cs.reduce((a, c) => a + (c.under ?? 0), 0)} px filled, ${cs.reduce((a, c) => a + (c.underEmpty ?? 0), 0)} px left empty` : ''),
-  );
+      (cs.some((c) => c.under !== undefined) ? `; under ${cs.reduce((a, c) => a + (c.under ?? 0), 0)} px filled${colour}, ${cs.reduce((a, c) => a + (c.underEmpty ?? 0), 0)} px left empty` : '')
+    );
+  });
 }
 
 /**
@@ -1771,8 +1779,14 @@ export function underBox(polygon: ReadonlyArray<readonly [number, number]>): { x
  * is the only place the image is read: its pixels over the band, over pixels
  * the layer never had, and over the box outside the polygon change nothing.
  * `filled + empty` is the removed count.
+ *
+ * With `fill` `"colour"` (issue #360, `cuts[].under_fill`) 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: the part's alpha
+ * is the uncut layer's wherever the image fills, so its silhouette does not
+ * grow over a soft edge an opaque image covers.
  */
-export function fillUnder(base: Raster, piece: Raster, band: Mask, under: Raster, box: { x0: number; y0: number }): { filled: number; empty: number } {
+export function fillUnder(base: Raster, piece: Raster, band: Mask, under: Raster, box: { x0: number; y0: number }, fill?: 'colour'): { filled: number; empty: number } {
   const W = base.width;
   let filled = 0;
   let empty = 0;
@@ -1784,7 +1798,10 @@ export function fillUnder(base: Raster, piece: Raster, band: Mask, under: Raster
       empty++;
       continue;
     }
-    base.data.set(under.data.subarray(u, u + 4), p * 4);
+    if (fill === 'colour') {
+      base.data.set(under.data.subarray(u, u + 3), p * 4);
+      base.data[p * 4 + 3] = a;
+    } else base.data.set(under.data.subarray(u, u + 4), p * 4);
     filled++;
   }
   return { filled, empty };
@@ -1839,7 +1856,23 @@ export interface LimbCount {
   before: number;
   shares: Array<{ part: string; px: number }>;
   /** The joints whose cap this part's segments carry, in `config.limbs` order. */
-  joints: Array<{ limb: string; joint: string; part: string; cap: CapRecord }>;
+  joints: Array<{ limb: string; joint: string; part: string; upper: string; cap: CapRecord }>;
+}
+
+/**
+ * What `cut_band` did at a joint (issue #360, item 14), for the `limb cap:`
+ * line: the line chosen — its offset from the joint line and a point it
+ * passes through — the stroke pixels it crosses, those the joint line
+ * crosses, and the split that made a pixel a stroke.
+ */
+function cutPhrase(k: CapRecord, upper: string, lower: string): string {
+  const off = k.cut_offset ?? 0;
+  const where = off === 0 ? 'on the joint line' : `${Math.abs(off)} px ${off < 0 ? `before the joint line (toward "${upper}")` : `past the joint line (toward "${lower}")`}`;
+  const stroke =
+    k.stroke_luma_max === undefined
+      ? `no stroke: the ${k.band_px ?? 0} px of the limb's art the band's lines cross hold one luma, so nothing splits from it`
+      : `stroke: luma ${k.stroke_luma_max} or below, the Otsu split of the ${k.band_px ?? 0} px of the limb's art the band's lines cross`;
+  return `cut_band ${k.cut_band ?? 0}: the cut ${where}, through [${(k.cut_at ?? k.at).join(', ')}], crosses ${k.cut_crossed ?? 0} stroke px; the joint line crosses ${k.joint_crossed ?? 0} (${stroke})`;
 }
 
 /**
@@ -1853,13 +1886,23 @@ export function limbLines(counts: readonly LimbCount[]): string[] {
     out.push(`  limb cut: "${c.of}" opaque ${c.before} = ${c.shares.map((q) => `"${q.part}" ${q.px}`).join(' + ')}`);
     for (const j of c.joints) {
       const k = j.cap;
-      const from = k.image_px === undefined ? `${k.layer_px} px from the layer` : `${k.image_px} px from ${k.image_layer === undefined ? 'the cap image' : `the hidden-art layer ${k.image_layer}`}, ${k.layer_px} px from the layer`;
+      const base = k.image_px === undefined ? `${k.layer_px} px from the layer` : `${k.image_px} px from ${k.image_layer === undefined ? 'the cap image' : `the hidden-art layer ${k.image_layer}`}, ${k.layer_px} px from the layer`;
+      // Issue #360: what cap_shape "disc" and edge "feather" did, said only when declared, so a limb without them prints what it did.
+      const from = k.shape === undefined ? base : `${base}, ${k.upper_px ?? 0} px from "${j.upper}"`;
+      const radius =
+        k.shape === undefined
+          ? `a disc of radius ${k.radius} px (the limb ${k.width} px across the joint line)`
+          : `a disc of radius ${k.radius} px (cap_shape "disc": the joint's distance to the nearer side of the limb, ${k.width} px across the joint line)`;
+      const shaped = [
+        ...(k.edge === undefined ? [] : [`edge "feather": ${k.feathered_px ?? 0} px of "${j.upper}" faded across the ${k.feather_radius ?? 0} px about the joint that "${j.part}" covers at every turn`]),
+        ...(k.cut_band === undefined ? [] : [cutPhrase(k, j.upper, j.part)]),
+      ];
       const miss =
         k.missing_px === 0
           ? 'none missing'
           : `${k.missing_px} px missing — the layer has no pixel there (hidden in the painting, or past the limb's outline), and the tool invents none: paint them into a ${k.box[2]}x${k.box[3]} image whose pixel (i, j) is rig pixel (${k.box[0]} + i, ${k.box[1]} + j), and name it in the segment's "cap"`;
       out.push(
-        `  limb cap: "${j.limb}" joint "${j.joint}" at [${k.at[0]}, ${k.at[1]}], on "${j.part}": a disc of radius ${k.radius} px (the limb ${k.width} px across the joint line), box [${k.box.join(', ')}] — on the upper side of the line ${from}, ${miss}`,
+        `  limb cap: "${j.limb}" joint "${j.joint}" at [${k.at[0]}, ${k.at[1]}], on "${j.part}": ${radius}, box [${k.box.join(', ')}] — on the upper side of the line ${from}, ${miss}${shaped.map((q) => `; ${q}`).join('')}`,
       );
     }
   }
@@ -1893,6 +1936,11 @@ export function limbOrder(order: readonly DrawSlot[], plan: readonly PlanEntry[]
   return out;
 }
 
+/** The point a joint line moved `offset` px along its axis passes through, to 3 places (issue #360, `cut_band`). */
+function shiftedAt(line: JointLine, offset: number): [number, number] {
+  return [pyRound(line.at[0] + offset * line.axis[0], 3), pyRound(line.at[1] + offset * line.axis[1], 3)];
+}
+
 /**
  * Cut every declared limb (module comment of `src/limbs.ts`): each part a limb
  * takes is split among the limbs that take it (nearest polyline), then each
@@ -1926,7 +1974,7 @@ function cutLimbs(
   const parts: LimbPart[] = [];
   for (const l of names) {
     limbs[l].segments.forEach((sg, k) =>
-      parts.push({ limb: l, segment: k, part: sg.part, of: sg.from, record: { name: l, segment: k, of: sg.from, bone: sg.bone, ...(k === 0 ? {} : { joint: sg.joint as string }) } }),
+      parts.push({ limb: l, segment: k, part: sg.part, of: sg.from, record: { name: l, segment: k, of: sg.from, bone: sg.bone, ...(k === 0 ? {} : { joint: sg.joint as string, ...(sg.range === undefined ? {} : { range: [sg.range[0], sg.range[1]] as [number, number] }) }) } }),
     );
   }
   const polylines = new Map(names.map((l) => [l, limbPolyline(limbs[l], places)]));
@@ -1954,6 +2002,9 @@ function cutLimbs(
     );
   }
   refuseIfAny(problems);
+  // The line each segment's pixels are split by: the joint line, or where cut_band placed the cut (issue #360).
+  const cutLines = new Map([...lines].map(([l, ls]) => [l, [...ls]]));
+  const placements = new Map<string, Extract<CutPlacement, { ok: true }>>();
   // Each part a limb takes, in the order the limbs first take them.
   const sources = [...new Set(parts.map((q) => q.of))];
   const pieces: Array<Built | null> = parts.map(() => null);
@@ -1977,14 +2028,42 @@ function cutLimbs(
       for (let x = 0; x < W; x++) {
         const p = y * W + x;
         if (b.r.data[p * 4 + 3] === 0) continue;
-        const li = on.length === 1 ? 0 : nearestLimb(lns, x, y);
-        const l = on[li];
-        own[p] = names.indexOf(l);
+        own[p] = names.indexOf(on[on.length === 1 ? 0 : nearestLimb(lns, x, y)]);
+      }
+    }
+    // Issue #360 (item 14): each joint of this part that declares cut_band has its cut placed, on the limb's own art.
+    for (const l of on) {
+      const li = names.indexOf(l);
+      limbs[l].segments.forEach((sg, k) => {
+        if (k === 0 || sg.cut_band === undefined || sg.from !== src || limbs[l].segments[k - 1].from !== src) return;
+        const line = (lines.get(l) as Array<JointLine | null>)[k] as JointLine;
+        const art = (x: number, y: number): boolean => x >= 0 && y >= 0 && x < W && y < H && own[y * W + x] === li && b.r.data[(y * W + x) * 4 + 3] > OPAQUE_ALPHA_ABOVE;
+        const luma = (x: number, y: number): number => luma601(b.r.data[(y * W + x) * 4], b.r.data[(y * W + x) * 4 + 1], b.r.data[(y * W + x) * 4 + 2]);
+        // The joint line on no art is ASSEMBLE_LIMB_JOINT_ON_ART at the caps; nothing is placed about it.
+        if (limbRun(line, art, [0, 0, W - 1, H - 1]) === null) return;
+        const placed = placeCut(line, sg.cut_band, art, luma, [0, 0, W - 1, H - 1]);
+        if (!placed.ok) {
+          problems.push({
+            code: 'ASSEMBLE_LIMB_CUT_BAND',
+            object: `config.limbs.${l}.segments[${k}] (joint "${String(sg.joint)}", part "${sg.part}").cut_band`,
+            detail: `is ${sg.cut_band}, and the line ${Math.abs(placed.offset)} px ${placed.offset < 0 ? 'before' : 'past'} the joint line, through [${shiftedAt(line, placed.offset).join(', ')}], crosses none of the limb's art within 1 px of that point — the band reaches past the limb there, and a cut placed off the art is no cut; a band whose every line crosses the limb is required — ${Math.abs(placed.offset) > 1 ? `cut_band ${Math.abs(placed.offset) - 1} or less` : 'leave cut_band out'}`,
+          });
+          return;
+        }
+        (cutLines.get(l) as Array<JointLine | null>)[k] = placed.line;
+        placements.set(`${l}/${k}`, placed);
+      });
+    }
+    for (let y = 0; y < H; y++) {
+      for (let x = 0; x < W; x++) {
+        const p = y * W + x;
+        if (b.r.data[p * 4 + 3] === 0) continue;
+        const l = names[own[p]];
         const segs = limbs[l].segments;
         const first = segs.findIndex((sg) => sg.from === src);
         let last = first;
         while (last + 1 < segs.length && segs[last + 1].from === src) last++;
-        const k = segmentOf(lines.get(l) as Array<JointLine | null>, first, last, x, y);
+        const k = segmentOf(cutLines.get(l) as Array<JointLine | null>, first, last, x, y);
         const at = parts.findIndex((q) => q.limb === l && q.segment === k);
         rasters[at].data.set(b.r.data.subarray(p * 4, p * 4 + 4), p * 4);
         if (b.region === null || b.region.data[p] === 1) regions[at].data[p] = 1;
@@ -2028,8 +2107,8 @@ function cutLimbs(
         return false;
       };
       const object = `config.limbs.${l}.segments[${k}] (joint "${String(sg.joint)}", part "${sg.part}")`;
-      const width = limbWidth(line, art, [0, 0, W - 1, H - 1]);
-      if (width === null) {
+      const run = limbRun(line, art, [0, 0, W - 1, H - 1]);
+      if (run === null) {
         problems.push({
           code: 'ASSEMBLE_LIMB_JOINT_ON_ART',
           object,
@@ -2038,10 +2117,23 @@ function cutLimbs(
         return;
       }
       // The width to 3 places (src/round.ts): a measured length, and a radius the line and the record print as read.
-      const w3 = pyRound(width, 3);
-      const radius = w3 / 2;
+      const w3 = pyRound(run[1] - run[0] + 1, 3);
+      // Issue #360: under cap_shape "disc" the radius is the half-width about the joint (src/limbs.ts), to 3 places as well.
+      const disc = sg.cap_shape === 'disc';
+      const half = halfWidthAbout(run);
+      if (disc && half <= 0) {
+        problems.push({
+          code: 'ASSEMBLE_LIMB_JOINT_ON_ART',
+          object,
+          detail: `the joint, "${sg.bone}"'s origin at [${line.at.join(', ')}], lies on the edge of the limb's art along its joint line — the run of art reaches ${pyRound(run[1] + 0.5, 3)} px from it one way and ${pyRound(0.5 - run[0], 3)} px the other — so cap_shape "disc" has no half-width about it; a bone origin inside the limb's art is required — move the bone onto the joint`,
+        });
+        return;
+      }
+      const radius = disc ? pyRound(half, 3) : w3 / 2;
       const box = capBox(line.at, radius);
       const at = parts.findIndex((q) => q.limb === l && q.segment === k);
+      const upAt = parts.findIndex((q) => q.limb === l && q.segment === k - 1);
+      const upper = rasters[upAt];
       // Issue #359: the lower segment's part's hidden-art layer is its cap when the segment names no cap image; with one named, a refusal.
       const hidden = hiddenOf(sg.from);
       if (hidden !== null && sg.cap !== undefined) {
@@ -2063,13 +2155,17 @@ function cutLimbs(
       }
       const lower = rasters[at];
       const lowerSrc = builtOf(sg.from) as Built;
+      // Issue #360 (cut_band): the cap's pixels are the disc's on the upper side of the cut, wherever it was placed.
+      const cut = (cutLines.get(l) as Array<JointLine | null>)[k] as JointLine;
+      const placed = placements.get(`${l}/${k}`);
       const ownLower = owners.get(sg.from) as Int32Array;
       let layerPx = 0;
       let imagePx = 0;
+      let upperPx = 0;
       let missing = 0;
       for (let y = Math.max(0, box[1]); y < Math.min(H, box[1] + box[3]); y++) {
         for (let x = Math.max(0, box[0]); x < Math.min(W, box[0] + box[2]); x++) {
-          if (!inDisc(line.at, radius, x, y) || pastJoint(line, x, y)) continue;
+          if (!inDisc(line.at, radius, x, y) || pastJoint(cut, x, y)) continue;
           const p = y * W + x;
           const u = img === null ? -1 : ((y - box[1]) * img.width + (x - box[0])) * 4;
           if (img !== null && img.data[u + 3] > 0) {
@@ -2078,6 +2174,10 @@ function cutLimbs(
           } else if (ownLower[p] === li && lowerSrc.r.data[p * 4 + 3] > 0) {
             lower.data.set(lowerSrc.r.data.subarray(p * 4, p * 4 + 4), p * 4);
             layerPx++;
+          } else if (disc && upper.data[p * 4 + 3] > 0) {
+            // Issue #360: the disc is filled from the art — the upper segment's, where the lower's layer has none.
+            lower.data.set(upper.data.subarray(p * 4, p * 4 + 4), p * 4);
+            upperPx++;
           } else missing++;
         }
       }
@@ -2085,11 +2185,54 @@ function cutLimbs(
         problems.push({ code: 'ASSEMBLE_LIMB_CAP_EMPTY', object: `${object}.cap`, detail: `${String(sg.cap)} is transparent over every one of the cap's pixels; an image that gives at least one is required — to keep the layer's cap, drop cap` });
         return;
       }
-      const cap: CapRecord = { at: [line.at[0], line.at[1]], width: w3, radius, box, layer_px: layerPx, ...(img === null ? {} : { image_px: imagePx }), ...(hidden === null ? {} : { image_layer: hidden.layer }), missing_px: missing };
+      // Issue #360: under edge "feather", the upper piece fades out across the cap, over the lower's opaque pixels only.
+      let featheredPx = 0;
+      let band = 0;
+      if (sg.edge === 'feather') {
+        band = pyRound(Math.max(0, coveredRadius(line.at, radius, (x, y) => x >= 0 && y >= 0 && x < W && y < H && lower.data[(y * W + x) * 4 + 3] === 255)), 3);
+        const fb = capBox(line.at, band);
+        for (let y = Math.max(0, fb[1]); y < Math.min(H, fb[1] + fb[3]); y++) {
+          for (let x = Math.max(0, fb[0]); x < Math.min(W, fb[0] + fb[2]); x++) {
+            if (band === 0 || !inDisc(line.at, band, x, y) || pastJoint(cut, x, y)) continue;
+            const p = y * W + x;
+            const ua = upper.data[p * 4 + 3];
+            if (ua === 0) continue;
+            const o = jointOffsets(line, x, y);
+            const na = Math.floor(ua * featherWeight(band, o.along, o.across, placed?.offset ?? 0) + 0.5);
+            if (na === ua) continue;
+            if (na === 0) upper.data.fill(0, p * 4, p * 4 + 4);
+            else upper.data[p * 4 + 3] = na;
+            featheredPx++;
+          }
+        }
+      }
+      const cap: CapRecord = {
+        at: [line.at[0], line.at[1]],
+        width: w3,
+        radius,
+        box,
+        layer_px: layerPx,
+        ...(img === null ? {} : { image_px: imagePx }),
+        ...(hidden === null ? {} : { image_layer: hidden.layer }),
+        missing_px: missing,
+        ...(disc ? { shape: 'disc' as const, upper_px: upperPx } : {}),
+        ...(sg.edge === 'feather' ? { edge: 'feather' as const, feather_radius: band, feathered_px: featheredPx } : {}),
+        ...(placed === undefined
+          ? {}
+          : {
+              cut_band: sg.cut_band as number,
+              cut_offset: placed.offset,
+              cut_at: shiftedAt(line, placed.offset),
+              cut_crossed: placed.crossed,
+              joint_crossed: placed.jointCrossed,
+              band_px: placed.bandPx,
+              ...(placed.strokeLumaMax === null ? {} : { stroke_luma_max: placed.strokeLumaMax }),
+            }),
+      };
       if (hidden !== null) readHidden(hidden.layer, `config.limbs.${l}.segments[${k}].cap (part "${sg.part}")`);
       parts[at].record.cap = cap;
       const c = counts.find((q) => q.of === sg.from);
-      if (c !== undefined) c.joints.push({ limb: l, joint: String(sg.joint), part: sg.part, cap });
+      if (c !== undefined) c.joints.push({ limb: l, joint: String(sg.joint), part: sg.part, upper: segs[k - 1].part, cap });
     });
   }
   refuseIfAny(problems);
@@ -2377,7 +2520,17 @@ export function assemble(input: AssembleInput): AssembleResult {
     cuts,
   );
   cuts.forEach((q, i) => {
-    if (q.under === undefined) return;
+    if (q.under === undefined) {
+      // Issue #360: under_fill says how an under fills; a cut with no under (no file, no hidden-art layer) has nothing it could say it of.
+      if (q.under_fill !== undefined) {
+        patchProblems.push({
+          code: 'ASSEMBLE_UNDER_FILL_SOURCE',
+          object: `config.assemble.cuts[${i}].under_fill (part "${q.into}")`,
+          detail: `is "${q.under_fill}", and the cut has no under: it names no under file and "${q.from}" has no hidden-art layer; under_fill says how an under fills the pixels the cut removed, so one is required — name under, or drop under_fill`,
+        });
+      }
+      return;
+    }
     const object = `config.assemble.cuts[${i}].under (part "${q.into}")`;
     const u = unders[i];
     if (u === null) {
@@ -2563,7 +2716,8 @@ export function assemble(input: AssembleInput): AssembleResult {
       const u = unders[i];
       if (u === null) return undefined;
       // Filled where the image is at least as opaque as the layer was; left empty elsewhere (`fillUnder`).
-      const f = fillUnder(b.r, (pieces[i] as Built).r, cutBand(cutMasks[i], cuts[i].overlap), u, underBox(cuts[i].polygon));
+      // With under_fill "colour" (issue #360) a filled pixel keeps the alpha the cut removed and takes the image's colour only.
+      const f = fillUnder(b.r, (pieces[i] as Built).r, cutBand(cutMasks[i], cuts[i].overlap), u, underBox(cuts[i].polygon), cuts[i].under_fill);
       // A hidden-art layer (issue #359) is the whole layer's covered art, read by every cut of its part: a cut it holds nothing
       // under fills 0, which the cut line counts, and is not refused as a file made for this one cut would be.
       if (f.filled === 0 && input.cuts[i].under !== undefined) {
@@ -2581,6 +2735,7 @@ export function assemble(input: AssembleInput): AssembleResult {
       if (f !== undefined) {
         c.under = f.filled;
         c.underEmpty = f.empty;
+        if (cuts[i].under_fill === 'colour') c.underFill = 'colour';
       }
       cutCounts.push(c);
     });

package/src/build.ts

@@ -70,7 +70,7 @@ import {
   splitSchedule,
   untestedIntervals,
 } from './autoreplay.ts';
-import { besideIdleLine, FOLD_LINE, type FoldsLine, LEVEL_LINE, type LevelLine, LIMB_LINE, type LimbLine, STRESS_LINE, 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 { 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 { failLine, PartsError, type Problem, refuseIfAny } from './errors.ts';
 import type { MeshQualityReport, MotionSchedule } from 'rig-c/mesh';
@@ -1135,6 +1135,22 @@ export function limbCheckLines(line: LimbLine): string[] {
   ];
 }
 
+/**
+ * The seam over the range (issue #360) as the console prints it: the status, what was posed and the bar, then each
+ * joint at each angle on a line of its own — its status and the seam figures there — or, not read, why.
+ */
+export function sweepCheckLines(line: SweepLine): string[] {
+  const s = line.frame_scale;
+  return [
+    `${SWEEP_LINE}: ${line.status} — ${line.joints.length} joint(s) bent to their declared range's ends and middle${line.physics_left_out === 0 ? '' : `, ${line.physics_left_out} physics constraint(s) left out`}; at each, the pose against the same pose with the joint's own art drawn under the limb, on the rest-pose seam's bar (mean |d| <= ${line.bar.mean.toFixed(1)}, <= ${line.bar.rig_px_over_40} rig px over ${line.bar.level})${s === null ? '' : ` at frame scale ${s}`}`,
+    ...line.joints.flatMap((j) => {
+      const head = `joint "${j.joint}" (${j.limb}, "${j.part}" on "${j.bone}", range [${j.range.join(', ')}]${j.shape === 'disc' ? `, cap_shape "disc": no pixel over ${line.bar.level} in the disc` : ''})`;
+      if (j.unread !== undefined) return [`${head}: FAIL — not read: ${j.unread}`];
+      return j.poses.map((p) => `${head} at ${p.degrees}°: ${p.status} — mean |d| ${p.mean}/255, ${p.px_over_40} frame px over ${line.bar.level} (${p.px_over_80} over ${SEAM_PX_LEVEL_HIGH}), ${p.rig_px_over_40.toFixed(2)} rig px`);
+    }),
+  ];
+}
+
 /** A requirement's line as the console prints it: its name and status, the reason first when NOT MEASURABLE, then its figures as check.json holds them. */
 export function requirementText(name: string, line: RequirementLine): string {
   const rest = Object.entries(line).filter(([k]) => k !== 'status' && k !== 'reason');
@@ -1181,6 +1197,8 @@ export function checkStage(input: CheckStageInput, rigc: RigcRunner, bin: string
   if (stress !== undefined) log(`  ${judgementLine(STRESS_LINE, stress)}`);
   const limbs = fig[LIMB_LINE];
   if (limbs !== undefined) for (const [i, l] of limbCheckLines(limbs).entries()) log(`  ${i === 0 ? '' : '  '}${l}`);
+  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])}`);
   const vsSource = fig[SOURCE_LINE];
   if (vsSource !== undefined) log(`  ${judgementLine(SOURCE_LINE, vsSource)}`);