spine-parts 0.5.0 → 0.7.0

package/NOTICE.md

@@ -60,10 +60,15 @@ from them beyond the layers See-through itself writes for the user's own image.
 ## 2. Spine Runtimes, through spine-rigc
 
 spine-parts depends on [`spine-rigc`](https://www.npmjs.com/package/spine-rigc)
-(MIT, same author), which compiles and validates Spine skeleton data and links
-`@esotericsoftware/spine-core`, part of the
+(MIT, same author), which compiles and validates Spine skeleton data. Its round
+trip runs through `@esotericsoftware/spine-core`, part of the
 [Spine Runtimes](https://github.com/EsotericSoftware/spine-runtimes), under the
 [Spine Runtimes License Agreement](https://esotericsoftware.com/spine-runtimes-license).
+Since spine-rigc 2.0 neither package installs the runtime: spine-rigc carries it
+only as a development dependency, and an install of spine-rigc gates a build with
+its own validator. spine-parts does not install it either; it is this repository's
+development dependency, at the version spine-rigc develops against, for the round
+trip in the selftest and CI and the selftest's posing oracle.
 spine-rigc's [NOTICE.md](https://github.com/firejune/rigc/blob/main/NOTICE.md)
 sets out the chain in full; briefly, as a restatement of Esoteric Software's
 terms and not a term of this project:
@@ -73,8 +78,11 @@ terms and not a term of this project:
 2. Playing Spine skeleton data in a product requires a Spine Runtime, and the
    Spine Runtimes License requires **each user of such a product to own a
    Spine Editor license**.
-3. spine-rigc links `spine-core`, and spine-parts depends on spine-rigc, so the
-   same obligation applies to running the stages of spine-parts that call it.
+3. spine-rigc no longer installs `spine-core`, and spine-parts does not either;
+   the obligation in 2 attaches to the Spine skeleton data spine-rigc writes,
+   which the stages of spine-parts that call it produce, and to `spine-core`
+   wherever it is installed beside them — this repository's development
+   dependency included.
 
 spine-parts also imports spine-rigc's own modules directly, by deep path: its PNG codec
 (`tools/plate.ts`, `src/png.ts`), its 5x7 label font (`tools/font5x7.ts`) and
@@ -114,10 +122,13 @@ function's comment says which call it stands in for and what was measured.
 | Package | Licence | Why |
 | --- | --- | --- |
 | [`spine-rigc`](https://www.npmjs.com/package/spine-rigc) | MIT | compile, gate, render and check; its PNG codec, font and coordinate conversion |
-| ↳ [`@esotericsoftware/spine-core`](https://www.npmjs.com/package/@esotericsoftware/spine-core) | Spine Runtimes License | spine-rigc's round trip (section 2) |
 | [`ag-psd`](https://www.npmjs.com/package/ag-psd) | MIT | reading an upstream See-through `.psd` |
 | ↳ [`pako`](https://www.npmjs.com/package/pako) | MIT AND Zlib | ag-psd's deflate |
 | ↳ [`base64-js`](https://www.npmjs.com/package/base64-js) | MIT | ag-psd's base64 |
 
 Development only, not installed with the package: `typescript` (Apache-2.0),
-`eslint` (MIT), `typescript-eslint` (MIT), `@types/bun` (MIT).
+`eslint` (MIT), `typescript-eslint` (MIT), `@types/bun` (MIT), and
+[`@esotericsoftware/spine-core`](https://www.npmjs.com/package/@esotericsoftware/spine-core)
+(Spine Runtimes License; section 2), pinned to the version spine-rigc develops
+against (`TY10`): the round trip in the selftest and CI, the selftest's posing
+oracle, and `tools/atlas_population.ts` and `tools/idle_cost.ts`.

package/README.md

@@ -35,17 +35,16 @@ was shifted down into the canvas (its proposal ran 118 px above the top edge;
 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>49 assertions: 23 measured (23 passed, 0 failed), 26 skipped, 0 not in profile "spine-html"</code><br/>
-<code>49 assertions: 14 measured (14 passed, 0 failed), 20 skipped, 15 not in profile "spine"</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 1024x2048, 22 region(s), 56.3% covered, padding 2</code><br/>
+<code>pack: skeleton.png 967x1338, 22 region(s), 91.2% covered, padding 2, page edges free</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
 <code>near-white</code>, the reference implementation's rule, so the examples stay
 comparable with it. The loop is <code>spine-parts loop --palette</code>'s indexed APNG, 48 frames at
-12 fps, 1,706,785 bytes, one 256-entry palette at a measured error of max 57, mean 1.601
+12 fps, 1,706,520 bytes, one 256-entry palette at a measured error of max 57, mean 1.601
 per channel over every frame (the lossless APNG beside it, the exactness record, is
-13,645,519 bytes; the GIF, at the same error, 1,812,625). Frame 29 (2.417 s) is the
+13,645,350 bytes; the GIF, at the same error, 1,812,238). Frame 29 (2.417 s) is the
 closed eye: the blink holds for 0.084 s, one 12 fps frame rounded up, where the
 reference implementation held 0.04 s and no frame of its loop showed the eyes shut
 (issue #32); the painting is shown at half size, resampled and written
@@ -87,7 +86,7 @@ page** (issue #2):
 
 | path under `--out` | what |
 | --- | --- |
-| `check/build/skeleton.json`, `skeleton.atlas`, `skeleton.png` | **the artifact** — Spine 4.3 skeleton data and one packed page, written by `rigc build --pack` and gated under both profiles |
+| `check/build/skeleton.json`, `skeleton.atlas`, `skeleton.png` | **the artifact** — Spine 4.3 skeleton data and one packed page, written by `rigc build --pack --page-edges free` and gated under `spine-html`, which holds every rule `spine` measures (on the demo, rigc 1.5.1 and 2.0.3: the 14 rules `validate --profile spine` measures are among the build's 23; 15 are not in `spine`) |
 | `parts/*.png`, `parts.json`, `recomposite_rig.png`, `recomposite_error_rig.png` | the loose parts, each cropped to its alpha box; the record of where every part came from, how many of its pixels were re-taken from the painting, and the recomposite's uncovered holes with their boxes; the flat stack of parts; its error map — red where no part covers a pixel the painting has, blue where a part covers it in the wrong colour |
 | `rig/` | `rig.json` and `motion.json` in spine-rigc's spec, `mesh_report.json`, the padded `images/` |
 | `check/` | both gate files verbatim, the idle's frames and their `geometry.json` (skinned vertices per frame), `contact.png`, `motion_heat.png`, `check.json` |
@@ -99,12 +98,23 @@ artifact paths — here for `examples/sample`:
 
 ```
 build: PASS — the packed atlas is the artifact; parts/ and rig/ are the intermediates it was made from
-  pack: skeleton.png 512x2048, 20 region(s), 49.7% covered, padding 2; page opaque 28.7% (alpha > 0) — spineboy yardstick 1024x256, 40 region(s), 45.8% opaque (alpha > 0), a reference and not a bar
+  pack: skeleton.png 479x1166, 20 region(s), 93.4% covered, padding 2, page edges free; page opaque 53.9% (alpha > 0) — spineboy yardstick 1024x256, 40 region(s), 45.8% opaque (alpha > 0), a reference and not a bar
   out/check/build/skeleton.json
   out/check/build/skeleton.atlas
   out/check/build/skeleton.png
 ```
 
+The page's edges are free by default: rigc picks the least-area page the parts need,
+not the next power of two. On the two examples that is 967x1338 and 479x1166, where a
+power-of-two page is 1024x2048 and 512x2048, and covered goes from 56.3 % to 91.2 % and
+from 49.7 % to 93.4 %. The cost is the one rigc's help states: *"region attachments
+sampling within 1 LSB of the loose build rather than exactly"*. Measured on both
+examples, every idle frame stays within 1 level of the power-of-two build's. The atlas says
+`filter: Linear, Linear` and has no `repeat` line, so `--page-edges pot` is for a
+consumer that mipmaps or repeats the page; it writes exactly the page builds wrote
+before the flag existed. The measurements are in
+[AUTHORING §5, *Page edges*](docs/AUTHORING.md#5-after-each-stage-what-to-read).
+
 The packer is spine-rigc's, and no other: a packed region is a lossless copy, and an
 atlas written by anything else would have no oracle behind it.
 
@@ -113,7 +123,7 @@ atlas written by anything else would have no oracle behind it.
 | stage | tool | what it owns |
 | --- | --- | --- |
 | painting + See-through layers → parts and specs | **spine-parts** | the merge of two runs, the measurements, the rig spec and motion spec |
-| specs → Spine skeleton data | **[spine-rigc](https://github.com/firejune/rigc)** | compile, the round trip through `spine-core`, the named assertions, the packer, the renderer |
+| specs → Spine skeleton data | **[spine-rigc](https://github.com/firejune/rigc)** | compile, the gate (rigc's own validator in an install; the round trip through `spine-core` where the runtime is beside it, as in this repository's CI), the named assertions, the packer, the renderer |
 | skeleton data → a page | **[spine-html](https://github.com/firejune/spine-html)**, a sibling project | a DOM renderer; rigc's `spine-html` profile is its policy, and every build here is gated under that profile as well as under `spine` |
 
 spine-parts never writes Spine data itself. Everything on disk under `check/build/`
@@ -242,8 +252,8 @@ agent skill.
 | `propose --head-box --full <run> --canvas WxH` | propose `seethrough.head_box` from the full run, held inside the painting |
 | `propose --parts --source --out [--compare <config>]` | propose bones, meshes, regions and an idle; draw the overlay |
 | `propose … --from-config <config>` | draw and LINT the config's current bones |
-| `rig --config --parts --out [--idle-keys ctl\|direct]` | author `rig.json` + `motion.json`, written only after spine-rigc's round trip is green; `--idle-keys` says whether the idle's keys on mesh-driving bones go through `<bone>_ctl` parents (default) or stay on the bones with `invariants.idleDrivesMeshes` declared |
-| `check --rig --out [--parts]` | build packed, gate under both profiles, render the idle, measure seam, loop and the six judgement lines (mesh texture stretch among them, from the idle's `render --geometry`), and report the recomposite's holes from `parts.json` |
+| `rig --config --parts --out [--idle-keys ctl\|direct]` | author `rig.json` + `motion.json`, written only after spine-rigc's gate is green; `--idle-keys` says whether the idle's keys on mesh-driving bones go through `<bone>_ctl` parents (default) or stay on the bones with `invariants.idleDrivesMeshes` declared |
+| `check --rig --out [--parts]` | build packed, gated under `spine-html`, render the idle, measure seam, loop and the six judgement lines (mesh texture stretch among them, from the idle's `render --geometry`), and report the recomposite's holes from `parts.json` |
 | `loop --frames <dir> --out <file.gif \| file.png> [--palette]` | encode a rendered idle as a looping GIF, lossless APNG, or indexed APNG (`--palette`) |
 | `build --config --source --full --head --out [--seam] [--project] [--loop]` | assemble, rig and check in one process, stopping at the first refusal |
 
@@ -308,13 +318,19 @@ the flag, puts 813 of `sample`'s 993 still-unprojected pixels and 879 of `demo`'
 
 [Bun](https://bun.sh) 1.2 or later. `npm install -g spine-parts` installs the
 `spine-parts` command; it hands off to Bun and says so in one sentence if Bun is not
-on `PATH`. spine-rigc comes with it as a dependency.
+on `PATH`. spine-rigc comes with it as a dependency. No Spine runtime does: since
+spine-rigc 2.0 the installed `rigc` gates every build with its own validator over the
+compiled model document, and `rigc --version` says `entry: cli_core.ts —
+@esotericsoftware/spine-core absent`. With `@esotericsoftware/spine-core` installed
+beside it, the same `rigc` runs the spine-core round trip instead, as this repository's
+selftest and CI do; `check.json`'s `rigc_entry` records which one gated a build.
 
 ## Licence posture
 
-spine-parts is MIT, and it depends on spine-rigc, which links Esoteric Software's
-`spine-core`: using what it produces in a product requires a Spine Editor licence, as
-any Spine data does. [NOTICE.md](NOTICE.md) records that chain and every other
+spine-parts is MIT, and it depends on spine-rigc, whose output is Spine skeleton data:
+using what it produces in a product requires a Spine Editor licence, as any Spine data
+does. Neither package installs Esoteric Software's `spine-core` any more; this
+repository uses it in development, for the round trip in its selftest and CI. [NOTICE.md](NOTICE.md) records that chain and every other
 third-party term this package touches, See-through's included.
 
 ## Development

package/cli.ts

@@ -15,10 +15,9 @@ import { spawnSync } from 'node:child_process';
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { basename, dirname, extname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
 import { DEFAULT_PROJECT_RULE, DEFAULT_SEAM_RULE, HOLES_LISTED, PROJECT_RULES, type ProjectRule, proposeFields, proposePlan, SEAM_RULES, type SeamRule } from './src/assemble.ts';
 import { assembleStage, build, checkStage, ERROR_MAP_FILE, loopStage, readRuns, readSource, rigStage } from './src/build.ts';
-import { findRigc, PARTS_HOME_SENTENCE, RIGC_GEOMETRY_VERSION, type RigcRunner, SEAM_MEAN_BAR, SEAM_PX_BAR, SEAM_PX_LEVEL, SPINEBOY_YARDSTICK, TEXTURE_STRETCH_CEILING } from './src/check.ts';
+import { DEFAULT_PAGE_EDGES, findRigc, PAGE_EDGES, type PageEdges, PARTS_HOME_SENTENCE, RIGC_GEOMETRY_VERSION, type RigcRunner, SEAM_MEAN_BAR, SEAM_PX_BAR, SEAM_PX_LEVEL, SPINEBOY_YARDSTICK, TEXTURE_STRETCH_CEILING } from './src/check.ts';
 import { ComfyClient, resolveHost, runPainting, runSeeThrough } from './src/comfy/index.ts';
 import { type CharacterConfig, loadConfig, loadEarlyConfig } from './src/config.ts';
 import { PartsError, problemLine } from './src/errors.ts';
@@ -98,6 +97,7 @@ usage:
       printed when one was needed.
 
   spine-parts rig --config <config.json> --parts <dir> --out <dir> [--idle-keys ctl|direct]
+                  [--page-edges pot|free]
       Author the rig: unrotated bones at the config's landmarks (a chain makes
       <chain>0..n), a square lattice mesh over every part in config.meshes
       weighted by distance to its candidate bone segments, a region for every
@@ -110,10 +110,11 @@ usage:
       bone twice, is refused by the loader, CONFIG_BLINK_GROUP_MEMBERS or
       CONFIG_BLINK_GROUP_UNIQUE, before rigc starts. --parts is the
       directory holding parts.json and parts/<name>.png. The result is built
-      through spine-rigc (profile spine-html, packed, then validated under
-      profile spine) in a scratch directory first, and --out receives
-      images/*.png, rig.json, motion.json and mesh_report.json only when both
-      are green. Prints one line per mesh and the rigc gate lines.
+      through spine-rigc (profile spine-html, packed with --page-edges as for
+      check; rigc's build gates the compile and the packed pages on disk) in a
+      scratch directory first, and --out receives images/*.png, rig.json,
+      motion.json and mesh_report.json only when it is green. Prints one line
+      per mesh and the rigc gate lines.
       --idle-keys says where the idle's keys on a bone a mesh is weighted to go:
       ctl (the default) keys a same-origin <bone>_ctl parent instead, which
       passes A15_IDLE_NO_MESH_BONE_KEYS on any spine-rigc; direct keys the bone
@@ -121,18 +122,19 @@ usage:
       spine-rigc 1.3.0 or later and makes A15 a SKIP that prints its cost (the
       stage prints that SKIP line). The pose is the same to one level of float
       rounding, and so is the per-frame mesh work (AUTHORING §5).
-  spine-parts check --rig <dir> --out <dir> [--parts <dir>]
+  spine-parts check --rig <dir> --out <dir> [--parts <dir>] [--page-edges pot|free]
       Build, gate, render and measure a rig through spine-rigc's CLI (the rigc at
       node_modules/.bin/rigc, or on PATH). --rig holds rig.json and motion.json
       (with an "idle").
       ${PARTS_HOME_SENTENCE}.
       Both are only read. Into --out:
-      build/ (rigc build --profile spine-html --pack: the packed atlas is the
-      artifact), gate_spine-html.txt and gate_spine.txt (the gate lines
+      build/ (rigc build --profile spine-html --pack --page-edges <value>: the
+      packed atlas is the artifact), gate_spine-html.txt (the gate lines
       verbatim), idle_frames/ (rigc render --animation idle --fps 12 --max 640
       --geometry: the frames and geometry.json, the skinned vertices and
       every bone's world transform per frame),
-      contact.png, motion_heat.png and check.json. PASS needs both gates
+      contact.png, motion_heat.png and check.json (with rigc_entry, the rigc
+      entry that gated the build). 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. Then six judgement lines, each in
@@ -163,6 +165,16 @@ usage:
       beside the spineboy yardstick (${SPINEBOY_YARDSTICK}), a reference and not
       a bar. Exit 0 on PASS, 1 on FAIL — every FAIL line names the bar, the value
       and the value required.
+      --page-edges is handed to rigc verbatim and defaults to ${DEFAULT_PAGE_EDGES}: the
+      least-area page the parts need (on the two public examples 967x1338 and
+      479x1166, where pot writes 1024x2048 and 512x2048), at the cost rigc
+      states — region attachments sample within 1 LSB of the loose build
+      rather than exactly (measured on both examples: every idle frame within
+      1 level of the pot build's; AUTHORING §5, Page edges). pot is a power of two on both edges, for a consumer
+      that mipmaps or repeats the page (the atlas declares filter Linear,
+      Linear and no repeat). rigc's pack line ends ", page edges free" under
+      free; a line that disagrees with the value passed, or a pot page that is
+      not a power of two, is refused, CHECK_PACK_PAGE_EDGES.
 
   spine-parts loop --frames <dir> --out <file.png | file.gif> [--palette]
       Encode a frame set rigc render wrote (its --out directory, or the set
@@ -247,7 +259,7 @@ usage:
 
   spine-parts build --config <config.json> --source <painting.png> --full <dir|psd>
                     --head <dir|psd> --out <dir> [--seam near-white|silhouette]
-                    [--project core|visible] [--loop]
+                    [--project core|visible] [--page-edges pot|free] [--loop]
       assemble, then rig, then check, in one process, each stage's own lines
       printed under [assemble], [rig] and [check]; the first stage that refuses
       stops the build with its own FAIL lines. The config must already carry
@@ -263,7 +275,8 @@ usage:
       three artifact paths — skeleton .json, .atlas and the packed page: the
       packed atlas is the result, the loose parts are the intermediate it was
       made from. --seam defaults to ${DEFAULT_SEAM_RULE}, --project to
-      ${DEFAULT_PROJECT_RULE} (both as for assemble).
+      ${DEFAULT_PROJECT_RULE} (both as for assemble), --page-edges to ${DEFAULT_PAGE_EDGES}
+      (as for check; both packed builds, rig's gate and check's artifact, take it).
 
   spine-parts --version
   spine-parts --help
@@ -384,18 +397,14 @@ function cmdSheet(args: string[]): number {
   }
 }
 
-/** spine-rigc's own CLI, resolved the way this package resolves every other rigc path. */
-function rigcCli(): string {
-  return fileURLToPath(import.meta.resolve('spine-rigc/cli.ts'));
+/** `--page-edges`, or its default; a value spine-rigc does not take is a usage error naming the two it does. */
+function pageEdgesOf(value: string | undefined): PageEdges | string {
+  const edges = value ?? DEFAULT_PAGE_EDGES;
+  return (PAGE_EDGES as readonly string[]).includes(edges) ? (edges as PageEdges) : `--page-edges ${edges}; one of ${PAGE_EDGES.join(', ')} is required`;
 }
 
-/** The rig stage's rigc: spine-rigc's cli.ts run by this Bun, as the stage has always gated. */
-function rigGateRunner(): RigcRunner {
-  return (args) => {
-    const r = spawnSync(process.execPath, [rigcCli(), ...args], { encoding: 'utf8', maxBuffer: 1 << 28 });
-    if (r.error !== undefined) return { status: 127, out: `could not start ${rigcCli()}: ${r.error.message}` };
-    return { status: r.status ?? 1, out: `${r.stdout ?? ''}${r.stderr ?? ''}` };
-  };
+function isPageEdges(v: PageEdges | string): v is PageEdges {
+  return (PAGE_EDGES as readonly string[]).includes(v);
 }
 
 function cmdRig(args: string[]): number {
@@ -403,10 +412,11 @@ function cmdRig(args: string[]): number {
   let partsDir: string | null = null;
   let out: string | null = null;
   let idleKeys: string | null = null;
+  let pageEdges: string | null = null;
   for (let i = 0; i < args.length; i++) {
     const flag = args[i];
     const value = args[i + 1];
-    if (!['--config', '--parts', '--out', '--idle-keys'].includes(flag)) return usage(`rig does not take "${flag}"`);
+    if (!['--config', '--parts', '--out', '--idle-keys', '--page-edges'].includes(flag)) return usage(`rig does not take "${flag}"`);
     if (value === undefined) return usage(`${flag} needs a value`);
     i++;
     if (flag === '--config') config = value;
@@ -414,6 +424,9 @@ function cmdRig(args: string[]): number {
     else if (flag === '--idle-keys') {
       if (idleKeys !== null) return usage('--idle-keys is given twice');
       idleKeys = value;
+    } else if (flag === '--page-edges') {
+      if (pageEdges !== null) return usage('--page-edges is given twice');
+      pageEdges = value;
     } else out = value;
   }
   if (config === null) return usage('rig needs --config <config.json>');
@@ -421,9 +434,17 @@ function cmdRig(args: string[]): number {
   if (out === null) return usage('rig needs --out <dir>');
   const keys = idleKeys ?? DEFAULT_IDLE_KEYS;
   if (!(IDLE_KEYS as readonly string[]).includes(keys)) return usage(`--idle-keys ${keys}; one of ${IDLE_KEYS.join(', ')} is required`);
+  const edges = pageEdgesOf(pageEdges ?? undefined);
+  if (!isPageEdges(edges)) return usage(edges);
+  let bin: string;
+  try {
+    bin = findRigc(import.meta.dir, process.env.PATH ?? '');
+  } catch (err) {
+    return printRefusal(err);
+  }
   const scratch = mkdtempSync(join(tmpdir(), 'spine-parts-rig-'));
   try {
-    rigStage({ config, parts: partsDir, out, idleKeys: keys as IdleKeys }, rigGateRunner(), scratch, console.log);
+    rigStage({ config, parts: partsDir, out, idleKeys: keys as IdleKeys, pageEdges: edges }, rigcRunner(bin), scratch, console.log);
     return EXIT_OK;
   } catch (err) {
     return printRefusal(err);
@@ -432,7 +453,16 @@ function cmdRig(args: string[]): number {
   }
 }
 
-/** The rigc process: `src/check.ts` is pure and takes the spawn from here. */
+/**
+ * The rigc process, for every stage that runs rigc — `rig`'s gate, `check`, and
+ * both inside `build`: the `rigc` binary {@link findRigc} located, spawned as
+ * it is, so spine-rigc's own launcher (`bin/rigc.cjs`) chooses the entry —
+ * `cli.ts` and the spine-core round trip where the runtime resolves beside it,
+ * `cli_core.ts` and rigc's own validator where it does not. No stage runs a
+ * rigc source file by path: under spine-rigc 2.0, `cli.ts` by path is the
+ * spine-core entry whether or not spine-core is there. `src/` is pure and takes
+ * the spawn from here.
+ */
 function rigcRunner(bin: string): RigcRunner {
   return (args) => {
     const r = spawnSync(bin, [...args], { encoding: 'utf8', maxBuffer: 1 << 28 });
@@ -456,13 +486,15 @@ function flags(args: string[], known: readonly string[], command: string, option
 }
 
 function cmdCheck(args: string[]): number {
-  const f = flags(args, ['--rig', '--out'], 'check', ['--parts']);
+  const f = flags(args, ['--rig', '--out'], 'check', ['--parts', '--page-edges']);
   if (typeof f === 'string') return usage(f);
   const rig = f.get('--rig') as string;
   const out = f.get('--out') as string;
+  const edges = pageEdgesOf(f.get('--page-edges'));
+  if (!isPageEdges(edges)) return usage(edges);
   try {
     const bin = findRigc(import.meta.dir, process.env.PATH ?? '');
-    const r = checkStage({ rig, parts: f.get('--parts') ?? rig, out }, rigcRunner(bin), bin, console.log);
+    const r = checkStage({ rig, parts: f.get('--parts') ?? rig, out, pageEdges: edges }, rigcRunner(bin), bin, console.log);
     return r.figures.PASS ? EXIT_OK : EXIT_REFUSED;
   } catch (err) {
     return printRefusal(err);
@@ -767,7 +799,7 @@ 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'];
+  const valued = ['--config', '--source', '--full', '--head', '--out', '--seam', '--project', '--page-edges'];
   for (let i = 0; i < args.length; i++) {
     const flag = args[i];
     if (flag === '--loop') {
@@ -787,6 +819,8 @@ function cmdBuild(args: string[]): number {
   if (!(SEAM_RULES as readonly string[]).includes(seam)) return usage(`--seam ${seam}; one of ${SEAM_RULES.join(', ')} is required`);
   const project = flags.get('--project') ?? DEFAULT_PROJECT_RULE;
   if (!(PROJECT_RULES as readonly string[]).includes(project)) return usage(`--project ${project}; one of ${PROJECT_RULES.join(', ')} is required`);
+  const edges = pageEdgesOf(flags.get('--page-edges'));
+  if (!isPageEdges(edges)) return usage(edges);
   const [config, source, full, head, out] = ['--config', '--source', '--full', '--head', '--out'].map((f) => flags.get(f) as string);
   let bin: string;
   try {
@@ -797,8 +831,8 @@ function cmdBuild(args: string[]): number {
   const scratch = mkdtempSync(join(tmpdir(), 'spine-parts-build-'));
   try {
     const r = build(
-      { config, source, full, head, out, seam: seam as SeamRule, project: project as ProjectRule, loop },
-      { rig: rigGateRunner(), check: rigcRunner(bin), checkBin: bin, scratch: join(scratch, 'rig-gate') },
+      { config, source, full, head, out, seam: seam as SeamRule, project: project as ProjectRule, loop, pageEdges: edges },
+      { rig: rigcRunner(bin), check: rigcRunner(bin), checkBin: bin, scratch: join(scratch, 'rig-gate') },
       console.log,
     );
     return r.stoppedAt === null ? EXIT_OK : EXIT_REFUSED;

package/docs/AUTHORING.md

@@ -18,7 +18,7 @@ into `examples/sample/inputs/`.
 | what | why | how |
 | --- | --- | --- |
 | [Bun](https://bun.sh) 1.2 or later | spine-parts and spine-rigc are Bun programs | `npm install -g spine-parts` installs the command; it says so if Bun is missing |
-| [spine-rigc](https://www.npmjs.com/package/spine-rigc) | compiles, gates, packs and renders every rig; spine-parts writes no Spine data itself | installed with spine-parts as a dependency (`node_modules/.bin/rigc`) |
+| [spine-rigc](https://www.npmjs.com/package/spine-rigc) | compiles, gates, packs and renders every rig; spine-parts writes no Spine data itself | installed with spine-parts as a dependency (`node_modules/.bin/rigc`); with no Spine runtime beside it, it gates with its own validator, and `rigc --version` says `entry: cli_core.ts` |
 | [See-through](https://github.com/shitagaki-lab/see-through), somewhere | the layer decomposition is the input | any route in README *Getting See-through layers*; it runs twice per character, outside this tool |
 | a GPU, wherever See-through runs | See-through is a diffusion model | nothing in spine-parts itself uses a GPU |
 
@@ -266,7 +266,7 @@ proposal in as the steps above say (`RL01`); every step must exit 0.
 | `sheet` of both runs | the tile list (and the sheet, if you can see) | eyes, irises, lashes and brows as left/right pairs in the head run | a head box that cut off an ornament: move `head_box`, re-run the head crop |
 | `assemble` | one line per part, the `pixels:` totals (opaque = visible + occluded; taken; visible but not projected), then `recomposite vs source: mean \|d\|, within 8, error px > 40, uncovered error px`, then `uncovered holes (8-connected): N` and the largest five as `uncovered hole K: <px> px at x,y wxh (between "<part>" <px> px, …)`; and look at `render/recomposite_error_rig.png` | on the examples: `sample` 0.84 / 98.0 % / 4,512 / 1,185, 259 holes, the largest 94 px; `demo` 2.39 / 95.8 % / 11,050 / 1,564, 453 holes, the largest 70 px (default rule) — many slivers along part edges, no hole a region could hide | one large hole: part of the figure is in no layer — a plan entry is missing, hair left the head crop sideways (the demo's `hair_back` is taken from the full run for that reason), or See-through split one garment into two and left the space between them in neither (a skirt as two trouser legs); the `between` parts say where. When neither run holds it at all, an `assemble.patches` entry cuts it from the painting (below) |
 | `propose` | `note:` lines, `LINT` lines, `landmarks.png` | no LINT line: every chain link lies on its mesh's art, and the hip is below the chest and the figure's top quarter | a link off the art (a bone on the background) — move it onto the layer; `LINT hip at [x, y] is not below chest at [x, y]: …` or `LINT hip at [x, y] is above 0.25 of the figure height (figure y T..B, so hip y must be at least L): a hip at the shoulders` — move `hip` down to the waist (and `chest` between it and the neck); a `hanging strand … -- no chain proposed` note — that strand hangs stiff until you add a chain down the x and rows it names (§3); a `no blink: …` or `blink without brows: …` note — the idle will not blink (or its brows will not drop), because no part came from an `eyewhite` (or `eyebrow`) layer; the note names the tags looked for; a `no eyewhite part for eye_<s> …` note — the iris and lash parts it names ride `head` and do not blink, because no `eyewhite-<s>` part made that side's eye bone: take the eyewhite from the other run, or keep them on `head` |
-| `rig` (inside `build`) | one line per mesh: vertices, triangles, bones, influences, `cover`; the `bones` line; the `idle keys` line; then rigc's gate lines (with A15's declared SKIP under `--idle-keys direct`) | `cover 1.00000` on every mesh, both gates `0 failed` | `RIG_LATTICE_ONE_LOOP`: change that mesh's `grid` |
+| `rig` (inside `build`) | one line per mesh: vertices, triangles, bones, influences, `cover`; the `bones` line; the `idle keys` line; then rigc's gate lines (with A15's declared SKIP under `--idle-keys direct`) | `cover 1.00000` on every mesh, both gate summaries `0 failed` (the compile and the packed pages) | `RIG_LATTICE_ONE_LOOP`: change that mesh's `grid` |
 | `check` (inside `build`) | the gate lines verbatim, the pack line, `loop:`, `seam:`, the six judgement lines and `RECOMPOSITE_HOLES` (§7), `check.json` | `check: PASS`, and a judgement line SKIP only where the character lacks what it reads | `CHECK_SEAM_WITHIN_BAR` or `CHECK_LOOP_CLOSES` (§6) |
 | `loop` (inside `build --loop`, or `loop --frames … --out …`) | the dropped-duplicate line, each file's line, then `loop: idle.png N B (lossless); idle-indexed.png N B (max …, mean …); idle.gif N B (max …, mean …)` | `f0048.png equals f0000.png byte for byte, so it is dropped` | `LOOP_ENCODE` (§6) |
 
@@ -279,9 +279,11 @@ entry, no dithering, filter None) — and is the small file to show. `idle.gif`
 (`loop --out x.gif`) is the same median cut in a GIF. The indexed APNG and the GIF
 print their palette error, per channel over R, G and B of every frame (and alpha's
 max for the APNG); a figure is a measurement of the file, not a bar. On the demo:
-13,645,519 B lossless, 1,706,785 B indexed and 1,812,625 B GIF, both palette files at
+13,645,350 B lossless, 1,706,520 B indexed and 1,812,238 B GIF, both palette files at
 max 57, mean 1.601 — the two share one quantiser, so their error is the same by
-construction and the size is the difference. The loop shows the blink closed: the
+construction and the size is the difference. That is `--seam silhouette` (the README's
+animation); with `--page-edges pot` the same build writes 13,645,519, 1,706,785 and
+1,812,625 B at the same error. The loop shows the blink closed: the
 eyes' hold is at least one 12 fps frame (below), so whatever `motion.blink.t` is, one
 idle frame lands inside it, and `check.json`'s `BLINK_NO_HOLE.idle_frames_closed`
 names it — `[29]` on both examples.
@@ -294,6 +296,38 @@ outside the figure. On the demo it lowered recomposite error pixels from 11,050
 9,540 and changed no check bar; on the sample it changed nothing. The default stays
 the reference's so the examples stay comparable with it.
 
+**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`,
+the least-area page the parts need. `--page-edges pot` is the opt-out: a power of
+two on both edges, which is the page every build wrote before this flag. The pack
+line says which one ran, because rigc ends it with `, page edges free` under `free`.
+Measured on the two examples by `tools/atlas_population.ts` with rigc 1.5.1, and again
+with rigc 2.0.3, which reproduced every figure in both tables and the one check figure
+below:
+
+| build | page | covered | page opaque | page / figure |
+| --- | --- | --- | --- | --- |
+| demo, `pot` | 1024x2048 | 56.3 % | 36.8 % | 2.651 |
+| demo, `free` | 967x1338 | 91.2 % | 59.7 % | 1.636 |
+| sample, `pot` | 512x2048 | 49.7 % | 28.7 % | 3.294 |
+| sample, `free` | 479x1166 | 93.4 % | 53.9 % | 1.755 |
+
+rigc's help states the cost: *"a smaller page, at the cost of region attachments
+sampling within 1 LSB of the loose build rather than exactly"*. On these builds
+every one of the 49 idle frames differs from the `pot` build, by at most 1 level
+in any channel:
+
+| example | idle frames that differ | pixels that differ (all 49 frames) | max \|d\| |
+| --- | --- | --- | --- |
+| demo | 49 of 49 | 2,373 | 1 |
+| sample | 49 of 49 | 651 | 1 |
+
+Only one check figure moved. It has no bar: sample's reported screen-space face
+mean in `STILL_REGIONS_DARK`, 11.475 under `pot` and 11.472 under `free`. Every
+barred figure and every status is the same under both. The atlas rigc writes says
+`filter: Linear, Linear` and has no `repeat` line, so choose `pot` for a consumer
+that mipmaps or repeats the page.
+
 `--project core` (the default) is the reference's projection rule: a layer takes the
 painting's pixel only inside its top-most `alpha >= 250` area eroded by a 5x5 square,
 so a part a few pixels wide (a lash, a brow, an iris) takes none. `--project visible`
@@ -325,8 +359,8 @@ differ by at most one level in a channel. The default stays `ctl`: the examples'
 `expected/rig.json` and `motion.json` are the reference's output, and the
 declaration is in the rig spec only, so `rigc validate <build> --profile spine-html`
 run on a `direct` build (it has no rig spec to read) refuses A15 once per keyed
-bone. `check` validates the build under `spine` only, where A15 is not in the
-profile, and is green on both.
+bone. No stage runs `validate`: the gate is `rigc build`, which reads the rig spec
+and its declaration, and is green on both (`RG19`).
 
 **Patching a hole no layer holds.** When an `uncovered hole` stays large after the
 plan is right — both See-through runs dropped a piece of the figure, red in
@@ -556,7 +590,8 @@ See-through with another seed.
 | `CHECK_RIGC_PRESENT` | no `rigc` binary found (every place looked is listed) | `bun install` |
 | `CHECK_INPUT_PRESENT` on `…/parts.json` | `--parts` named a directory without `parts.json` — most often `parts/` itself. The detail says it: "--parts names the directory holding parts.json and parts/, not parts/ itself (after build, that is build's --out, whose rig is <out>/rig); without --parts it is --rig", and names the parent when the parent holds `parts.json` | `--parts` — the directory above `parts/` |
 | `CHECK_INPUT_PRESENT`, `CHECK_INPUT_IS_JSON`, `CHECK_PART_PNG_PRESENT`, `CHECK_PART_PNG_MATCHES_BOX`, `CHECK_PART_SLOT_PRESENT`, `CHECK_RIG_STAGE_PRESENT`, `CHECK_RIG_STAGE_IS_THE_CANVAS`, `CHECK_RIG_ROOT_BONE`, `CHECK_IDLE_PRESENT` | the rig directory is incomplete or disagrees with `parts.json` (`CHECK_PART_SLOT_PRESENT`: a part with no slot of its own name, which the judgement lines render it by) | re-run rig (`build` does both) |
-| `CHECK_RIGC_VERSION` | `rigc --version` is below 1.4.0, or prints no version: its `render` has no `--geometry`, which `TEXTURE_STRETCH` reads. Refused before anything is built | `bun install` (this package depends on spine-rigc ^1.5.1), or put a newer `rigc` first on `PATH` |
+| `CHECK_RIGC_VERSION` | `rigc --version` is below 1.4.0, or prints no version: its `render` has no `--geometry`, which `TEXTURE_STRETCH` reads. Refused before anything is built | `bun install` (this package depends on spine-rigc ^2.0.3), or put a newer `rigc` first on `PATH` |
+| `CHECK_RIGC_ENTRY`, `CHECK_RIGC_ENTRY_READS` | `rigc --version` names no entry (a rigc below 2.0.0), or names one in neither launcher form (`entry: cli.ts — @esotericsoftware/spine-core <v> present`, `entry: cli_core.ts — @esotericsoftware/spine-core absent — …`); `check.json`'s `rigc_entry` records the one that gated the build | `bun install` |
 | `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) | a track whose last key is not its first |
@@ -569,6 +604,8 @@ See-through with another seed.
 | `CHECK_TEXTURE_STRETCH` | a mesh triangle's edge, in some idle frame, is more than 1.926544 times its rest length or less than 1/1.926544 of it (the mesh, triangle, its three vertices, the edge and the frame are named); or a rest edge has length 0 | the chain tracks' `amps` on the bones that mesh is weighted to (the stretch grows with them), or the mesh's `segments` — a vertex blending two bones that swing against each other |
 | `CHECK_SEAM_FRAME_SIZE`, `FRAMES_SIDECAR`, `CHECK_GEOMETRY_FILE` | rigc's render is not what its `frames.json` says, or its `geometry.json` is not a whole `rigc-geometry/1` export of the frames beside it (a frame count, a mesh whose vertex count differs from its rest entry; for the face half, another viewport than `frames.json`'s, other frame indices, the head bone or a feature's bone missing from a frame, a non-finite transform or time) | a rigc problem; report it |
 | `LOOP_ENCODE` | the loop encoder refused a frame (translucent pixel in a GIF, a size change) | the frames; for a translucent frame write the lossless or the indexed APNG, which keep alpha |
+| `CHECK_PACK_LINE_READS` | rigc printed a `pack:` line that is not `pack: <page> <W>x<H>, <N> region(s), <P>% covered, padding <D>` with `, page edges free` after it or nothing; the line is quoted | a rigc this package does not know the output of; report it, with `rigc --version` |
+| `CHECK_PACK_PAGE_EDGES` | the pack line disagrees with the `--page-edges` the build was run with — its `, page edges free` suffix is there under `pot` or missing under `free`, or a `pot` page is not a power of two on both edges | a rigc problem; report it, with `rigc --version` |
 | `BUILD_ARTIFACT_PRESENT` | the packed build lacks its `.json`, `.atlas` or page | a rigc problem; report it |
 
 ## 7. The bars `check` enforces, and what only an eye answers today
@@ -577,14 +614,17 @@ See-through with another seed.
 implementation's bars):
 
 - `gate_spine-html.txt`: every summary line `(N passed, 0 failed)` — the packed build
-  under the `spine-html` profile;
-- `gate_spine.txt`: the same, `rigc validate` of that build under the `spine` profile;
+  under the `spine-html` profile, gated once over the compile and once over the packed
+  pages on disk. There is no `spine` gate of its own: `spine-html` holds every rule
+  `spine` measures (on the demo, rigc 1.5.1 and 2.0.3: `validate --profile spine`'s 14
+  measured rules are all among the build's 23, the 15 others 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;
 - **loop**: idle frame 0 against the frame at `t = duration`: max |d| exactly 0.
 
-On the examples: `sample` 23/23 and 14/14, seam 0.207 with 0 pixels over 40, loop 0;
-`demo` (default rule) 23/23 and 14/14, seam 0.326 with 2 pixels over 40, loop 0.
+On the examples: `sample` 23/23, seam 0.207 with 0 pixels over 40, loop 0;
+`demo` (default rule) 23/23, seam 0.326 with 2 pixels over 40, loop 0.
 
 A green gate cannot see a wrong animation, so `check` also writes six **judgement
 lines** (issue #11; `TEXTURE_STRETCH`, issue #31), each a key of `check.json` and a console line
@@ -676,7 +716,8 @@ What each figure is, and is not:
 - **The face is measured in the head's frame, and its bar is the model's (issue #33).**
   Until #33 the face half read the screen-space heat map, where the head's intended
   roll lights the outline on both examples (16.988 and 11.475, the figures now
-  reported as `screen_heat_mean`), so its ceiling was twice the worse example,
+  reported as `screen_heat_mean`; sample's reads 11.472 since the page edges
+  default to `free`, *Page edges* in §5), so its ceiling was twice the worse example,
   33.976 — a ceiling a smooth fixture face sliding two rig pixels stayed under (24.8;
   eight pixels measured 85.5). The judgement means *nothing moves on the face that
   the head does not move*, so the heat is now taken after each frame's face region is

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spine-parts",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "AI-authored Spine 2D character parts from one anime painting and its See-through layer decomposition: measured parts, weighted-mesh rig specs, verified through spine-rigc before anything is written. A CLI for agents that cannot see the image.",
   "type": "module",
   "bin": {
@@ -57,9 +57,10 @@
   },
   "dependencies": {
     "ag-psd": "^31.0.2",
-    "spine-rigc": "^1.5.1"
+    "spine-rigc": "^2.0.3"
   },
   "devDependencies": {
+    "@esotericsoftware/spine-core": "4.3.13",
     "@types/bun": "^1.4.2",
     "eslint": "^10.11.0",
     "typescript": "^5.9.3",

package/skills/spine-parts/SKILL.md

@@ -15,9 +15,11 @@ stage writes are the whole interface.
 
 ## Non-negotiables
 
-- **spine-rigc's round trip is never bypassed.** spine-parts writes no Spine data
-  itself; `rig` writes only after rigc's build and validate are green, and `build`'s
+- **spine-rigc's gate is never bypassed.** spine-parts writes no Spine data
+  itself; `rig` writes only after rigc's `build` gate is green, and `build`'s
   artifact is what rigc wrote. There is no flag that skips it, and none may be added.
+  `check.json`'s `rigc_entry` names which gate ran: rigc's own validator in an
+  install, the spine-core round trip where the runtime is installed beside rigc.
 - **No value is invented.** A missing config field is a refusal naming it. Take a
   value from the command that proposes it (`propose --head-box`,
   `assemble --propose-plan`, `propose`) or decide it yourself — never guess one

package/src/build.ts

@@ -44,7 +44,7 @@ import { existsSync, mkdirSync, readdirSync, rmSync, writeFileSync } from 'node:
 import { dirname, join } from 'node:path';
 import { type AnimFrame, EncodeError, encodeApng, encodeIndexedApng, INDEXED_DEFAULTS } from './apng.ts';
 import { assemble, type AssembleResult, figuresLine, holeLines, type ProjectRule, type SeamRule, stageFields } from './assemble.ts';
-import { type CheckReport, JUDGEMENT_LINES, type JudgementLine, readFrameSet, REPORTED_LINES, type ReportedLine, type RigcRunner, runCheck, SEAM_MEAN_BAR, SEAM_PX_BAR, SEAM_PX_LEVEL, SEAM_PX_LEVEL_HIGH, SPINEBOY_YARDSTICK } from './check.ts';
+import { causeLines, type CheckReport, type PackLine, DEFAULT_PAGE_EDGES, JUDGEMENT_LINES, type JudgementLine, packedBuildArgs, packedBuildLabel, type PageEdges, readFrameSet, REPORTED_LINES, type ReportedLine, type RigcRunner, runCheck, SEAM_MEAN_BAR, SEAM_PX_BAR, SEAM_PX_LEVEL, SEAM_PX_LEVEL_HIGH, SPINEBOY_YARDSTICK } from './check.ts';
 import { loadConfig, loadEarlyConfig } from './config.ts';
 import { PartsError, type Problem, problemLine } from './errors.ts';
 import { encodeGif } from './gif.ts';
@@ -162,7 +162,12 @@ export function assembleStage(input: AssembleStageInput, outs: AssembleOutputs,
 interface GateRun {
   label: string;
   status: number;
-  /** rigc's FAIL lines, its assertion summary and the one SKIP this stage's own declaration causes, as it printed them. */
+  /**
+   * rigc's FAIL lines, its assertion summary, the core entry's `here:` line and
+   * the one SKIP this stage's own declaration causes, as it printed them — or,
+   * for a run that exited non-zero with none of those, the lines
+   * {@link causeLines} says name why.
+   */
   lines: string[];
 }
 
@@ -175,31 +180,33 @@ interface GateRun {
  */
 const DECLARED_SKIP = /^ {2}SKIP {2}A15_IDLE_NO_MESH_BONE_KEYS: declared by the rig/;
 
+/** The core entry's line after its summary (spine-rigc 2.0.0 and later): which rules ran, and that the round trip did not. */
+const HERE_LINE = /^ {2}\.\. {4}here: /;
+
 function gateRun(label: string, rigc: RigcRunner, args: string[]): GateRun {
   const r = rigc(args);
-  const lines = r.out.split('\n').filter((l) => /^ {2}FAIL {2}/.test(l) || /assertions: \d+ measured/.test(l) || /^rigc compile error/.test(l) || DECLARED_SKIP.test(l));
-  return { label, status: r.status, lines };
+  const lines = r.out.split('\n').filter((l) => /^ {2}FAIL {2}/.test(l) || /assertions: \d+ measured/.test(l) || /^rigc compile error/.test(l) || DECLARED_SKIP.test(l) || HERE_LINE.test(l));
+  const failed = lines.some((l) => /^ {2}FAIL {2}/.test(l) || /^rigc compile error/.test(l));
+  return { label, status: r.status, lines: r.status !== 0 && !failed ? [...lines, ...causeLines(r.out)] : lines };
 }
 
 /**
- * spine-rigc's round trip over the rig in a scratch directory: `build` under
- * the spine-html profile with `--pack`, then `validate` of that build under
- * the spine profile. The files are staged exactly as `--out` will receive
- * them, so what passed is what is written. The scratch directory is the
- * caller's, and is emptied here before and after.
+ * spine-rigc's gate over the rig in a scratch directory: `build` under the
+ * spine-html profile with `--pack --page-edges <edges>`, which runs the gate
+ * once over the compile and once over the packed pages on disk. There is no
+ * second `validate --profile spine` run: spine-html holds every rule spine
+ * measures (selftest `CH09`). The files are staged exactly as `--out` will
+ * receive them, so what passed is what is written. The scratch directory is
+ * the caller's, and is emptied here before and after.
  */
-function gateThroughRigc(out: RigOutput, texts: Array<[string, string]>, rigc: RigcRunner, scratch: string): GateRun[] {
+function gateThroughRigc(out: RigOutput, texts: Array<[string, string]>, rigc: RigcRunner, scratch: string, edges: PageEdges): GateRun[] {
   rmSync(scratch, { recursive: true, force: true });
   try {
     mkdirSync(join(scratch, 'images'), { recursive: true });
     for (const [file, img] of out.images) writeFileSync(join(scratch, 'images', file), encodePngBytes(img));
     for (const [file, text] of texts) writeFileSync(join(scratch, file), text);
     const build = join(scratch, 'build');
-    const html = gateRun('build --profile spine-html --pack', rigc, [
-      'build', '--rig', join(scratch, 'rig.json'), '--motion', join(scratch, 'motion.json'), '--out', build, '--profile', 'spine-html', '--pack',
-    ]);
-    if (html.status !== 0) return [html];
-    return [html, gateRun('validate --profile spine', rigc, ['validate', build, '--profile', 'spine'])];
+    return [gateRun(packedBuildLabel(edges), rigc, ['build', '--rig', join(scratch, 'rig.json'), '--motion', join(scratch, 'motion.json'), '--out', build, ...packedBuildArgs(edges)])];
   } finally {
     rmSync(scratch, { recursive: true, force: true });
   }
@@ -212,9 +219,11 @@ export interface RigStageInput {
   out: string;
   /** Where the idle's keys on mesh-driving bones go; `ctl` when absent. See `IDLE_KEYS` in `src/rig.ts`. */
   idleKeys?: IdleKeys;
+  /** The gate build's `--page-edges`; {@link DEFAULT_PAGE_EDGES} when absent. The pack is scratch here; the gate is what it is for. */
+  pageEdges?: PageEdges;
 }
 
-/** Author the rig, gate it through rigc in `scratch`, and write `out` only when both gates are green. */
+/** Author the rig, gate it through rigc in `scratch`, and write `out` only when the gate is green. */
 export function rigStage(input: RigStageInput, rigc: RigcRunner, scratch: string, log: Log): RigOutput {
   const cfg = loadConfig(input.config);
   const parts = readParts(join(input.parts, 'parts.json'));
@@ -249,7 +258,7 @@ export function rigStage(input: RigStageInput, rigc: RigcRunner, scratch: string
       ? `  idle keys ctl: ${rig.meshKeyed.length} mesh-driving bone(s) keyed by the idle, each keyed through a same-origin <bone>_ctl parent`
       : `  idle keys direct: ${rig.meshKeyed.length} mesh-driving bone(s) keyed in place, ${rig.rig.invariants === undefined ? 'so no invariants.idleDrivesMeshes is declared (it would switch nothing off)' : 'invariants.idleDrivesMeshes declared'}`,
   );
-  const gate = gateThroughRigc(rig, texts, rigc, scratch);
+  const gate = gateThroughRigc(rig, texts, rigc, scratch, input.pageEdges ?? DEFAULT_PAGE_EDGES);
   for (const g of gate) {
     log(`  rigc ${g.label}: exit ${g.status}`);
     for (const l of g.lines) log(`    ${l.trim()}`);
@@ -259,7 +268,7 @@ export function rigStage(input: RigStageInput, rigc: RigcRunner, scratch: string
     const problems: Problem[] = red.map((g) => ({
       code: 'RIG_RIGC_GREEN',
       object: `rigc ${g.label}`,
-      detail: `exited ${g.status}${g.lines.length > 0 ? `: ${g.lines.map((l) => l.trim()).join(' | ')}` : ''}; exit 0 is required before anything is written, and nothing was`,
+      detail: `exited ${g.status}${g.lines.length > 0 ? `: ${g.lines.map((l) => l.trim()).join(' | ')}` : ', and it printed nothing'}; exit 0 is required before anything is written, and nothing was`,
     }));
     throw new PartsError(problems);
   }
@@ -280,6 +289,8 @@ export interface CheckStageInput {
   /** The directory holding parts.json and parts/; the rig directory when they sit there. */
   parts: string;
   out: string;
+  /** The packed build's `--page-edges`; {@link DEFAULT_PAGE_EDGES} when absent. */
+  pageEdges?: PageEdges;
 }
 
 /** The pack line as it is printed: rigc's own, then the page's opaque share beside the spineboy yardstick. */
@@ -314,12 +325,13 @@ export function judgementLine(name: string, line: JudgementLine | ReportedLine):
 export function checkStage(input: CheckStageInput, rigc: RigcRunner, bin: string, log: Log): CheckReport {
   const v = rigc(['--version']);
   log(`spine-parts check: ${input.rig} -> ${input.out}`);
-  log(`  rigc ${v.out.trim().split('\n')[0]} at ${bin}`);
-  const r = runCheck(input.rig, input.out, rigc, input.parts);
-  log('  gate spine-html (rigc build --profile spine-html --pack), verbatim:');
+  const versionLines = v.out.trim().split('\n');
+  const entryLine = versionLines.find((l) => l.startsWith('entry:'));
+  log(`  rigc ${versionLines[0]} at ${bin}${entryLine === undefined ? '' : `; ${entryLine}`}`);
+  const edges = input.pageEdges ?? DEFAULT_PAGE_EDGES;
+  const r = runCheck(input.rig, input.out, rigc, input.parts, edges);
+  log(`  gate spine-html (rigc ${packedBuildLabel(edges)}), verbatim:`);
   for (const l of r.gateHtml) log(l);
-  log('  gate spine (rigc validate build --profile spine), verbatim:');
-  for (const l of r.gateSpine) log(l);
   for (const l of packLines(r)) log(`  ${l}`);
   const fig = r.figures;
   log(`  loop: idle ${r.idle.frames} frame(s) at ${r.idle.fps} fps, f0000 vs f${String(r.idle.lastIndex).padStart(4, '0')} (t = ${r.idle.duration}s): max |d| ${fig.loop_max_diff} (0 required)`);
@@ -329,7 +341,7 @@ export function checkStage(input: CheckStageInput, rigc: RigcRunner, bin: string
   );
   for (const name of JUDGEMENT_LINES) log(`  ${judgementLine(name, fig[name])}`);
   for (const name of REPORTED_LINES) log(`  ${judgementLine(name, fig[name])}`);
-  log(`  gates: spine-html ${fig.gate_spine_html_green ? 'green' : 'RED'}, spine ${fig.gate_spine_green ? 'green' : 'RED'}`);
+  log(`  gate: spine-html ${fig.gate_spine_html_green ? 'green' : 'RED'} (${fig.rigc_entry.entry}${fig.rigc_entry.spine_core === null ? ', rigc\'s own validator' : `, the spine-core ${fig.rigc_entry.spine_core} round trip`})`);
   log(`  wrote ${r.written.map((w) => join(input.out, w)).join(', ')}, ${join(input.out, 'build')}/, ${join(input.out, 'idle_frames')}/`);
   for (const p of r.problems) log(`  FAIL  ${problemLine(p)}`);
   log(fig.PASS ? 'check: PASS' : `check: FAIL — ${r.problems.length} bar(s) not met`);
@@ -427,9 +439,16 @@ export interface BuildInput {
   seam: SeamRule;
   project: ProjectRule;
   loop: boolean;
+  /** `--page-edges` for both packed builds, the rig stage's gate and the check's artifact. */
+  pageEdges: PageEdges;
 }
 
-/** The two rigc processes, as each command runs its own: `rig` gates through one, `check` measures through the other. */
+/**
+ * The rigc process for each stage: `rig` gates through one, `check` measures
+ * through the other. `cli.ts` hands both the same runner, the `rigc` binary
+ * spine-rigc's launcher answers for; they are two fields so a caller can tell
+ * the stages' calls apart (the selftest counts them).
+ */
 export interface BuildRunners {
   rig: RigcRunner;
   check: RigcRunner;
@@ -452,20 +471,28 @@ export interface BuildResult {
   artifact: string[];
 }
 
+/**
+ * rigc's own record of the compiled rig, which `build` writes beside the
+ * skeleton JSON and atlas (spine-rigc's AUTHORING, the `--out` row; written
+ * since 1.6): what rigc's posing core reads, not a Spine file, so it is not the
+ * artifact and is not counted as a second skeleton JSON.
+ */
+export const RIGC_MODEL_DOCUMENT = 'skeleton.model.json';
+
 /** The three artifact files of a packed build, each refused by name when absent. */
-function artifactPaths(buildDir: string, report: CheckReport): string[] {
+export function artifactPaths(buildDir: string, pack: readonly PackLine[]): string[] {
   const problems: Problem[] = [];
   const names = existsSync(buildDir) ? readdirSync(buildDir).sort() : [];
-  const json = names.filter((n) => n.endsWith('.json'));
+  const json = names.filter((n) => n.endsWith('.json') && n !== RIGC_MODEL_DOCUMENT);
   const atlas = names.filter((n) => n.endsWith('.atlas'));
-  if (json.length !== 1) problems.push({ code: 'BUILD_ARTIFACT_PRESENT', object: `${buildDir} skeleton JSON`, detail: `holds ${json.length} .json file(s) [${json.join(', ')}]; the packed build writes exactly one` });
+  if (json.length !== 1) problems.push({ code: 'BUILD_ARTIFACT_PRESENT', object: `${buildDir} skeleton JSON`, detail: `holds ${json.length} .json file(s) [${json.join(', ')}]; the packed build writes exactly one besides rigc's ${RIGC_MODEL_DOCUMENT}` });
   if (atlas.length !== 1) problems.push({ code: 'BUILD_ARTIFACT_PRESENT', object: `${buildDir} atlas`, detail: `holds ${atlas.length} .atlas file(s) [${atlas.join(', ')}]; the packed build writes exactly one` });
-  if (report.pack.length === 0) problems.push({ code: 'BUILD_ARTIFACT_PRESENT', object: `${buildDir} packed page`, detail: 'rigc printed no pack line, so no packed page is named; the build runs with --pack and must print one' });
-  for (const p of report.pack) {
+  if (pack.length === 0) problems.push({ code: 'BUILD_ARTIFACT_PRESENT', object: `${buildDir} packed page`, detail: 'rigc printed no pack line, so no packed page is named; the build runs with --pack and must print one' });
+  for (const p of pack) {
     if (!names.includes(p.page)) problems.push({ code: 'BUILD_ARTIFACT_PRESENT', object: `${buildDir} packed page`, detail: `the pack line names ${p.page}, which is not on disk` });
   }
   if (problems.length > 0) throw new PartsError(problems);
-  return [join(buildDir, json[0]), join(buildDir, atlas[0]), ...report.pack.map((p) => join(buildDir, p.page))];
+  return [join(buildDir, json[0]), join(buildDir, atlas[0]), ...pack.map((p) => join(buildDir, p.page))];
 }
 
 /**
@@ -487,7 +514,7 @@ export function build(input: BuildInput, run: BuildRunners, log: Log): BuildResu
   const out = input.out;
   mkdirSync(out, { recursive: true });
   for (const p of BUILD_OWNS) rmSync(join(out, p), { recursive: true, force: true });
-  log(`spine-parts build: ${input.config} -> ${out}, seam rule ${input.seam}, projection rule ${input.project}${input.loop ? ', with the idle loop' : ''}`);
+  log(`spine-parts build: ${input.config} -> ${out}, seam rule ${input.seam}, projection rule ${input.project}, page edges ${input.pageEdges}${input.loop ? ', with the idle loop' : ''}`);
 
   try {
     // build runs rig next, which needs the whole config, so the full loader is
@@ -505,14 +532,14 @@ export function build(input: BuildInput, run: BuildRunners, log: Log): BuildResu
   }
 
   try {
-    rigStage({ config: input.config, parts: out, out: join(out, 'rig') }, run.rig, run.scratch, prefixed('rig'));
+    rigStage({ config: input.config, parts: out, out: join(out, 'rig'), pageEdges: input.pageEdges }, run.rig, run.scratch, prefixed('rig'));
   } catch (err) {
     return refused('rig', err);
   }
 
   let report: CheckReport;
   try {
-    report = checkStage({ rig: join(out, 'rig'), parts: out, out: join(out, 'check') }, run.check, run.checkBin, prefixed('check'));
+    report = checkStage({ rig: join(out, 'rig'), parts: out, out: join(out, 'check'), pageEdges: input.pageEdges }, run.check, run.checkBin, prefixed('check'));
   } catch (err) {
     return refused('check', err);
   }
@@ -537,7 +564,7 @@ export function build(input: BuildInput, run: BuildRunners, log: Log): BuildResu
 
   let artifact: string[];
   try {
-    artifact = artifactPaths(join(out, 'check', 'build'), report);
+    artifact = artifactPaths(join(out, 'check', 'build'), report.pack);
   } catch (err) {
     return refused('artifact', err, report);
   }

package/src/check.ts

@@ -6,9 +6,11 @@
  *
  * ⭐ **This is the one stage that drives a subprocess, and it does not own the
  * spawn.** Every rigc step — build, validate, render — is spine-rigc's own CLI,
- * never a re-implementation of it, because rigc's round trip through
- * `spine-core` is the only oracle behind a skeleton (CLAUDE.md, "spine-rigc's
- * validation is not optional here either"). But `src/` is held to no child
+ * never a re-implementation of it, because rigc's gate is the only oracle
+ * behind a skeleton (CLAUDE.md, "spine-rigc's gate is not optional here
+ * either"): the spine-core round trip where the runtime resolves beside rigc,
+ * rigc's own validator where it does not, and `check.json`'s `rigc_entry` says
+ * which ({@link readRigcEntry}). But `src/` is held to no child
  * processes (`TY06`, with `src/comfy/` its one named exception), so the process
  * is injected: `runCheck` takes a {@link RigcRunner}, `cli.ts` hands it one
  * that spawns the binary {@link findRigc} located, and the selftest hands it
@@ -23,9 +25,8 @@
  *
  * | output | what |
  * | --- | --- |
- * | `build/` | `rigc build --profile spine-html --pack` — the packed atlas is the final artifact |
- * | `gate_spine-html.txt` | that build's gate lines, verbatim |
- * | `gate_spine.txt` | `rigc validate build/ --profile spine`'s gate lines, verbatim |
+ * | `build/` | `rigc build --profile spine-html --pack --page-edges free` (or `pot`, when the caller names it; {@link PAGE_EDGES}) — the packed atlas is the final artifact |
+ * | `gate_spine-html.txt` | that build's gate lines, verbatim — the one gate: rigc's `build` runs it once over the compile and once over the packed pages on disk, and `spine-html` holds every rule `spine` measures (selftest `CH09`) |
  * | `idle_frames/` | `rigc render --animation idle --fps 12 --max 640 --geometry`: `frames.json` + `idle/f*.png` + `idle/geometry.json` (each mesh's skinned vertices, which `TEXTURE_STRETCH` reads, and every bone's world transform, which the face half of `STILL_REGIONS_DARK` reads) |
  * | `contact.png` | rigc's own contact sheet of that render, copied out |
  * | `motion_heat.png` | frame 0 in grey with each pixel's largest change across the idle in red |
@@ -184,6 +185,40 @@ export const GEOMETRY_SPEC = 'rigc-geometry/1';
 /** Issue #2's yardstick, measured on the Spine example export `spineboy.png` (alpha > 0). */
 export const SPINEBOY_YARDSTICK = '1024x256, 40 region(s), 45.8% opaque (alpha > 0)';
 
+/**
+ * What a packed page's edges may be: spine-rigc's `build --pack --page-edges`,
+ * handed to it verbatim (the flag is in spine-rigc's CLI since 1.4.0, the
+ * floor `check` already requires; 1.5.0 made `free` search every width).
+ * `pot` is a power of two on both edges; `free` is the least-area page the
+ * placement needs, at the cost rigc's help states: region attachments sample
+ * within 1 LSB of the loose build rather than exactly.
+ *
+ * `free` is the default here although rigc's own default is `pot`: the packed
+ * page is this package's final artifact, and on the two public examples `free`
+ * takes the page from 1024x2048 to 967x1338 (covered 56.3 % -> 91.2 %) and
+ * from 512x2048 to 479x1166 (49.7 % -> 93.4 %), rigc 1.5.1 and 2.0.3 alike. The cost was
+ * measured on the same two builds. Each of the 49 idle frames differs from the
+ * `pot` build's, by at most 1 level in any channel (demo 2,373 px, sample 651
+ * px over all 49). On sample that moves STILL_REGIONS_DARK's reported
+ * screen-space face mean from 11.475 to 11.472; no bar or status moves. The
+ * atlas rigc writes says `filter: Linear, Linear` and has no `repeat` line, so
+ * a consumer that mipmaps or repeats the page itself is the one that wants
+ * `pot`. AUTHORING §5, *Page edges*, holds the tables.
+ */
+export const PAGE_EDGES = ['pot', 'free'] as const;
+export type PageEdges = (typeof PAGE_EDGES)[number];
+export const DEFAULT_PAGE_EDGES: PageEdges = 'free';
+
+/** The packed build's rigc arguments after `--out <dir>`, as every stage that packs passes them. */
+export function packedBuildArgs(edges: PageEdges): string[] {
+  return ['--profile', 'spine-html', '--pack', '--page-edges', edges];
+}
+
+/** The packed build as a label: the rigc command line that was run, after `rigc`. */
+export function packedBuildLabel(edges: PageEdges): string {
+  return `build ${packedBuildArgs(edges).join(' ')}`;
+}
+
 // ---------------------------------------------------------------------------
 // the rigc process, injected
 // ---------------------------------------------------------------------------
@@ -197,6 +232,81 @@ export interface RigcCall {
 
 export type RigcRunner = (args: readonly string[]) => RigcCall;
 
+/** A line in which a rigc run that stopped says why: Bun's own `error: …`, rigc's `rigc <command>: …` refusals, a `usage: …` line. */
+const CAUSE = /^(error: |rigc[\w -]*: |usage: )/;
+
+/**
+ * What a rigc run that exited non-zero said about why, for a refusal whose own
+ * filter (FAIL lines, the assertion summary) matched nothing: every line that
+ * names a cause, or, when none does, the last three non-empty lines. Measured
+ * against spine-rigc 2.0.3: its `cli.ts` run by path without
+ * `@esotericsoftware/spine-core` beside it dies at import with one
+ * `error: Cannot find module '@esotericsoftware/spine-core' from …` line, and its
+ * core entry refuses `validate` with one `rigc validate: …` line, neither of
+ * which a gate filter reads. The last lines and not the first are the fallback
+ * because `rigc build` prints its header and inputs before it can stop. Empty
+ * only when the run printed nothing at all.
+ */
+export function causeLines(out: string): string[] {
+  const lines = out.split('\n').map((l) => l.trim()).filter((l) => l !== '');
+  const named = lines.filter((l) => CAUSE.test(l));
+  return named.length > 0 ? named : lines.slice(-3);
+}
+
+/** The two entries spine-rigc's launcher (`bin/rigc.cjs`, spine-rigc 2.0.0 and later) runs. */
+export const RIGC_ENTRIES = ['cli.ts', 'cli_core.ts'] as const;
+export type RigcEntry = (typeof RIGC_ENTRIES)[number];
+
+/** The first spine-rigc whose `--version` names the entry that ran (its launcher's stderr line; spine-rigc 2.0.0's changelog, issue #1061 there). */
+export const RIGC_ENTRY_VERSION = '2.0.0';
+
+/**
+ * Which rigc entry gated the build, as `check.json` records it: `cli.ts`, the
+ * spine-core round trip, with the runtime's version; `cli_core.ts`, rigc's own
+ * validator over its model document, with no runtime (`spine_core` null).
+ */
+export interface RigcEntryRecord {
+  entry: RigcEntry;
+  spine_core: string | null;
+}
+
+/** The launcher's two `entry:` lines, whole, as spine-rigc 2.0.3's `bin/rigc.cjs` writes them. */
+const ENTRY_FULL = /^entry: cli\.ts — @esotericsoftware\/spine-core (\S+) present$/;
+const ENTRY_CORE = /^entry: cli_core\.ts — @esotericsoftware\/spine-core absent — /;
+
+/**
+ * The entry a `rigc --version` run names. A run with no `entry:` line is a
+ * rigc older than {@link RIGC_ENTRY_VERSION}, or not rigc's launcher, and is
+ * refused `CHECK_RIGC_ENTRY`; an `entry:` line in neither form above is refused
+ * `CHECK_RIGC_ENTRY_READS`, naming the line — a third entry is not read as
+ * either of the two.
+ */
+export function readRigcEntry(versionOut: string): RigcEntryRecord {
+  const lines = versionOut.split('\n').map((l) => l.trim());
+  const line = lines.find((l) => l.startsWith('entry:'));
+  if (line === undefined) {
+    refuseIfAny([
+      {
+        code: 'CHECK_RIGC_ENTRY',
+        object: '`rigc --version`',
+        detail: `printed ${JSON.stringify(versionOut.trim())} and no \`entry:\` line; spine-rigc ${RIGC_ENTRY_VERSION} or later is required — its launcher names the entry that ran, and check.json records which one gated the build (\`bun install\` puts this package's own spine-rigc at node_modules/.bin/rigc)`,
+      },
+    ]);
+  }
+  const at = line as string;
+  const full = ENTRY_FULL.exec(at);
+  if (full !== null) return { entry: 'cli.ts', spine_core: full[1] };
+  if (ENTRY_CORE.test(at)) return { entry: 'cli_core.ts', spine_core: null };
+  refuseIfAny([
+    {
+      code: 'CHECK_RIGC_ENTRY_READS',
+      object: `rigc's entry line ${JSON.stringify(at)}`,
+      detail: 'reads as neither "entry: cli.ts — @esotericsoftware/spine-core <version> present" nor "entry: cli_core.ts — @esotericsoftware/spine-core absent — …"; one of the two is required',
+    },
+  ]);
+  throw new Error('unreachable');
+}
+
 /**
  * Where the `rigc` binary is: `node_modules/.bin/rigc` in `from` or any
  * directory above it (a clone has it beside the package; an install has it in
@@ -393,14 +503,34 @@ export function readCheckInputs(rigDir: string, partsHome: string = rigDir): Che
 // gate lines
 // ---------------------------------------------------------------------------
 
-/** `check_rig.py`'s filter for the build: summary, stats and pack lines, and anything that failed. */
+/**
+ * The `here:` line spine-rigc's core entry (`cli_core.ts`, 2.0.0 and later)
+ * prints after its assertion summary, saying which rules ran and that the
+ * spine-core round trip did not; `cli.ts` prints none.
+ */
+const HERE_LINE = /^\.\.\s+here: /;
+
+/**
+ * `check_rig.py`'s filter for the build: summary, stats and pack lines, and
+ * anything that failed — and, under rigc's core entry, its `here:` line, so the
+ * gate file says which validator ran.
+ */
 export function buildGateLines(out: string): string[] {
-  return out.split('\n').filter((l) => (l.trim().startsWith('..') && (l.includes(' assertions: ') || l.includes('pages=') || l.includes('pack:'))) || l.includes('FAIL') || l.includes('compile error'));
+  return out
+    .split('\n')
+    .filter((l) => (l.trim().startsWith('..') && (l.includes(' assertions: ') || l.includes('pages=') || l.includes('pack:') || HERE_LINE.test(l.trim()))) || l.includes('FAIL') || l.includes('compile error'));
 }
 
-/** `check_rig.py`'s filter for validate: the summary and anything that failed. */
-export function validateGateLines(out: string): string[] {
-  return out.split('\n').filter((l) => l.includes(' assertions: ') || l.includes('FAIL'));
+/**
+ * The rules a rigc run measured — every `PASS` and `FAIL` line's rule name, in
+ * the order printed, each once. A SKIP, a PROF line and a summary are not
+ * measurements. The selftest's `CH09` compares a build's set with
+ * `rigc validate --profile spine`'s on the same build.
+ */
+export function measuredRules(out: string): string[] {
+  const seen: string[] = [];
+  for (const m of out.matchAll(/^ {2}(?:PASS|FAIL) {2}([A-Z][A-Z0-9_]*)/gm)) if (!seen.includes(m[1])) seen.push(m[1]);
+  return seen;
 }
 
 const SUMMARY = /\((\d+) passed, (\d+) failed\)/;
@@ -423,19 +553,68 @@ export interface PackLine {
   regions: number;
   coveredPct: number;
   padding: number;
+  /** `free` when the line ends `, page edges free`, `pot` when it carries no suffix — spine-rigc prints the suffix exactly when it packed under `--page-edges free` (its `cli.ts`, the pack line). */
+  pageEdges: PageEdges;
 }
 
-const PACK = /pack: (\S+) (\d+)x(\d+), (\d+) region\(s\), ([\d.]+)% covered, padding (\d+)/;
+/** rigc's pack line, whole: the line is this and nothing else, or it is refused. */
+const PACK = /^pack: (\S+) (\d+)x(\d+), (\d+) region\(s\), (\d+(?:\.\d+)?)% covered, padding (\d+)(, page edges free)?$/;
 
+/**
+ * Every pack line among the gate lines — a line that reads `pack:` once its
+ * `..` gutter is taken off. A pack line spine-rigc 1.5.1 to 2.0.3 would not print (an
+ * unknown suffix, a missing field) is refused, `CHECK_PACK_LINE_READS`, naming
+ * the line and the form required: a line half-read would lose the one field
+ * that changed.
+ */
 export function parsePackLines(lines: readonly string[]): PackLine[] {
   const out: PackLine[] = [];
+  const problems: Problem[] = [];
   for (const l of lines) {
-    const m = PACK.exec(l);
-    if (m !== null) out.push({ line: l.trim().replace(/^\.\.\s+/, ''), page: m[1], width: Number(m[2]), height: Number(m[3]), regions: Number(m[4]), coveredPct: Number(m[5]), padding: Number(m[6]) });
+    const text = l.trim().replace(/^\.\.\s+/, '');
+    if (!text.startsWith('pack:')) continue;
+    const m = PACK.exec(text);
+    if (m === null) {
+      problems.push({
+        code: 'CHECK_PACK_LINE_READS',
+        object: `rigc's pack line ${JSON.stringify(text)}`,
+        detail: 'does not read as "pack: <page> <W>x<H>, <N> region(s), <P>% covered, padding <D>", with ", page edges free" after it or nothing; that form is required',
+      });
+      continue;
+    }
+    out.push({ line: text, page: m[1], width: Number(m[2]), height: Number(m[3]), regions: Number(m[4]), coveredPct: Number(m[5]), padding: Number(m[6]), pageEdges: m[7] === undefined ? 'pot' : 'free' });
   }
+  refuseIfAny(problems);
   return out;
 }
 
+function powerOfTwo(n: number): boolean {
+  return Number.isInteger(n) && n > 0 && (n & (n - 1)) === 0;
+}
+
+/**
+ * Where a pack line disagrees with the `--page-edges` the build was given:
+ * the line's own suffix must say the same, and a `pot` page must be a power of
+ * two on both edges, as rigc's help defines it. One problem per disagreement,
+ * `CHECK_PACK_PAGE_EDGES`; empty is agreement.
+ */
+export function packEdgeProblems(pack: readonly PackLine[], edges: PageEdges): Problem[] {
+  const problems: Problem[] = [];
+  for (const p of pack) {
+    const object = `packed page ${p.page}`;
+    if (p.pageEdges !== edges) {
+      problems.push({
+        code: 'CHECK_PACK_PAGE_EDGES',
+        object,
+        detail: `rigc's pack line says page edges ${p.pageEdges} (${p.pageEdges === 'free' ? 'it ends ", page edges free"' : 'no ", page edges free" suffix'}); the build was run with --page-edges ${edges}, so page edges ${edges} is required`,
+      });
+    } else if (edges === 'pot' && !(powerOfTwo(p.width) && powerOfTwo(p.height))) {
+      problems.push({ code: 'CHECK_PACK_PAGE_EDGES', object, detail: `is ${p.width}x${p.height}; the build was run with --page-edges pot, so a power of two on both edges is required` });
+    }
+  }
+  return problems;
+}
+
 /** Share of a page's pixels with alpha above 0 — the measure issue #2's spineboy figure is in. rigc's "covered" is region rectangles, not pixels. */
 export function opaqueShare(r: Raster): number {
   let n = 0;
@@ -704,7 +883,8 @@ export const REPORTED_LINES = ['RECOMPOSITE_HOLES'] as const;
 /** check.json — the reference's fields in its order, then the judgement lines, then PASS. */
 export interface CheckFigures {
   gate_spine_html_green: boolean;
-  gate_spine_green: boolean;
+  /** Which rigc entry gated the build ({@link readRigcEntry}): provenance, not a bar. */
+  rigc_entry: RigcEntryRecord;
   loop_max_diff: number;
   seam_mean: number;
   seam_px_over_40: number;
@@ -722,7 +902,6 @@ export interface CheckFigures {
 export interface CheckReport {
   figures: CheckFigures;
   gateHtml: string[];
-  gateSpine: string[];
   pack: PackLine[];
   /** Opaque share (alpha > 0) of each packed page, by page file name. */
   packOpaque: Array<{ page: string; share: number }>;
@@ -733,10 +912,17 @@ export interface CheckReport {
   written: string[];
 }
 
-function rigcFailed(what: string, call: RigcCall, lines: readonly string[]): Problem[] {
+/**
+ * One `CHECK_RIGC_GREEN` per line that says why `rigc <what>` was not green:
+ * its FAIL and compile-error lines, or, when there are none, {@link causeLines}.
+ * A run that printed nothing is still one problem, never none.
+ */
+export function rigcFailed(what: string, call: RigcCall, lines: readonly string[]): Problem[] {
   const named = lines.filter((l) => l.includes('FAIL') || l.includes('compile error'));
-  const quoted = named.length > 0 ? named : call.out.split('\n').filter((l) => l.trim() !== '').slice(-3);
-  return quoted.map((l) => ({ code: 'CHECK_RIGC_GREEN', object: `\`rigc ${what}\``, detail: `exit ${call.status}: ${l.trim()}` }));
+  const quoted = named.length > 0 ? named.map((l) => l.trim()) : causeLines(call.out);
+  const object = `\`rigc ${what}\``;
+  if (quoted.length === 0) return [{ code: 'CHECK_RIGC_GREEN', object, detail: `exit ${call.status}, and it printed nothing` }];
+  return quoted.map((l) => ({ code: 'CHECK_RIGC_GREEN', object, detail: `exit ${call.status}: ${l}` }));
 }
 
 /**
@@ -745,11 +931,13 @@ function rigcFailed(what: string, call: RigcCall, lines: readonly string[]): Pro
  * gate file is written first, so the refusal's evidence is on disk. Otherwise
  * it measures everything, writes every output including `check.json`, and
  * returns the report; `report.problems` names each bar that was not met, and
- * `figures.PASS` is true exactly when it is empty.
+ * `figures.PASS` is true exactly when it is empty. `pageEdges` reaches rigc's
+ * `--page-edges` verbatim, and a pack line that disagrees with it is refused
+ * (`CHECK_PACK_PAGE_EDGES`).
  */
-export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, partsHome: string = rigDir): CheckReport {
+export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, partsHome: string = rigDir, pageEdges: PageEdges = DEFAULT_PAGE_EDGES): CheckReport {
   const inp = readCheckInputs(rigDir, partsHome);
-  requireRigcVersion(rigc);
+  const rigcEntry = readRigcEntry(requireRigcVersion(rigc));
   const out = resolve(outDir);
   mkdirSync(out, { recursive: true });
   const buildDir = join(out, 'build');
@@ -764,19 +952,18 @@ export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, parts
   };
 
   // 1. build, packed, under the policy profile
-  const build = rigc(['build', '--rig', inp.rigPath, '--motion', inp.motionPath, '--out', buildDir, '--profile', 'spine-html', '--pack']);
+  const build = rigc(['build', '--rig', inp.rigPath, '--motion', inp.motionPath, '--out', buildDir, ...packedBuildArgs(pageEdges)]);
   const gateHtml = buildGateLines(build.out);
   write('gate_spine-html.txt', `${gateHtml.join('\n')}\n`);
-  if (build.status !== 0) refuseIfAny(rigcFailed('build --profile spine-html --pack', build, gateHtml));
+  if (build.status !== 0) refuseIfAny(rigcFailed(packedBuildLabel(pageEdges), build, gateHtml));
   const pack = parsePackLines(gateHtml);
+  refuseIfAny(packEdgeProblems(pack, pageEdges));
   const packOpaque = pack.filter((p) => existsSync(join(buildDir, p.page))).map((p) => ({ page: p.page, share: opaqueShare(readPng(join(buildDir, p.page))) }));
 
-  // 2. validate under the validity profile
-  const validate = rigc(['validate', buildDir, '--profile', 'spine']);
-  const gateSpine = validateGateLines(validate.out);
-  write('gate_spine.txt', `${gateSpine.join('\n')}\n`);
+  // 2. no second gate: `rigc validate --profile spine` of this build measured no rule the build's own two passes
+  // had not (14 of the build's 23 on the demo, rigc 1.5.1 and 2.0.3 alike; selftest CH09 holds it), and on rigc's
+  // core entry — an install without spine-core — `validate` is refused outright
   const htmlGreen = gateGreen(build.status, gateHtml);
-  const spineGreen = gateGreen(validate.status, gateSpine);
 
   // 3. the idle, the loop, the heat
   const render = rigc(['render', '--candidate', buildDir, '--animation', 'idle', '--fps', String(IDLE_FPS), '--max', String(IDLE_MAX_PX), '--geometry', '--out', idleDir]);
@@ -892,7 +1079,7 @@ export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, parts
 
   const figures: CheckFigures = {
     gate_spine_html_green: htmlGreen,
-    gate_spine_green: spineGreen,
+    rigc_entry: rigcEntry,
     loop_max_diff: loop.max,
     seam_mean: round3(seam.mean),
     seam_px_over_40: seam.over40,
@@ -907,8 +1094,7 @@ export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, parts
     PASS: false,
   };
   const barProblems: Problem[] = [];
-  if (!htmlGreen) barProblems.push(...rigcFailed('build --profile spine-html --pack', build, gateHtml));
-  if (!spineGreen) barProblems.push(...rigcFailed('validate --profile spine', validate, gateSpine));
+  if (!htmlGreen) barProblems.push(...rigcFailed(packedBuildLabel(pageEdges), build, gateHtml));
   if (figures.loop_max_diff !== LOOP_MAX_BAR) {
     barProblems.push({
       code: 'CHECK_LOOP_CLOSES',
@@ -931,7 +1117,6 @@ export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, parts
   return {
     figures,
     gateHtml,
-    gateSpine,
     pack,
     packOpaque,
     idle: { frames: idle.frames.length, fps: idle.fps, duration: idle.duration, lastIndex: last.index, loopAt: { x: loop.x, y: loop.y } },
@@ -1369,10 +1554,12 @@ export function parseRigcVersion(out: string): [number, number, number] | null {
 /**
  * Refuse, before anything is built, a rigc older than
  * {@link RIGC_GEOMETRY_VERSION}: its `render` has no `--geometry`, so the idle
- * render would fail on the flag after the build and validate had run, and
+ * render would fail on the flag after the build had run, and
  * the refusal would name a flag rather than the version that lacks it.
+ * Returns what `--version` printed, stdout then stderr, which is where
+ * {@link readRigcEntry} reads the entry.
  */
-export function requireRigcVersion(rigc: RigcRunner): void {
+export function requireRigcVersion(rigc: RigcRunner): string {
   const v = rigc(['--version']);
   const got = v.status === 0 ? parseRigcVersion(v.out) : null;
   const need = parseRigcVersion(RIGC_GEOMETRY_VERSION) as [number, number, number];
@@ -1386,6 +1573,7 @@ export function requireRigcVersion(rigc: RigcRunner): void {
       },
     ]);
   }
+  return v.out;
 }
 
 export interface IdleGeometry {