rig-parts 1.5.1 → 1.5.3

package/README.md

@@ -37,10 +37,10 @@ is taken from the full run, because the twin tails leave the head crop sideways
 (a plan edit). <code>check</code> printed, verbatim:<br/>
 <code>50 assertions: 24 measured (24 passed, 0 failed), 26 skipped, 0 not in profile "spine-html"</code><br/>
 <code>loop: idle 49 frame(s) at 12 fps, f0000 vs f0048 (t = 4s): max |d| 0 (0 required)</code><br/>
-<code>seam: setup pose at 714x1216, scale 0.9422: mean |d| 0.324 (&lt;= 1.0), 2 px over 40 (&lt;= 50), 0 px over 80 (reported)</code><br/>
-<code>pack: skeleton.png 922x1348, 22 region(s), 95.0% covered, padding 2, page edges free, shape polygon</code><br/>
+<code>seam: setup pose at 714x1216, scale 0.9422: mean |d| 0.234 (&lt;= 1.0), 2 px over 40, 2.25 rig px (the count / s²; &lt;= 50), 0 px over 80 (reported)</code><br/>
+<code>pack: skeleton.png 922x1348, 22 region(s), 94.9% covered, padding 2, page edges free, shape polygon</code><br/>
 <code>--seam silhouette</code> repaired the navy blobs the default rule leaves on the white
-blouse (recomposite error pixels 11,050 → 9,540); the default stays
+blouse (recomposite error pixels 10,340 → 8,644); the default stays
 <code>near-white</code>, the reference implementation's rule, so the examples stay
 comparable with it. The loop is <code>rig-parts loop --palette</code>'s indexed APNG, 48 frames at
 12 fps, 1,706,719 bytes, one 256-entry palette at a measured error of max 57, mean 1.601
@@ -60,7 +60,7 @@ made the contact sheet.
 <p align="center"><em>
 The plain fixture, <code>examples/sample</code>: same checkpoint, no LoRA, and a rig
 built from its own proposal with no hand edit at all —
-<code>seam: … mean |d| 0.207 (&lt;= 1.0), 0 px over 40 (&lt;= 50)</code>, loop max |d| 0.
+<code>seam: setup pose at 379x1216, scale 1.0116: mean |d| 0.204 (&lt;= 1.0), 2 px over 40, 1.95 rig px (the count / s²; &lt;= 50), 0 px over 80 (reported)</code>, loop max |d| 0.
 </em></p>
 
 <p align="center"><em>

package/cli.ts

@@ -225,12 +225,17 @@ usage:
       contact.png, motion_heat.png and check.json (with rigc_entry, the rigc
       entry that gated the build, and pack_mode, the two pack flags). PASS needs every gate summary
       "0 failed", the seam (setup pose vs the flat composite of parts/) at mean
-      |d| <= ${SEAM_MEAN_BAR.toFixed(1)} with <= ${SEAM_PX_BAR} px over ${SEAM_PX_LEVEL}, and the loop (idle frame 0 vs the
-      frame at t = duration) at max |d| 0. A failing seam, or any seam under
-      --seam-pairs, is split by the pair of parts each counted pixel lies
-      between: one "seam pair" line each, worst first, with its count, frame
-      and rig boxes and a picture under seam/, and check.json's seam_pairs
-      (AUTHORING §7). --keep-stills leaves the setup-pose still the seam reads,
+      |d| <= ${SEAM_MEAN_BAR.toFixed(1)} with <= ${SEAM_PX_BAR} rig px over ${SEAM_PX_LEVEL} (the frame pixels over ${SEAM_PX_LEVEL}
+      divided by s², s the frame scale the seam: line prints and check.json's
+      seam_frame_scale holds, so the bar means the same at every scale), and
+      the loop (idle frame 0 vs the frame at t = duration) at max |d| 0. A
+      failing seam, or any seam under --seam-pairs, is split by the pair of
+      parts each counted pixel lies between: one "seam pair" line each, worst
+      first, with its count in frame px, frame and rig boxes and a picture
+      under seam/, and check.json's seam_pairs (AUTHORING §7). A seam picture
+      is the setup-pose frame with that pair's counted pixels painted magenta
+      (255, 0, 255) — magenta = a counted pixel — and a cyan (0, 255, 255)
+      box one pixel outside them. --keep-stills leaves the setup-pose still the seam reads,
       rigc's render directory with its frames.json (viewport and background),
       under setup_still/. Then six judgement lines, each in
       check.json and on the console as NAME: PASS|FAIL|SKIP with its figures and
@@ -545,6 +550,39 @@ function printLayerTable(set: LayerSet): void {
   console.log(`  ${warned} WARN line(s)`);
 }
 
+/**
+ * Every flag each command takes: `valued` flags carry a value, `switches` are bare. Each parser reads its row to
+ * decide what it accepts, and {@link notTaken} prints the same row in the unknown-flag refusal, so the refusal
+ * lists exactly the flags the parser accepts (CL26). `layers` takes one positional path and no flag, so it has no row.
+ */
+const TAKES = {
+  sheet: { valued: ['--source', '--layers', '--out', '--cell', '--cols'], switches: [] },
+  rig: { valued: ['--config', '--parts', '--out', '--idle-keys', '--page-edges', '--pack-shape'], switches: [] },
+  propose: { valued: ['--parts', '--source', '--out', '--from-config', '--compare', '--full', '--canvas', '--keypoints', '--person', '--wrist-snap'], switches: ['--head-box'] },
+  compare: { valued: ['--left', '--right', '--map'], switches: [] },
+  check: { valued: ['--rig', '--out', '--parts', '--source', '--page-edges', '--pack-shape', '--requirements'], switches: ['--seam-pairs', '--keep-stills'] },
+  loop: { valued: ['--frames', '--out'], switches: ['--palette'] },
+  assemble: { valued: ['--source', '--full', '--head', '--config', '--out', '--seam', '--project'], 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'], switches: ['--loop'] },
+  compose: { valued: ['--scene', '--out', '--requirements', '--accept'], switches: [] },
+} as const satisfies Record<string, { valued: readonly string[]; switches: readonly string[] }>;
+
+type Command = keyof typeof TAKES;
+
+/** Whether `command` takes `flag` as a valued flag, read off its {@link TAKES} row. */
+function takesValued(command: Command, flag: string): boolean {
+  return (TAKES[command].valued as readonly string[]).includes(flag);
+}
+
+/** The unknown-flag refusal: the flag, and every flag the command's {@link TAKES} row holds, valued then bare. */
+function notTaken(command: Command, flag: string): string {
+  const row = TAKES[command];
+  return `${command} does not take "${flag}"; it takes ${[...row.valued, ...row.switches].join(', ')}`;
+}
+
 function cmdLayers(args: string[]): number {
   if (args.length !== 1) return usage(`layers takes one path; got ${args.length}`);
   try {
@@ -564,7 +602,7 @@ function cmdSheet(args: string[]): number {
   for (let i = 0; i < args.length; i++) {
     const flag = args[i];
     const value = args[i + 1];
-    if (!['--source', '--layers', '--out', '--cell', '--cols'].includes(flag)) return usage(`sheet does not take "${flag}"`);
+    if (!takesValued('sheet', flag)) return usage(notTaken('sheet', flag));
     if (value === undefined) return usage(`${flag} needs a value`);
     i++;
     if (flag === '--source') source = value;
@@ -634,7 +672,7 @@ function cmdRig(args: string[]): number {
   for (let i = 0; i < args.length; i++) {
     const flag = args[i];
     const value = args[i + 1];
-    if (!['--config', '--parts', '--out', '--idle-keys', '--page-edges', '--pack-shape'].includes(flag)) return usage(`rig does not take "${flag}"`);
+    if (!takesValued('rig', flag)) return usage(notTaken('rig', flag));
     if (value === undefined) return usage(`${flag} needs a value`);
     i++;
     if (flag === '--config') config = value;
@@ -694,17 +732,17 @@ function rigcRunner(bin: string): RigcRunner {
   };
 }
 
-function flags(args: string[], known: readonly string[], command: string, optional: readonly string[] = []): Map<string, string> | string {
+/** The command's valued flags as `--flag value` pairs, each one its {@link TAKES} row holds; `required` must all be given. Its bare switches are taken out by the caller before this reads the rest. A string is a usage error. */
+function flags(args: string[], command: Command, required: readonly string[]): Map<string, string> | string {
   const got = new Map<string, string>();
-  const all = [...known, ...optional];
   for (let i = 0; i < args.length; i += 2) {
     const flag = args[i];
-    if (!all.includes(flag)) return `${command} does not take "${flag}"; it takes ${all.join(', ')}`;
+    if (!takesValued(command, flag)) return notTaken(command, flag);
     if (args[i + 1] === undefined) return `${flag} needs a value`;
     if (got.has(flag)) return `${flag} is given twice`;
     got.set(flag, args[i + 1]);
   }
-  for (const k of known) if (!got.has(k)) return `${command} needs ${k} <value>`;
+  for (const k of required) if (!got.has(k)) return `${command} needs ${k} <value>`;
   return got;
 }
 
@@ -716,9 +754,8 @@ function cmdCheck(args: string[]): number {
   if (keepStills > 1) return usage('--keep-stills is given twice');
   const f = flags(
     args.filter((a) => a !== '--seam-pairs' && a !== '--keep-stills'),
-    ['--rig', '--out'],
     'check',
-    ['--parts', '--source', '--page-edges', '--pack-shape', '--requirements'],
+    ['--rig', '--out'],
   );
   if (typeof f === 'string') return usage(f);
   const rig = f.get('--rig') as string;
@@ -768,14 +805,13 @@ function printLint(P: PartSet, spec: { bones: CharacterConfig['bones']; meshes:
 function cmdPropose(args: string[]): number {
   const flags = new Map<string, string>();
   let headBox = false;
-  const valued = ['--parts', '--source', '--out', '--from-config', '--compare', '--full', '--canvas', '--keypoints', '--person', '--wrist-snap'];
   for (let i = 0; i < args.length; i++) {
     const flag = args[i];
     if (flag === '--head-box') {
       headBox = true;
       continue;
     }
-    if (!valued.includes(flag)) return usage(`propose does not take "${flag}"; it takes --head-box and ${valued.join(', ')}`);
+    if (!takesValued('propose', flag)) return usage(notTaken('propose', flag));
     const value = args[i + 1];
     if (value === undefined) return usage(`${flag} needs a value`);
     if (flags.has(flag)) return usage(`${flag} is given twice`);
@@ -873,10 +909,9 @@ function cmdPropose(args: string[]): number {
 
 function cmdCompare(args: string[]): number {
   const flags = new Map<string, string>();
-  const valued = ['--left', '--right', '--map'];
   for (let i = 0; i < args.length; i++) {
     const flag = args[i];
-    if (!valued.includes(flag)) return usage(`compare does not take "${flag}"; it takes ${valued.join(', ')}`);
+    if (!takesValued('compare', flag)) return usage(notTaken('compare', flag));
     const value = args[i + 1];
     if (value === undefined) return usage(`${flag} needs a value`);
     if (flags.has(flag)) return usage(`${flag} is given twice`);
@@ -905,8 +940,8 @@ function cmdLoop(args: string[]): number {
   if (palettes > 1) return usage('--palette is given twice');
   const f = flags(
     args.filter((a) => a !== '--palette'),
-    ['--frames', '--out'],
     'loop',
+    ['--frames', '--out'],
   );
   if (typeof f === 'string') return usage(f);
   const out = f.get('--out') as string;
@@ -925,14 +960,13 @@ function cmdLoop(args: string[]): number {
 function cmdAssemble(args: string[]): number {
   const flags = new Map<string, string>();
   let propose = false;
-  const valued = ['--source', '--full', '--head', '--config', '--out', '--seam', '--project'];
   for (let i = 0; i < args.length; i++) {
     const flag = args[i];
     if (flag === '--propose-plan') {
       propose = true;
       continue;
     }
-    if (!valued.includes(flag)) return usage(`assemble does not take "${flag}"`);
+    if (!takesValued('assemble', flag)) return usage(notTaken('assemble', flag));
     const value = args[i + 1];
     if (value === undefined) return usage(`${flag} needs a value`);
     if (flags.has(flag)) return usage(`${flag} is given twice`);
@@ -968,8 +1002,9 @@ function cmdAssemble(args: string[]): number {
   }
 }
 
-/** Parse `--flag value` pairs and bare `--switch`es; a string is a usage error. */
-function comfyFlags(args: string[], valued: readonly string[], switches: readonly string[], command: string): { v: Map<string, string>; on: Set<string> } | string {
+/** Parse `--flag value` pairs and bare `--switch`es, as the command's {@link TAKES} row names them; a string is a usage error. */
+function comfyFlags(args: string[], command: 'comfy seethrough' | 'comfy paint'): { v: Map<string, string>; on: Set<string> } | string {
+  const switches: readonly string[] = TAKES[command].switches;
   const v = new Map<string, string>();
   const on = new Set<string>();
   for (let i = 0; i < args.length; i++) {
@@ -979,7 +1014,7 @@ function comfyFlags(args: string[], valued: readonly string[], switches: readonl
       on.add(flag);
       continue;
     }
-    if (!valued.includes(flag)) return `${command} does not take "${flag}"; it takes ${[...valued, ...switches].join(', ')}`;
+    if (!takesValued(command, flag)) return notTaken(command, flag);
     const value = args[i + 1];
     if (value === undefined) return `${flag} needs a value`;
     if (v.has(flag)) return `${flag} is given twice`;
@@ -1005,14 +1040,10 @@ function secondsFlag(v: Map<string, string>, flag: string, fallback: number): nu
   return Number.isFinite(n) && n > 0 ? n : `${flag} ${raw} is not a number of seconds above 0`;
 }
 
-const COMFY_TIMING = ['--host', '--wait', '--timeout', '--poll'] as const;
-
 async function cmdComfy(args: string[]): Promise<number> {
   const [sub, ...rest] = args;
   if (sub !== 'seethrough' && sub !== 'paint') return usage(`comfy takes seethrough or paint; got ${sub === undefined ? 'nothing' : `"${sub}"`}`);
-  const valued = sub === 'seethrough' ? ['--image', '--out', '--resolution', '--steps', '--seed', '--prefix', ...COMFY_TIMING] : ['--config', '--out', '--seeds', '--seed0', ...COMFY_TIMING];
-  const switches = sub === 'seethrough' ? ['--offload', '--lama', '--nf4'] : [];
-  const f = comfyFlags(rest, valued, switches, `comfy ${sub}`);
+  const f = comfyFlags(rest, `comfy ${sub}`);
   if (typeof f === 'string') return usage(f);
   const { v, on } = f;
   const wait = secondsFlag(v, '--wait', 1800);
@@ -1075,7 +1106,7 @@ async function cmdComfy(args: string[]): Promise<number> {
 }
 
 function cmdInputs(args: string[]): number {
-  const f = flags(args, ['--source', '--config', '--out'], 'inputs');
+  const f = flags(args, 'inputs', ['--source', '--config', '--out']);
   if (typeof f === 'string') return usage(f);
   const source = f.get('--source') as string;
   const out = f.get('--out') as string;
@@ -1107,7 +1138,6 @@ function cmdInputs(args: string[]): number {
 function cmdBuild(args: string[]): number {
   const flags = new Map<string, string>();
   let loop = false;
-  const valued = ['--config', '--source', '--full', '--head', '--out', '--seam', '--project', '--page-edges', '--pack-shape', '--requirements', '--idle-keys'];
   for (let i = 0; i < args.length; i++) {
     const flag = args[i];
     if (flag === '--loop') {
@@ -1115,7 +1145,7 @@ function cmdBuild(args: string[]): number {
       loop = true;
       continue;
     }
-    if (!valued.includes(flag)) return usage(`build does not take "${flag}"; it takes --loop and ${valued.join(', ')}`);
+    if (!takesValued('build', flag)) return usage(notTaken('build', flag));
     const value = args[i + 1];
     if (value === undefined) return usage(`${flag} needs a value`);
     if (flags.has(flag)) return usage(`${flag} is given twice`);
@@ -1154,7 +1184,7 @@ function cmdBuild(args: string[]): number {
 }
 
 function cmdCompose(args: string[]): number {
-  const f = flags(args, ['--scene', '--out'], 'compose', ['--requirements', '--accept']);
+  const f = flags(args, 'compose', ['--scene', '--out']);
   if (typeof f === 'string') return usage(f);
   let bin: string;
   try {

package/docs/AUTHORING.md

@@ -1230,8 +1230,10 @@ names it — `[29]` on both examples.
 flat stack of parts differs from the painting by more than 60, the top part takes the
 painting's colour — except where the painting is near-white, which protects the page
 and also every white garment. `--seam silhouette` protects near-white pixels only
-outside the figure. On the demo it lowered recomposite error pixels from 11,050 to
-9,540 and changed no check bar; on the sample it changed nothing. The default stays
+outside the figure. On the demo it lowers recomposite error pixels from 10,340 to
+8,644 (`assemble`'s `error px > 40`, at v1.5.2); on the sample it changes nothing
+(4,359 under both). At v0.14.0 the demo's were 11,050 and 9,540, and no check bar
+changed. The default stays
 the reference's so the examples stay comparable with it.
 
 **The fringe push-back** (issue #119; under either seam rule, no flag). Both places
@@ -1253,9 +1255,9 @@ and a cleared bridge to opaque art is put back, so no part gains an island
 names them. On the examples (default flags, measured against the v0.14.0 build of
 the same inputs): `demo` 1,193 px over 16 parts, recomposite error pixels 11,050 →
 10,340; `sample` 276 px over 15 parts, 4,512 → 4,359; uncovered error pixels and
-holes unchanged on both, `check` 9 of 9 on both. The `--seam` and `--project`
-comparisons in this section and the `SETUP_POSE_VS_SOURCE` example figures in §7
-were measured before it, at v0.14.0.
+holes unchanged on both, `check` 9 of 9 on both. The `--project` comparison in
+this section and the `SETUP_POSE_VS_SOURCE` example figures in §7 were measured
+before it, at v0.14.0; the `--seam` figures above are v1.5.2's.
 
 **Page edges.** `rig`, `check` and `build` pack through `rigc build --pack
 --page-edges <v>`, and hand the value to rigc verbatim. The default is `free`,
@@ -1685,7 +1687,7 @@ See-through with another seed.
 | `CHECK_RIGC_GREEN` | a rigc step failed; its line is quoted | as `RIG_RIGC_GREEN` |
 | `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 |
 | `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 |
-| `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): 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` |
+| `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` |
 | `CHECK_BREATH_VISIBLE` | the torso (`topwear`), rendered alone, barely moves over the idle — 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) |
 | `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 |
 | `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 | that chain track's `phase`/`lag` (a positive `lag`, a child `phase` above its parent's) or its `amps` (non-decreasing toward the tip) |
@@ -1753,7 +1755,19 @@ assemble*, at the end of this section):
   `A49_PACKED_FOOTPRINTS_DO_NOT_OVERLAP` on the packed pass, 16 not in `spine`; `CH09`
   holds it on every fetched example);
 - **seam**: the setup-pose render against the flat composite of `parts/`: mean
-  max-channel |d| ≤ 1.0 of 255, and at most 50 pixels over 40. The bar reads one
+  max-channel |d| ≤ 1.0 of 255, and at most 50 **rig** pixels over 40 — the
+  frame pixels over 40 divided by s², `s` the frame scale the `seam:` line
+  prints and `check.json`'s `seam_frame_scale` holds (issue #216). The frame
+  holds s² pixels per rig pixel, so a stack that parts from the render over a
+  fixed area of the rig reads s² times as many frame pixels: on the public
+  `sample` a part moved 2 rig px read 400, 891 and 1,560 frame px over 40 at
+  s = 1.0, 1.5 and 2.0, and 400, 396 and 390 rig px; the sample as built read
+  3, 3 and 7 frame px [measured, issue #216]. Divided by s² the bar reads the
+  same rig at every scale, and at s = 1 it is the reference's count. The mean
+  is a share of the frame and needs no such division (0.242, 0.188 and 0.226 on
+  the sample as built; 0.353, 0.305 and 0.340 with the part moved).
+  `seam_px_over_40` and `seam_px_over_80` stay frame pixels, and so does each
+  pair's count below. The bar reads one
   frame, the setup-pose still, never the idle. When it fails (or when `check
   --seam-pairs` asks, pass or fail), the pixels over 40 are split by the pair of
   parts that answers for each (issue #202): the two parts drawn last among those
@@ -1761,7 +1775,8 @@ assemble*, at the end of this section):
   sample reads for that frame pixel, lower first, `(no art)` standing in where
   fewer than two do. Each pair is a console line `seam pair <i> of <n>: "<a>" /
   "<b>" at the setup pose: <count> px over 40 (<count> over 80), frame box x
-  <x0>..<x1>, y <y0>..<y1>, rig box …, picture seam/<i>_<a>_<b>.png`, worst first,
+  <x0>..<x1>, y <y0>..<y1>, rig box …, picture seam/<i>_<a>_<b>.png` (in the
+  picture, **magenta = a counted pixel**, cyan = the box round them), worst first,
   and a row of `check.json`'s `seam_pairs` (`parts`, `px_over_40`, `px_over_80`,
   `frame_box` in frame pixels, `rig_box` in the rig pixels of `parts.json` and
   `cuts[].polygon`, `picture`); `CHECK_SEAM_WITHIN_BAR`'s line quotes the worst.

package/docs/STABILITY.md

@@ -158,7 +158,7 @@ every number) are AUTHORING §3's tables, and the loader refuses any other by na
 | `parts.json`, `parts/<name>.png` | `assemble`, `build` | one record per part: `from`, the box `x`, `y`, `w`, `h` (rig px), the pixel counts `src/parts.ts` documents (`opaque_px`, `visible_px`, `occluded_px`, `projected_core_px`, `source_px_taken`, `visible_not_projected_px`, `refused_drift_px`, `merged_px`, `seam_override_px`, and `fringe_pushed_back` when not empty); `rig_size`, `scale_rig_per_source`, `ghost_px`, `recomposite` |
 | `rig/rig.json`, `rig/motion.json`, `rig/images/` | `rig`, `build`, `compose` | rig-c's rig spec and motion spec, `spec` `rigc-rig/1` and `rigc-motion/1`: the format is rig-c's, and this package writes only what rig-c's parser accepts |
 | `rig/mesh_report.json` | `rig`, `build` | one row per mesh: `part`, `vertices`, `triangles`, `hull`, `bones`, `max_influences`, `mean_influences`, `art_coverage`, then `grid` (a lattice); `mode` "contour" with `params`, `contour`, `regions`; or `mode` "auto" with `settings`, `source`, `result`, `residuals`, `worst_residual`, `worst_region`, `motion_amplitude`, `termination`, `weights`, `regions`, `deformation`, `quality_report` (rig-c's `mesh-quality-report/1` document whole), `motion_report`, and, only when they apply, `stray_cleared` (after `source`, when `source.stray` is declared), `skinning_residual` and `replay` (`AutoMeshReport` in `src/rig.ts`); in every mode, `exponent` when the mesh declares one (after `grid`, or after `mode`); `ribs` when a contour or auto mesh declares them (after `exponent`, or after `mode`), and then `contour.ribs` (`source.contour.ribs` in the automatic mode) |
-| `check/check.json` and the rest of `check/` | `check`, `build`, `compose` | the reference's fields in its order (`gate_spine_html_green`, `rigc_entry`, `pack_mode`, `loop_max_diff`, the seam figures), `loop_physics` after `loop_max_diff` when the rig declares a physics constraint, `seam_pairs` after the seam figures when the seam bar fails or `--seam-pairs` asks (each row's picture under `check/seam/`; `--keep-stills` leaves the setup-pose still and its `frames.json` under `check/setup_still/`), then the judgement lines (`BREATH_VISIBLE`, `BLINK_NO_HOLE`, `CHAIN_LAG`, `TIP_OVER_ROOT`, `STILL_REGIONS_DARK`, `TEXTURE_STRETCH`), `RECOMPOSITE_HOLES`, `SETUP_POSE_VS_SOURCE`, `skipped`, a `requirements` block under `--requirements`, and `PASS`; `check/build/skeleton.json`, `.atlas` and `.png` are the packed artifact rig-c writes |
+| `check/check.json` and the rest of `check/` | `check`, `build`, `compose` | the reference's fields in its order (`gate_spine_html_green`, `rigc_entry`, `pack_mode`, `loop_max_diff`, the seam figures — `seam_mean`, `seam_px_over_40`, `seam_px_over_80` and, from issue #216, `seam_frame_scale`, the frame scale the bar divides the count by), `loop_physics` after `loop_max_diff` when the rig declares a physics constraint, `seam_pairs` after the seam figures when the seam bar fails or `--seam-pairs` asks (each row's picture under `check/seam/`; `--keep-stills` leaves the setup-pose still and its `frames.json` under `check/setup_still/`), then the judgement lines (`BREATH_VISIBLE`, `BLINK_NO_HOLE`, `CHAIN_LAG`, `TIP_OVER_ROOT`, `STILL_REGIONS_DARK`, `TEXTURE_STRETCH`), `RECOMPOSITE_HOLES`, `SETUP_POSE_VS_SOURCE`, `skipped`, a `requirements` block under `--requirements`, and `PASS`; `check/build/skeleton.json`, `.atlas` and `.png` are the packed artifact rig-c writes |
 | `proposal.json`, `render/landmarks*.png` | `propose` | the config's four rig sections and `notes` |
 | `basis.json` | `propose` | spec `spine-parts-basis/1` |
 | the scene report | `compose` | spec `spine-parts-scene-report/1` |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rig-parts",
-  "version": "1.5.1",
+  "version": "1.5.3",
   "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/skills/rig-parts/SKILL.md

@@ -125,7 +125,7 @@ it and the order as `scene.json` records it (AUTHORING §7, *Composing several
 characters*).
 
 `--seam silhouette` repairs more of the seam on white garments than the default
-`near-white` (the demo: 11,050 → 9,540 recomposite error pixels); the default is
+`near-white` (the demo: 10,340 → 8,644 recomposite error pixels); the default is
 the reference implementation's rule. `--project visible` lets thin visible parts
 (lashes, brows, irises) take the painting's pixels, which the default `core` rule
 erodes away. Name both rules you used in your report, and quote the assemble

package/src/build.ts

@@ -70,7 +70,7 @@ import {
   splitSchedule,
   untestedIntervals,
 } from './autoreplay.ts';
-import { BARS, besideIdleLine, causeLines, REQUIREMENTS_DIR, type CheckReport, type PackLine, DEFAULT_PACK_SHAPE, DEFAULT_PAGE_EDGES, JUDGEMENT_LINES, type JudgementLine, packedBuildArgs, packedBuildLabel, type PackMode, type PackShape, type PageEdges, readFrameSet, REPORTED_LINES, type ReportedLine, type RigcRunner, runCheck, SEAM_DIR, SEAM_MEAN_BAR, seamPairText, SOURCE_LINE, SEAM_PX_BAR, SEAM_PX_LEVEL, SEAM_PX_LEVEL_HIGH, SPINEBOY_YARDSTICK, STILL_DIR } from './check.ts';
+import { BARS, besideIdleLine, causeLines, REQUIREMENTS_DIR, type CheckReport, type PackLine, DEFAULT_PACK_SHAPE, DEFAULT_PAGE_EDGES, JUDGEMENT_LINES, type JudgementLine, packedBuildArgs, packedBuildLabel, type PackMode, type PackShape, type PageEdges, readFrameSet, 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, loadConfig, loadConfigAndAnimations, loadEarlyConfig } from './config.ts';
 import { PartsError, type Problem, problemLine, refuseIfAny } from './errors.ts';
 import type { MeshQualityReport, MotionSchedule } from 'rig-c/mesh';
@@ -981,7 +981,7 @@ export function checkStage(input: CheckStageInput, rigc: RigcRunner, bin: string
   else {
     log(
       `  seam: setup pose at ${r.seamViewport.pixelWidth}x${r.seamViewport.pixelHeight}, scale ${r.seamViewport.scale.toFixed(4)}: mean |d| ${fig.seam_mean} (<= ${SEAM_MEAN_BAR.toFixed(1)}), ` +
-        `${fig.seam_px_over_40} px over ${SEAM_PX_LEVEL} (<= ${SEAM_PX_BAR}), ${fig.seam_px_over_80} px over ${SEAM_PX_LEVEL_HIGH} (reported)`,
+        `${fig.seam_px_over_40} px over ${SEAM_PX_LEVEL}, ${fig.seam_frame_scale === null || fig.seam_px_over_40 === null ? '' : seamRigPxText(fig.seam_px_over_40, fig.seam_frame_scale)} rig px (the count / s²; <= ${SEAM_PX_BAR}), ${fig.seam_px_over_80} px over ${SEAM_PX_LEVEL_HIGH} (reported)`,
     );
     const pairs = fig.seam_pairs ?? [];
     pairs.forEach((row, i) => log(`  seam pair ${i + 1} of ${pairs.length}: ${seamPairText(row)}`));

package/src/check.ts

@@ -153,7 +153,17 @@ import { type ScaleTranslate, warpAffine } from './raster/warp.ts';
 
 /** Seam: mean max-channel |d| over the frame, in levels of 255, at most this. */
 export const SEAM_MEAN_BAR = 1.0;
-/** Seam: pixels whose max-channel |d| exceeds {@link SEAM_PX_LEVEL}, at most this many. */
+/**
+ * Seam: pixels whose max-channel |d| exceeds {@link SEAM_PX_LEVEL}, at most
+ * this many **rig** pixels — the frame count divided by s², s the frame scale
+ * the setup-pose still renders at (issue #216). The frame holds s² pixels per
+ * rig pixel, so a stack that parts from the render over a fixed area of the
+ * rig reads s² times as many frame pixels: on the public sample a part moved
+ * 2 rig px read 400, 891 and 1,560 frame px over 40 at s = 1.0, 1.5 and 2.0,
+ * and 400, 396 and 390 divided by s²; the uncut sample 3, 3 and 7 frame px
+ * [measured for issue #216, a scratch run, not tracked]. At s = 1 the bar is
+ * the reference's frame count.
+ */
 export const SEAM_PX_BAR = 50;
 export const SEAM_PX_LEVEL = 40;
 /** Seam: the second, reported-only level. */
@@ -1372,9 +1382,29 @@ function round3(x: number): number {
   return Number(x.toFixed(3));
 }
 
-/** The seam bar, on the figures as check.json writes them: the mean (rounded to three places) over {@link SEAM_MEAN_BAR}, or more than {@link SEAM_PX_BAR} pixels over {@link SEAM_PX_LEVEL}. */
-function seamFails(mean: number, over40: number): boolean {
-  return mean > SEAM_MEAN_BAR || over40 > SEAM_PX_BAR;
+/** Python's `round(x, 6)` for the frame scale written: to six places, on the value's exact decimal expansion. */
+function round6(x: number): number {
+  return Number(x.toFixed(6));
+}
+
+/** The seam's count in rig pixels (issue #216): the frame pixels over {@link SEAM_PX_LEVEL} divided by the square of the frame scale. */
+export function seamRigPx(over40: number, scale: number): number {
+  return over40 / (scale * scale);
+}
+
+/** {@link seamRigPx} as the console and the refusal print it, to two places. */
+export function seamRigPxText(over40: number, scale: number): string {
+  return seamRigPx(over40, scale).toFixed(2);
+}
+
+/**
+ * The seam bar, on the figures as check.json writes them: the mean (rounded
+ * to three places) over {@link SEAM_MEAN_BAR}, or more than
+ * {@link SEAM_PX_BAR} rig pixels over {@link SEAM_PX_LEVEL} — the frame count
+ * over the square of the written frame scale (issue #216).
+ */
+function seamFails(mean: number, over40: number, scale: number): boolean {
+  return mean > SEAM_MEAN_BAR || seamRigPx(over40, scale) > SEAM_PX_BAR;
 }
 
 /** A seam row as the console prints it: the pair, the frame, the counts, both boxes and the picture. */
@@ -1536,10 +1566,16 @@ export interface CheckFigures {
    * read from. Reported, not judged; a rig without one writes the keys it always wrote.
    */
   loop_physics?: LoopPhysics[];
-  /** The three seam figures: null when there is no parts.json (issue #77); `skipped.seam` then says why. */
+  /** The seam figures: null when there is no parts.json (issue #77); `skipped.seam` then says why. The two counts are frame pixels. */
   seam_mean: number | null;
   seam_px_over_40: number | null;
   seam_px_over_80: number | null;
+  /**
+   * The frame scale s the setup-pose still rendered at (rigc's viewport
+   * scale, to six places), issue #216: the seam bar reads `seam_px_over_40`
+   * divided by its square ({@link seamRigPx}). Null with the other three.
+   */
+  seam_frame_scale: number | null;
   /**
    * Written only when the seam bar fails, or when it was asked for (`check
    * --seam-pairs`), issue #202: the counted pixels split by the pair of parts
@@ -1600,7 +1636,9 @@ export function barsNotMet(fig: Readonly<Record<string, unknown>>): string[] {
   const out: string[] = [];
   if (fig.gate_spine_html_green !== true) out.push('gate');
   if (typeof fig.loop_max_diff === 'number' && fig.loop_max_diff !== LOOP_MAX_BAR) out.push('loop');
-  if (typeof fig.seam_mean === 'number' && typeof fig.seam_px_over_40 === 'number' && seamFails(fig.seam_mean, fig.seam_px_over_40)) out.push('seam');
+  // 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');
   for (const n of JUDGEMENT_LINES) {
     const l = fig[n];
     if (typeof l === 'object' && l !== null && (l as { status?: unknown }).status === 'FAIL') out.push(n);
@@ -1895,7 +1933,7 @@ export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, parts
       if (inp.parts !== null) {
         const composite = flatComposite(inp.parts, inp.partsDir, stillSet.background);
         seam = seamFigures(composite, stillSet.frames[0].image, inp.stage, stillSet.viewport, stillSet.background);
-        if (seamPairsAsked || seamFails(round3(seam.mean), seam.over40)) {
+        if (seamPairsAsked || seamFails(round3(seam.mean), seam.over40, round6(stillSet.viewport.scale))) {
           const placed = inp.parts.parts.map((p) => ({ name: p.name, from: p.from, x: p.x, y: p.y, image: readPng(join(inp.partsDir, `${p.name}.png`)) }));
           const split = seamPairRows(seam, placed, inp.parts.rig_size, stillSet.viewport);
           mkdirSync(seamDir, { recursive: true });
@@ -1955,6 +1993,7 @@ export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, parts
     seam_mean: seam === null ? null : round3(seam.mean),
     seam_px_over_40: seam === null ? null : seam.over40,
     seam_px_over_80: seam === null ? null : seam.over80,
+    seam_frame_scale: seam === null || seamViewport === null ? null : round6(seamViewport.scale),
     ...(seamPairs === null ? {} : { seam_pairs: seamPairs }),
     BREATH_VISIBLE: breath,
     BLINK_NO_HOLE: blink,
@@ -1978,13 +2017,13 @@ export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, parts
       detail: `max |d| ${loop.max}/255, first at pixel ${loop.x},${loop.y} of ${loopSet.viewport.pixelWidth}x${loopSet.viewport.pixelHeight}; ${LOOP_MAX_BAR} is required — the idle's last key must equal its first`,
     });
   }
-  if (figures.seam_mean !== null && figures.seam_px_over_40 !== null && seamFails(figures.seam_mean, figures.seam_px_over_40)) {
+  if (figures.seam_mean !== null && figures.seam_px_over_40 !== null && figures.seam_frame_scale !== null && seamFails(figures.seam_mean, figures.seam_px_over_40, figures.seam_frame_scale)) {
     const worst = seamPairs === null || seamPairs.length === 0 ? null : seamPairs[0];
     barProblems.push({
       code: 'CHECK_SEAM_WITHIN_BAR',
       object: 'the setup-pose render vs the flat composite of parts/',
       detail:
-        `mean |d| ${figures.seam_mean}/255 and ${figures.seam_px_over_40} px over ${SEAM_PX_LEVEL} (${figures.seam_px_over_80} over ${SEAM_PX_LEVEL_HIGH}); mean <= ${SEAM_MEAN_BAR.toFixed(1)} and <= ${SEAM_PX_BAR} px over ${SEAM_PX_LEVEL} are required` +
+        `mean |d| ${figures.seam_mean}/255 and ${figures.seam_px_over_40} frame px over ${SEAM_PX_LEVEL} (${figures.seam_px_over_80} over ${SEAM_PX_LEVEL_HIGH}) at frame scale ${figures.seam_frame_scale}, ${seamRigPxText(figures.seam_px_over_40, figures.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 ${(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`),