spine-parts 0.6.0 → 0.8.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

@@ -34,18 +34,17 @@ was shifted down into the canvas (its proposal ran 118 px above the top edge;
 <code>propose --head-box</code> now makes that shift itself), and <code>hair_back</code>
 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>50 assertions: 24 measured (24 passed, 0 failed), 26 skipped, 0 not in profile "spine-html"</code><br/>
 <code>loop: idle 49 frame(s) at 12 fps, f0000 vs f0048 (t = 4s): max |d| 0 (0 required)</code><br/>
 <code>seam: setup pose at 714x1216, scale 0.9422: mean |d| 0.324 (&lt;= 1.0), 2 px over 40 (&lt;= 50), 0 px over 80 (reported)</code><br/>
-<code>pack: skeleton.png 967x1338, 22 region(s), 91.2% covered, padding 2, page edges free</code><br/>
+<code>pack: skeleton.png 922x1348, 22 region(s), 95.0% covered, padding 2, page edges free, shape polygon</code><br/>
 <code>--seam silhouette</code> repaired the navy blobs the default rule leaves on the white
 blouse (recomposite error pixels 11,050 → 9,540); the default stays
 <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,520 bytes, one 256-entry palette at a measured error of max 57, mean 1.601
+12 fps, 1,706,719 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,350 bytes; the GIF, at the same error, 1,812,238). Frame 29 (2.417 s) is the
+13,645,503 bytes; the GIF, at the same error, 1,812,288). 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,10 +86,10 @@ 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 --pack-shape polygon` and gated under `spine-html`, which holds every rule `spine` measures (on the demo, rigc 2.1.3: the 14 rules `validate --profile spine` measures are among the build's 24; 16 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` |
+| `check/` | both gate files verbatim, the idle's frames and their `geometry.json` (skinned vertices per frame), `contact.png`, `motion_heat.png`, `check.json` (with `pack_mode`, the `--page-edges` and `--pack-shape` the page was packed under) |
 | `idle.png`, `idle-indexed.png`, `idle.gif` | with `--loop`: the idle as a lossless APNG (the exactness record), an indexed APNG with one shared palette (the small one) and a GIF; the last two print their palette error |
 
 The last lines of a green build are the pack line, printed beside the Spine example
@@ -99,15 +98,15 @@ 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 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
+  pack: skeleton.png 477x1151, 20 region(s), 95.0% covered, padding 2, page edges free, shape polygon; page opaque 54.8% (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
+not the next power of two. On the two examples, packed by rectangles, 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
@@ -116,6 +115,16 @@ consumer that mipmaps or repeats the page; it writes exactly the page builds wro
 before the flag existed. The measurements are in
 [AUTHORING §5, *Page edges*](docs/AUTHORING.md#5-after-each-stage-what-to-read).
 
+The pack shape is `polygon` by default (spine-rigc 2.1): a region only meshes draw is
+packed by its emitted hull, so a neighbour may sit inside its rectangle where the hull
+is not; a region attachment stays its rectangle. On the two examples that takes the
+free page from 967x1338 to 922x1348 (covered 91.2 % to 95.0 %, 3.9 % less area) and
+from 479x1166 to 477x1151 (93.4 % to 95.0 %, 1.7 % less), at the cost class `free`
+already has: every idle frame within 1 level of the `rect` build's, and no figure in
+`check.json` but `pack_mode` moves. `--pack-shape rect` writes the page and atlas
+0.7.0 wrote. The measurements are in
+[AUTHORING §5, *Pack shape*](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.
 
@@ -124,7 +133,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 +262,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 +328,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 { 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 { DEFAULT_PACK_SHAPE, DEFAULT_PAGE_EDGES, findRigc, PACK_SHAPES, type PackShape, 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,7 +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]
+                  [--page-edges pot|free] [--pack-shape rect|polygon]
       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
@@ -111,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 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.
+      through spine-rigc (profile spine-html, packed with --page-edges and
+      --pack-shape 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
@@ -123,17 +123,19 @@ usage:
       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>] [--page-edges pot|free]
+                    [--pack-shape rect|polygon]
       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 --page-edges <value>: 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>
+      --pack-shape <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, and pack_mode, the two pack flags). PASS needs every gate summary
       "0 failed", the seam (setup pose vs the flat composite of parts/) at mean
       |d| <= ${SEAM_MEAN_BAR.toFixed(1)} with <= ${SEAM_PX_BAR} px over ${SEAM_PX_LEVEL}, and the loop (idle frame 0 vs the
       frame at t = duration) at max |d| 0. Then six judgement lines, each in
@@ -165,15 +167,25 @@ usage:
       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
+      least-area page the parts need (on the two public examples, rect, 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
+      Linear and no repeat). rigc's pack line carries ", 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.
+      --pack-shape is handed to rigc verbatim and defaults to ${DEFAULT_PACK_SHAPE}:
+      a region only meshes draw is packed by its emitted hull, so a neighbour
+      may sit inside its rectangle where the hull is not (on the two public
+      examples, under free, 922x1348 and 477x1151 where rect writes 967x1338
+      and 479x1166), at the cost of the same 1-level class as free (measured
+      on both examples: every idle frame within 1 level of the rect build's;
+      AUTHORING §5, Pack shape). rect keeps every region's cell apart and
+      writes the page earlier releases wrote. rigc's pack line ends
+      ", shape rect" or ", shape polygon"; a line that disagrees with the
+      value passed is refused, CHECK_PACK_SHAPE.
 
   spine-parts loop --frames <dir> --out <file.png | file.gif> [--palette]
       Encode a frame set rigc render wrote (its --out directory, or the set
@@ -258,7 +270,8 @@ 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] [--page-edges pot|free] [--loop]
+                    [--project core|visible] [--page-edges pot|free]
+                    [--pack-shape rect|polygon] [--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
@@ -274,8 +287,9 @@ 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), --page-edges to ${DEFAULT_PAGE_EDGES}
-      (as for check; both packed builds, rig's gate and check's artifact, take it).
+      ${DEFAULT_PROJECT_RULE} (both as for assemble), --page-edges to ${DEFAULT_PAGE_EDGES} and
+      --pack-shape to ${DEFAULT_PACK_SHAPE} (as for check; both packed builds, rig's gate
+      and check's artifact, take them).
 
   spine-parts --version
   spine-parts --help
@@ -396,20 +410,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;
@@ -420,16 +420,27 @@ function isPageEdges(v: PageEdges | string): v is PageEdges {
   return (PAGE_EDGES as readonly string[]).includes(v);
 }
 
+/** `--pack-shape`, or its default; a value spine-rigc does not take is a usage error naming the two it does. */
+function packShapeOf(value: string | undefined): PackShape | string {
+  const shape = value ?? DEFAULT_PACK_SHAPE;
+  return (PACK_SHAPES as readonly string[]).includes(shape) ? (shape as PackShape) : `--pack-shape ${shape}; one of ${PACK_SHAPES.join(', ')} is required`;
+}
+
+function isPackShape(v: PackShape | string): v is PackShape {
+  return (PACK_SHAPES as readonly string[]).includes(v);
+}
+
 function cmdRig(args: string[]): number {
   let config: string | null = null;
   let partsDir: string | null = null;
   let out: string | null = null;
   let idleKeys: string | null = null;
   let pageEdges: string | null = null;
+  let packShape: 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', '--page-edges'].includes(flag)) return usage(`rig does not take "${flag}"`);
+    if (!['--config', '--parts', '--out', '--idle-keys', '--page-edges', '--pack-shape'].includes(flag)) return usage(`rig does not take "${flag}"`);
     if (value === undefined) return usage(`${flag} needs a value`);
     i++;
     if (flag === '--config') config = value;
@@ -440,6 +451,9 @@ function cmdRig(args: string[]): number {
     } else if (flag === '--page-edges') {
       if (pageEdges !== null) return usage('--page-edges is given twice');
       pageEdges = value;
+    } else if (flag === '--pack-shape') {
+      if (packShape !== null) return usage('--pack-shape is given twice');
+      packShape = value;
     } else out = value;
   }
   if (config === null) return usage('rig needs --config <config.json>');
@@ -449,9 +463,17 @@ 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);
+  const shape = packShapeOf(packShape ?? undefined);
+  if (!isPackShape(shape)) return usage(shape);
+  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, packShape: shape }, rigcRunner(bin), scratch, console.log);
     return EXIT_OK;
   } catch (err) {
     return printRefusal(err);
@@ -460,7 +482,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 });
@@ -484,15 +515,17 @@ function flags(args: string[], known: readonly string[], command: string, option
 }
 
 function cmdCheck(args: string[]): number {
-  const f = flags(args, ['--rig', '--out'], 'check', ['--parts', '--page-edges']);
+  const f = flags(args, ['--rig', '--out'], 'check', ['--parts', '--page-edges', '--pack-shape']);
   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);
+  const shape = packShapeOf(f.get('--pack-shape'));
+  if (!isPackShape(shape)) return usage(shape);
   try {
     const bin = findRigc(import.meta.dir, process.env.PATH ?? '');
-    const r = checkStage({ rig, parts: f.get('--parts') ?? rig, out, pageEdges: edges }, rigcRunner(bin), bin, console.log);
+    const r = checkStage({ rig, parts: f.get('--parts') ?? rig, out, pageEdges: edges, packShape: shape }, rigcRunner(bin), bin, console.log);
     return r.figures.PASS ? EXIT_OK : EXIT_REFUSED;
   } catch (err) {
     return printRefusal(err);
@@ -797,7 +830,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', '--page-edges'];
+  const valued = ['--config', '--source', '--full', '--head', '--out', '--seam', '--project', '--page-edges', '--pack-shape'];
   for (let i = 0; i < args.length; i++) {
     const flag = args[i];
     if (flag === '--loop') {
@@ -819,6 +852,8 @@ function cmdBuild(args: string[]): number {
   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 shape = packShapeOf(flags.get('--pack-shape'));
+  if (!isPackShape(shape)) return usage(shape);
   const [config, source, full, head, out] = ['--config', '--source', '--full', '--head', '--out'].map((f) => flags.get(f) as string);
   let bin: string;
   try {
@@ -829,8 +864,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, pageEdges: edges },
-      { 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, packShape: shape },
+      { 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,11 +279,12 @@ 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,350 B lossless, 1,706,520 B indexed and 1,812,238 B GIF, both palette files at
+13,645,503 B lossless, 1,706,719 B indexed and 1,812,288 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. 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
+animation, spine-rigc 2.1.3); with `--pack-shape rect` the same build writes 13,645,350,
+1,706,520 and 1,812,238 B, and with `--page-edges pot --pack-shape rect` 13,645,519,
+1,706,785 and 1,812,625 B, all 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.
@@ -300,8 +301,11 @@ the reference's so the examples stay comparable with it.
 --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 with rigc 1.5.1 on the two examples, by `tools/atlas_population.ts`:
+line says which one ran, because rigc writes `, page edges free` after the padding under
+`free`. Measured on the two examples by `tools/atlas_population.ts` with rigc 1.5.1, and
+again with rigc 2.0.3 and with rigc 2.1.3 under `--pack-shape rect` (the frames table
+by the same idle render), which reproduced every figure in both tables and the one
+check figure below:
 
 | build | page | covered | page opaque | page / figure |
 | --- | --- | --- | --- | --- |
@@ -326,6 +330,56 @@ barred figure and every status is the same under both. The atlas rigc writes say
 `filter: Linear, Linear` and has no `repeat` line, so choose `pot` for a consumer
 that mipmaps or repeats the page.
 
+**Pack shape.** `rig`, `check` and `build` also hand rigc `--pack-shape <v>`
+verbatim (spine-rigc 2.1.0 and later). `rect` keeps every region's cell apart, the
+only packing before 2.1. `polygon`, the default here (rigc's own is `rect`), packs a
+region that only meshes draw by its emitted hull, so a neighbour may sit inside its
+rectangle where the hull is not, with the padding kept between footprints; a region
+attachment stays its rectangle. rigc gates the result on the packed pages with
+`A49_PACKED_FOOTPRINTS_DO_NOT_OVERLAP` (SKIP on the compile pass, where every part has
+its own page; PASS on the packed pass, both shapes, both examples). The pack line ends
+`, shape rect` or `, shape polygon` under either, and `check.json`'s `pack_mode` records
+both flags. Measured on the two examples with spine-rigc 2.1.3 (the full entry,
+spine-core 4.3.13 beside it), `spine-parts build` with `--page-edges free` and each
+shape, the table columns by `tools/atlas_population.ts`:
+
+| build | page | page area | covered | page opaque | page / figure |
+| --- | --- | --- | --- | --- | --- |
+| demo, `rect` | 967x1338 | 1,293,846 | 91.2 % | 59.7 % | 1.636 |
+| demo, `polygon` | 922x1348 | 1,242,856 (−3.9 %) | 95.0 % | 62.1 % | 1.571 |
+| sample, `rect` | 479x1166 | 558,514 | 93.4 % | 53.9 % | 1.755 |
+| sample, `polygon` | 477x1151 | 549,027 (−1.7 %) | 95.0 % | 54.8 % | 1.725 |
+
+Covered is Σ region rectangles over page area, as rigc prints it; under `polygon` the
+rectangles may overlap where a hull leaves room, so it is not a union and can exceed
+100 %. Page opaque is the measure of what the page holds. Under `--page-edges pot` the
+shape changes nothing on these two examples: both shapes write 1024x2048 and 512x2048,
+and the idle frames are identical.
+
+The cost, from `rect` to `polygon` (the idle `check` renders, `rigc render --animation
+idle --fps 12 --max 640`, compared frame by frame, max over R, G, B and A):
+
+| example | idle frames that differ | pixels that differ (all 49 frames) | max \|d\| |
+| --- | --- | --- | --- |
+| demo | 49 of 49 | 2,594 | 1 |
+| sample | 49 of 49 | 740 | 1 |
+
+That is the class `free` already costs (the table above, measured by the same
+comparison), a little larger. No figure in `check.json` moved but `pack_mode`: every
+bar, every status and every reported figure is the same under both shapes.
+`--pack-shape rect` gives back the page and atlas 0.7.0 wrote: on both examples
+they are byte-identical to rigc 2.0.3's `--page-edges free` build of the same rig (the
+skeleton JSON differs only in its relative `images` path), and selftest `CK53` holds
+`rect` to rigc's own rectangle page.
+
+The hull ceiling (spine-parts #58: hull area over rectangle area, 0.812 on demo and
+0.814 on sample) is not what the packer realises here: the hollows inside the meshes'
+rectangles are worth only what fits into them. On the polygon pages, read off the
+atlas, demo's packed rectangles overlap in 21 pairs (17 a region attachment inside a
+mesh's rectangle, 4 a mesh inside another's) and sample's in 12 (10 and 2); no two
+region attachments overlap. More would take tighter hulls, meshes in place of
+regions, or a stronger nesting search in rigc, each its own card.
+
 `--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`
@@ -357,8 +411,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 +642,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.1.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 |
@@ -601,8 +656,9 @@ 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` |
+| `CHECK_PACK_LINE_READS` | rigc printed a `pack:` line that is not `pack: <page> <W>x<H>, <N> region(s), <P>% covered, padding <D>`, then `, page edges free` or nothing, then `, shape rect`, `, shape polygon` or nothing (spine-rigc 2.1 prints the shape; 1.5–2.0 printed none, read as `rect`); an unknown shape is this refusal; 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` clause 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` |
+| `CHECK_PACK_SHAPE` | the pack line disagrees with the `--pack-shape` the build was run with — it ends `, shape rect` under `polygon` or `, shape polygon` under `rect`, or it has no shape clause (the 1.5–2.0 form, read as `rect`) under `polygon` | a rigc older than 2.1.0 on `PATH`: rigc 2.0.3 takes `--pack-shape` without a word, packs by rectangles and prints the form with no shape clause, so this refusal is what catches it — `bun install` (this package depends on spine-rigc ^2.1.3); otherwise 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
@@ -611,14 +667,19 @@ 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`; rigc
+  2.1.3: the same 14 among the build's 24, which adds
+  `A49_PACKED_FOOTPRINTS_DO_NOT_OVERLAP` on the packed pass, 16 not in `spine`; `CH09`
+  holds it on every fetched example);
 - **seam**: the setup-pose render against the flat composite of `parts/`: mean
   max-channel |d| ≤ 1.0 of 255, and at most 50 pixels over 40;
 - **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.8.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.1.3"
   },
   "devDependencies": {
+    "@esotericsoftware/spine-core": "4.3.13",
     "@types/bun": "^1.4.2",
     "eslint": "^10.11.0",
     "typescript": "^5.9.3",