spine-parts 0.6.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,7 +35,6 @@ 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 967x1338, 22 region(s), 91.2% covered, padding 2, page edges free</code><br/>
@@ -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 --page-edges free` 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` |
@@ -124,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/`
@@ -253,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 |
 
@@ -319,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,7 +15,6 @@ 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 { 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';
@@ -112,9 +111,10 @@ usage:
       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 with --page-edges as for
-      check, 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.
+      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
@@ -129,11 +129,12 @@ usage:
       ${PARTS_HOME_SENTENCE}.
       Both are only read. Into --out:
       build/ (rigc build --profile spine-html --pack --page-edges <value>: the
-      packed atlas is the artifact), gate_spine-html.txt and gate_spine.txt (the gate lines
+      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
@@ -396,20 +397,6 @@ 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'));
-}
-
-/** 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 ?? ''}` };
-  };
-}
-
 /** `--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;
@@ -449,9 +436,15 @@ function cmdRig(args: string[]): number {
   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, pageEdges: edges }, 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);
@@ -460,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 });
@@ -830,7 +832,7 @@ function cmdBuild(args: string[]): number {
   try {
     const r = build(
       { config, source, full, head, out, seam: seam as SeamRule, project: project as ProjectRule, loop, pageEdges: edges },
-      { rig: rigGateRunner(), check: rigcRunner(bin), checkBin: bin, scratch: join(scratch, 'rig-gate') },
+      { 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) |
 
@@ -301,7 +301,9 @@ the reference's so the examples stay comparable with it.
 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 with rigc 1.5.1 on the two examples, by `tools/atlas_population.ts`:
+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 |
 | --- | --- | --- | --- | --- |
@@ -357,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
@@ -588,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 |
@@ -611,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spine-parts",
-  "version": "0.6.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, 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 { 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,18 +180,24 @@ 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 --page-edges <edges>`, 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, edges: PageEdges): GateRun[] {
   rmSync(scratch, { recursive: true, force: true });
@@ -195,9 +206,7 @@ function gateThroughRigc(out: RigOutput, texts: Array<[string, string]>, rigc: R
     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(packedBuildLabel(edges), rigc, ['build', '--rig', join(scratch, 'rig.json'), '--motion', join(scratch, 'motion.json'), '--out', build, ...packedBuildArgs(edges)]);
-    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 });
   }
@@ -214,7 +223,7 @@ export interface RigStageInput {
   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'));
@@ -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);
   }
@@ -316,13 +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 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)`);
@@ -332,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`);
@@ -434,7 +443,12 @@ export interface BuildInput {
   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;
@@ -457,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))];
 }
 
 /**
@@ -542,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
@@ -24,8 +26,7 @@
  * | output | what |
  * | --- | --- |
  * | `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 |
- * | `gate_spine.txt` | `rigc validate build/ --profile spine`'s gate lines, verbatim |
+ * | `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 |
@@ -195,7 +196,7 @@ export const SPINEBOY_YARDSTICK = '1024x256, 40 region(s), 45.8% opaque (alpha >
  * `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. The cost was
+ * 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
@@ -231,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
@@ -427,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\)/;
@@ -466,7 +562,7 @@ const PACK = /^pack: (\S+) (\d+)x(\d+), (\d+) region\(s\), (\d+(?:\.\d+)?)% cove
 
 /**
  * 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 would not print (an
+ * `..` 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.
@@ -787,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;
@@ -805,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 }>;
@@ -816,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}` }));
 }
 
 /**
@@ -834,7 +937,7 @@ function rigcFailed(what: string, call: RigcCall, lines: readonly string[]): Pro
  */
 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');
@@ -857,12 +960,10 @@ export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, parts
   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]);
@@ -978,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,
@@ -994,7 +1095,6 @@ export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, parts
   };
   const barProblems: Problem[] = [];
   if (!htmlGreen) barProblems.push(...rigcFailed(packedBuildLabel(pageEdges), build, gateHtml));
-  if (!spineGreen) barProblems.push(...rigcFailed('validate --profile spine', validate, gateSpine));
   if (figures.loop_max_diff !== LOOP_MAX_BAR) {
     barProblems.push({
       code: 'CHECK_LOOP_CLOSES',
@@ -1017,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 } },
@@ -1455,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];
@@ -1472,6 +1573,7 @@ export function requireRigcVersion(rigc: RigcRunner): void {
       },
     ]);
   }
+  return v.out;
 }
 
 export interface IdleGeometry {