spine-rigc 0.24.0 → 0.25.1

package/README.md

@@ -503,7 +503,7 @@ commands take it and what its default is.
 | `build … --pack` | the same build with every part arranged onto **shared** atlas pages, written into `--out` — losslessly, and gated a second time as the pair that ships. `--page-size` and `--padding` tune it |
 | `build … --atlas-in <file.atlas>` | the same build with every part resolved to a **region of an existing pack** instead of a loose PNG; a name the atlas lacks, a size the spec disagrees with or a rectangle off its page is refused by name |
 | `validate <dir>` | re-gates artifacts already on disk |
-| `ingest <skeleton.json> --out <dir>` | `build` run backwards: reads a Spine 4.3 skeleton and writes the rig spec and motion spec that **rebuild it**, plus a findings report naming everything it could not carry. `--stage x,y,w,h` supplies the one value a skeleton does not hold, and `--images <dir>` writes the spec's own images directory — the opposite direction from `build --images`, which overrides it — so the rebuild carries no flag at all |
+| `ingest <skeleton.json> --out <dir>` | `build` run backwards: reads a Spine 4.3 skeleton and writes the rig spec and motion spec that **rebuild it**, plus a findings report naming everything it could not carry. `--stage x,y,w,h` supplies the stage for a skeleton that declares none — and is refused, rather than ignored, beside one that declares a box — and `--images <dir>` writes the spec's own images directory — the opposite direction from `build --images`, which overrides it — so the rebuild carries no flag at all |
 | `explain --rig … --motion …` | the compiled rig as a table — every bone with its resolved parent, the slots in draw order, every timeline key by key. Writes nothing. What to reach for when a rig compiles and still looks wrong |
 | `render --candidate <dir>` | PNG frames plus a contact sheet, in `render/` |
 | `preview --candidate <dir>` | one self-contained `.html` that plays it |
@@ -539,7 +539,7 @@ rebuild it. It is the only command that runs against `build`'s direction, and th
 only one whose contract is an equality rather than a rulebook:
 
 ```bash
-rigc ingest hero.json --out specs/ --stage 0,0,1024,768 --images parts/
+rigc ingest hero.json --out specs/ --images parts/
 rigc build --rig specs/rig.json --motion specs/motion.json --out build/
 rigc diff build/skeleton.json hero.json
 ```
@@ -580,7 +580,10 @@ One thing it drops on purpose and says so: a path attachment's `lengths`, which
 - **The stage.** `skeleton.width`/`height`: rigc always writes one, and a skeleton that
   carries none is refused by name unless `--stage x,y,w,h` supplies it. It is not
   derivable — posing the rig gives the *animated* extent, which is a different number
-  from the setup box. ⚠️ This said *"an editor export carries none"* until #594 measured
+  from the setup box. ⛔ **And `--stage` beside a box the file already states is refused
+  too**, for the opposite reason: two sources for one value, where the file is the record
+  of what was measured. It used to be read after the box and therefore never
+  ([#626](https://github.com/firejune/rigc/issues/626)). ⚠️ This said *"an editor export carries none"* until #594 measured
   it: **all twelve exports in the example corpus carry a stage** and none of them needs
   the flag. It is still the value that costs least to get wrong, because `diff` reports
   the box and gates nothing on it.
@@ -613,7 +616,12 @@ export, every `diff` measure that moved, `check`'s mean MAE and worst drift per
 animation **for each skin the build declares** — one render-and-check block per
 skin, with a per-skin roll-up under them, because a rig's contested art lives in
 its named skins and a single un-skinned check draws none of it — and a
-field-by-field list of what the editor rewrote. On its first
+field-by-field list of what the editor rewrote. Every step quotes what its child
+said when that child did not do what it was for, the renderers included; a skin
+**neither** side can draw — a hit-box rig, say — is a **SKIP** naming that, not a
+red, because `check` had nothing to compare and `diff` and `validate` have
+already measured the rig. One side drawing where the other does not is the
+divergence the trip exists to find and stays a failure. On its first
 run it found three emitter defects — [#368](https://github.com/firejune/rigc/issues/368),
 [#369](https://github.com/firejune/rigc/issues/369),
 [#370](https://github.com/firejune/rigc/issues/370) — and then showed that a

package/cli.ts

@@ -67,7 +67,7 @@ import {
   type DeformSpan,
 } from './src/deformmeasure.ts';
 import { diffLines, diffSkeletons, reportedFigures, sectionFigures, type DiffReport } from './src/diff.ts';
-import { ingest, type IngestFindingKind, type IngestStage } from './src/ingest.ts';
+import { ingest, IngestError, type IngestFindingKind, type IngestStage } from './src/ingest.ts';
 import { copyAtlasImages } from './src/emit.ts';
 import { DEFAULT_PADDING, DEFAULT_PAGE_SIZE, packAtlas } from './src/atlas.ts';
 import { parseJsonWithPosition } from './src/json-position.ts';
@@ -2961,9 +2961,13 @@ const FLAG_MEANINGS: Record<string, string> = {
     '--images <dir>` on every rebuild), `none` states width/height only for `build --atlas-in <pack>` to ' +
     'resolve (default: loose)',
   stage:
-    "the setup bounding box — `skeleton.x,y,width,height`. An editor export carries none and rigc refuses a " +
-    'compile without one; posing the rig gives the ANIMATED extent, which is a different number, so this is the ' +
-    "caller's value and is never derived. Without it the missing stage is reported as a blocker",
+    'the setup bounding box — `skeleton.x,y,width,height` — for a skeleton that declares none. It cannot be ' +
+    'derived: posing the rig gives the ANIMATED extent, which is a different number from the setup box, so this ' +
+    "is the caller's value, and without it the missing stage is reported as a blocker. ⚠️ An editor export MAY " +
+    'carry none; every editor export measured for this project carries one and ingest reads it straight through, ' +
+    'so the flag is for a file that really has none rather than for editor exports as a class. ⛔ Beside a ' +
+    'skeleton that already declares a box it is REFUSED rather than ignored: two sources for one value, and the ' +
+    'file is the record of what was measured',
   help: "show this command's flags and exit",
 };
 
@@ -3308,13 +3312,15 @@ const USAGE = [
   'ingest runs build backwards: it reads a Spine 4.3 skeleton.json and writes the rig',
   'spec and motion spec that rebuild it, so an existing skeleton becomes a starting',
   'point instead of something to retype:',
-  '  rigc ingest hero.json --out specs/ --stage 0,0,1024,768   rig.json + motion.json',
+  '  rigc ingest hero.json --out specs/ --images parts/         rig.json + motion.json',
   'The contract is an equality, not a rulebook: build(ingest(x)) is x, byte for byte.',
   'It reads the skeleton and nothing else — no .spine project, no binary .skel, no',
   'atlas — so two things are the caller\'s and are refused rather than guessed: the',
-  'setup stage (--stage; an export carries none) and how the spec reaches the art',
-  '(--art). --images <dir> is the third and the only optional one: it WRITES the rig',
-  'spec\'s own images directory, relative to --out, so the rebuild needs no flag.',
+  'setup stage (--stage, only when the skeleton itself declares none — beside a box the',
+  'file states, the flag is refused rather than ignored) and how the spec',
+  'reaches the art (--art). --images <dir> is the third and the only optional one: it',
+  'WRITES the rig spec\'s own images directory, relative to --out, so the rebuild needs',
+  'no flag.',
   'Everything the spec format cannot hold is printed as a named finding and',
   'exits non-zero, with both files still written, because a spec plus a list of what',
   'is missing from it beats no spec at all.',
@@ -3428,5 +3434,15 @@ try {
     console.error(`rigc chainfit: ${err.message}`);
     process.exit(2);
   }
+  // A usage error in kind — an option that contradicts the file it was given —
+  // and exit 2 for that reason rather than 1: nothing was compiled and nothing
+  // was written, so it is the invocation that has to change (issue #626). It is
+  // raised in `src/ingest.ts` rather than here because the library caller who
+  // passes the same contradiction deserves the same refusal, and one rule in one
+  // place is what stops the two from drifting apart.
+  if (err instanceof IngestError) {
+    console.error(`rigc ingest: ${err.message}`);
+    process.exit(2);
+  }
   throw err;
 }

package/docs/AUTHORING.md

@@ -362,7 +362,7 @@ Everything above starts from two spec files you wrote. `rigc ingest` starts from
 an existing rig is a starting point instead of 250 KB of arrays to retype.
 
 ```bash
-bun cli.ts ingest hero.json --out specs/ --stage 0,0,1024,768 --images parts/
+bun cli.ts ingest hero.json --out specs/ --images parts/
 #   ..    out  /abs/path/specs
 #   ..    art  loose
 #   ..    images ../parts/  (the rig spec's own, from /abs/path/specs)
@@ -397,7 +397,7 @@ repository builds on every run.
 | `--art loose` (default) | name an `image` per attachment — `<path or placeholder>.png` — so the rebuild resolves loose PNGs and rigc measures them |
 | `--art none` | state `width`/`height` only, so the rebuild is `build --atlas-in <pack.atlas>` and every part resolves out of the pack |
 | `--images <dir>` | **write** the rig spec's own `images` directory, spelled relative to `--out`, so the rebuild is a plain `build --rig … --motion … --out …`. Without it the field is left out and every `image` resolves against `--out` itself, which holds the specs and no art — so every rebuild has to repeat `build --images <dir>`. Refused together with `--art none`, which writes no `image` for it to be the base of |
-| `--stage x,y,w,h` | the setup bounding box. **Required for an editor export**, which carries none |
+| `--stage x,y,w,h` | the setup bounding box, **for a skeleton that declares none**. An editor export *may* be one; every export under `examples/` carries a box and `ingest` reads it straight through — so passing the flag at one of them is **refused**, naming both boxes, rather than silently doing nothing ([#626](https://github.com/firejune/rigc/issues/626)) |
 | `--name <n>` | the rig spec's `name`, which the motion spec's `archetype` must equal (default: the file's basename) |
 
 ⚠️ **`ingest --images` and `build --images` point opposite ways.** `build --images`
@@ -407,13 +407,36 @@ they name the same field — and `ingest` spells the value with the same functio
 `build` spells `skeleton.images` with, so a spec and the skeleton it came from say
 where the parts are in one convention.
 
-🚨 **The stage is the one value `ingest` will not guess.** rigc always emits
-`skeleton.width`/`height` and an editor export never does, so a foreign file needs
-`--stage`; without it the missing box is a **blocker**, named. It is not derivable —
-posing the rig gives the *animated* extent, which is a different number from the
-editor's setup box — and it is the value that costs least to get wrong, because no
-measure `diff` reports reads the skeleton header at all. Supply it from the project
-the file came from, or from the editor's own canvas.
+🚨 **The stage is one of the two values `ingest` will not guess.** A skeleton JSON
+*need not* carry `skeleton.width`/`height`, and when it does not rigc cannot derive
+one — posing the rig gives the *animated* extent, which is a different number from the
+editor's setup box. So a file that declares none is a **blocker**, named, unless
+`--stage x,y,w,h` supplies it; supply it from the project the file came from, or from
+the editor's own canvas.
+
+⛔ **The flag is refused beside a box the file states.** Two sources for one value, and
+the file is the one that was measured — so `ingest` names both boxes and stops rather
+than writing one of them and saying nothing. Drop the flag, or correct `skeleton` in the
+source if its box is wrong ([#626](https://github.com/firejune/rigc/issues/626)). What
+it does **not** do is refuse an *omitted origin*: inside a declared extent an omitted
+`x`/`y` is `0` — the reading `build` emits and `diff` compares
+([#620](https://github.com/firejune/rigc/issues/620)) — so the written spec states it
+and a `LOSS HEADER_ORIGIN` line says the source omitted it and that the rebuild will
+spell it ([#622](https://github.com/firejune/rigc/issues/622)).
+
+⚠️ **This said an editor export "never" carries one until
+[#594](https://github.com/firejune/rigc/issues/594) measured the corpus.** All twelve
+exports under `examples/` declare `x`, `y`, `width` and `height`, `ingest` takes the
+early return on every one of them, and not one needs the flag. What an editor export
+*may* do is carry none: a rigc build that declares no stage
+([#578](https://github.com/firejune/rigc/issues/578)) came back from a Spine 4.3.26
+round trip with a header of `hash`, `spine`, `images`, `audio` and **no box at all** —
+the editor preserves the absence rather than inventing a stage
+([#616](https://github.com/firejune/rigc/issues/616)). So `--stage` is for a file that
+really has none, and this repository's corpus holds no example of one. It is still the
+value that costs least to get wrong: `diff` reports the box as `stage_present` and
+`stage_box` ([#578](https://github.com/firejune/rigc/issues/578)) and both are
+`(reported)`, so nothing on the ladder consults them.
 
 ⚠️ **The duration is a convention, and it is recorded as one.** Skeleton JSON has no
 duration field. The largest key time is the only derivable answer and it is what a
@@ -430,7 +453,7 @@ the first:
 | --- | --- |
 | `BLOCK` | the spec format cannot say it, so the rebuild will **not** be the file that was read — `linkedmesh`, `point`, an attachment `sequence`, an unknown field on a bone, slot or constraint, a timeline family the motion spec has no track for. The command exits non-zero **and still writes both specs**, because a spec plus a list of what is missing from it beats no spec |
 | `JUDGE` | the skeleton cannot answer and somebody has to: the stage, and each animation's duration |
-| `LOSS` | the skeleton says it and rigc re-derives it, on purpose. A path attachment's `lengths` is the one that matters — it is `PathConstraint`'s own four-sample measurement rather than an arc length (#560), so a transcribed one would freeze whatever produced the source |
+| `LOSS` | the skeleton's spelling and rigc's differ, on purpose, and the line says how. A path attachment's `lengths` is the one that matters — it is `PathConstraint`'s own four-sample measurement rather than an arc length (#560), so a transcribed one would freeze whatever produced the source. The header ones are cheaper: `HEADER_BOOKKEEPING` for a field the spec has no home for, `HEADER_REDERIVED` for the version string, `HEADER_ORIGIN` for an origin the source left to the format and the rebuild writes out (#622) |
 
 📝 **Do not delete the `note`.** Both written specs carry one saying the file is
 decompiled and naming the skeleton it came from. A decompiled spec is
@@ -822,7 +845,17 @@ Three readings stay apart, and the middle one is the point of the other two:
 reports **SKIP** on one, because there is no full frame for a mesh to span. And
 `rigc diff` reports it — `skeleton.stage_present` and `skeleton.stage_box`, in the
 header block at the top of the report — so a stage somebody invented now reads
-below 1.000 against a source that has none. Both are reported and gate nothing, for
+below 1.000 against a source that has none.
+
+⭐ **A stage at `0,0` is not a stage-less one, and an editor export spells it by
+saying nothing.** The editor omits a header field that is at its default, so a
+skeleton whose box sits at the origin exports as a `width` and a `height` with no
+`x`/`y`; `stage_box` reads that omission as the `0` it means, and its line says so
+— *the extent as stated, an omitted origin as the 0 it means*. So `4/4` on a build
+of yours against an export of that same build is the right answer rather than a
+tolerance, and an origin that really did move still reads below 1.000. The extent
+is the half that is read exactly as stated: omit a `width` and you have declared no
+stage, which `stage_present` is the measure of. Both are reported and gate nothing, for
 the reason every reported measure is: no reading of the rendered frames could have
 decided a setup-pose bounding box. The measure inventory that says so lives in
 [BENCHMARK.md](https://github.com/firejune/rigc/blob/main/docs/BENCHMARK.md), which
@@ -927,7 +960,12 @@ pointing into it is not.
 ⚠️ **`rigc render` still refuses such a build**, by name and before it draws
 anything: `… posed no drawable attachment in any animation or in its setup pose —
 there is nothing to draw`. That is the honest division — the rig is valid Spine
-data, and there is no picture of it.
+data, and there is no picture of it. `rigc check` says the same thing one step
+on, since it has no frames to compare; `tools/editor_roundtrip.ts` quotes both
+renderers and reports its step 5 as a **SKIP** naming that, and the round trip
+comes back green on the strength of `validate` and `diff`
+([#621](https://github.com/firejune/rigc/issues/621)). A skin only **one** side
+can draw is the other case entirely, and stays red.
 
 **Region attachment** ([Spine: region attachments](http://esotericsoftware.com/spine-regions)),
 the default `type`:

package/docs/FACE.md

@@ -1403,6 +1403,15 @@ shift through the vertex's coordinate instead of its index, so the next
 renumbering cannot move it. A `vertices` run is positional by format — that is
 `fromVertex`'s whole job — and a *generator* of one has no reason to be.
 
+🔒 **And that repair is now measured rather than asserted.** `bun run selftest`
+runs this script again against a rig whose vertices have been renumbered every
+way the compiler accepts — the outline rotated along its own walk, the outline
+reflected, the interior reordered — and requires the run it writes to come back
+as the same geometry once the renumbering is undone, while the run's own
+positions have visibly moved. Nothing here declares that property: the subject
+is any script on any page whose product is a `vertices` run, read off the
+product.
+
 **What comes back from both:**
 
 | | good | (a) one band inverted | (b) mesh folded |

package/docs/INGEST.md

@@ -253,7 +253,7 @@ rigc diff
 
   skeleton (reported)   (no mean)   over 2 measures  — the stage, which no reading of the frames could decide
       1.000  stage_present                1/1         both sides declare a setup-pose stage, or neither does  — …
-      1.000  stage_box                    4/4         the stage is the same box (x, y, width, height, exactly as stated)  — …
+      1.000  stage_box                    4/4         the stage is the same box (x, y, width, height — the extent as stated, an omitted origin as the 0 it means)  — …
 
   bones                 mean 1.000  over 8 measures
       1.000  count                        3/3         how many bones
@@ -288,12 +288,31 @@ units and every one of the 49 measures still reads **1.000**. ⇒ Never take a g
 `diff` as evidence that a geometric edit did not land, and never take it as evidence
 that one did.
 
+⚠️ **The corpus gate has a value-level measure and this command does not expose it**
+(§2.3, and `docs/BENCHMARK.md`'s *The nine value measures*). The reason is an input
+rather than a policy: comparing values means reading both files through `spine-core`,
+and a skeleton whose attachments carry a `sequence` cannot be parsed without the atlas
+that resolves it — so the measure takes two skeletons **and two packs**, which
+`rigc diff <a.json> <b.json>` does not have. The sentence above is about this command
+and stays true of it.
+
 ⚠️ **The one exception is the skeleton's own declared box**, and it is an exception to
 the sentence and not to the rule: `skeleton.stage_box` compares four world numbers,
-but they are numbers an exporter *wrote into the header* rather than a pose anything
+but they are numbers an exporter *declared in the header* rather than a pose anything
 measured, and the block they sit in gates nothing. Moving a pivot does not move them
 either.
 
+⭐ **Declared is not the same as written down, and for the origin it is the
+difference between a green round trip and a false finding**
+([#620](https://github.com/firejune/rigc/issues/620)). The editor omits a header
+field at its default, so a stage sitting at `0,0` exports as a `width` and a
+`height` and no `x`/`y` at all — there is no other spelling for it. The measure
+reads that omission as the `0` it means, which is why a rigc build whose stage is at
+the origin and its own export of that build read `stage_box` **4/4**; reading the
+four "exactly as stated" scored the same box **2/4**. The extent is still read
+exactly as stated: it is what decides whether there is a stage at all, so a missing
+`width` is an absent stage rather than a stage of width zero.
+
 ⛔ **And its ratios are not a score.** [`src/diff.ts`](../src/diff.ts) says so in the
 type itself (*"Unweighted mean of the measures below. NOT a quality score"*), and the
 report repeats it at the foot. It measures *agreement with a particular reference*,
@@ -437,16 +456,21 @@ a file rigc did not write.
 them** ([#594](https://github.com/firejune/rigc/issues/594)). Every
 `examples/*/export/*.json` is ingested with `--art none`, rebuilt through the pack
 beside it, and `diff`ed against the file it was read from: **12 of 12 come back with 0
-blockers and 1.000 on all 49 ratio-bearing measures and all 5 reported ones.** Byte
+blockers and 1.000 on all 49 ratio-bearing measures and all 5 reported ones** — and,
+since [#615](https://github.com/firejune/rigc/issues/615), on all **nine value
+measures** too, over **193,927** compared values. Byte
 identity is not the claim there and the reason is the input, not the round trip — §2.3
-has the three kinds of difference, measured. ⚠️ Which pack is "the one beside it" is
+has the three kinds of difference, measured, and what the value measures do and do not
+reach. ⚠️ Which pack is "the one beside it" is
 resolved rather than guessed, for §0.2's reason: `spineboy/export` holds two, and
 `spineboy-run.atlas` covers neither skeleton in it.
 
 **What it will not do is invent.** Everything the spec format cannot hold is a
 finding with a code — `BLOCK` for a construct the rebuild will be missing, `JUDGE`
-for the two values a skeleton does not carry, `LOSS` for the one number rigc
-re-derives on purpose. A blocker exits non-zero and still writes both files.
+for the two values a skeleton does not carry, `LOSS` wherever the source's spelling and
+rigc's differ on purpose (a number rigc re-derives, a field the spec has no home for, or
+a default the source left to the format and the rebuild writes out). A blocker exits
+non-zero and still writes both files.
 
 **Two values are not in a skeleton**, so `ingest` asks rather than guesses:
 
@@ -461,7 +485,11 @@ re-derives on purpose. A blocker exits non-zero and still writes both files.
   reports it as two measures of its own (`stage_present`, `stage_box`, since
   [#578](https://github.com/firejune/rigc/issues/578)) and they are `(reported)`, so
   nothing on the ladder reads them and an absurd box is green nearly everywhere. The
-  corpus half of the selftest's `IG` suite is the one gate that does read them;
+  corpus half of the selftest's `IG` suite is the one gate that does read them. ⛔ **The
+  flag is refused beside a box the file states** — two sources for one value, both named,
+  and the file is the record of what was measured
+  ([#626](https://github.com/firejune/rigc/issues/626)). It used to be read only *after*
+  the file's box, so `--stage` at any of the twelve did nothing and said nothing;
 - **each animation's duration** — the format has no such field. The largest key time
   is used, stated in the motion spec's `note`, and recorded as a finding per
   animation. Edit it if you know the real number.
@@ -598,15 +626,46 @@ rebuild against its source produces differences of exactly three kinds, in every
 | Kind | Example, candidate vs reference | Why |
 | --- | --- | --- |
 | **header bookkeeping**, 3 per file | `skeleton.hash: undefined vs "VFWbaK2UoCM"`, `skeleton.audio: undefined vs null`, `skeleton.spine: "4.3.13" vs "4.3.75-beta"` | the rig spec has no field for `hash` or `audio`, and the version is the runtime rigc links. `ingest` reports all three as findings — `HEADER_BOOKKEEPING` and `HEADER_REDERIVED` |
-| **an omitted default written out** | `…rotate[0].time: 0 vs undefined` | the editor omits a zero `time`; rigc writes it. AUTHORING §10.5's *do not imitate the exporter's omissions*, from the other side |
+| **an omitted default written out** | `…rotate[0].time: 0 vs undefined` | the editor omits a zero `time`; rigc writes it. AUTHORING §10.5's *do not imitate the exporter's omissions*, from the other side. The header has one of these too and it is the one `ingest` now names: a stage at the origin is written `width`/`height` with no `x`/`y`, and the rebuild spells both — `LOSS HEADER_ORIGIN`, with the box unchanged ([#622](https://github.com/firejune/rigc/issues/622)). No file in this corpus takes that branch: all twelve declare an origin away from 0 |
 | **the emitted precision** | `…curve[0]: 0.066667 vs 0.06666667`, `uvs[0]: 0 vs 2.554152e-7` | rigc emits six decimals |
 
 ⇒ **So the corpus gate is `diff` at 1.000 rather than a byte comparison**, and it is
 worth being exact about what that does and does not cover. `diff` compares structure —
 counts, names, parentage, order, timeline kinds, key counts, curve kinds — and **not
 the values inside the keys**, which is why the precision row above is invisible to it.
-On rigc's own rigs byte identity covers both; on a foreign export the values are held
-by `check` (pixels) or by nothing, depending on what you render.
+On rigc's own rigs byte identity covers both; on a foreign export it used to be
+`check` (pixels) or nothing, depending on what you render.
+
+⭐ **The values are gated now, and by a second measure rather than by `diff`**
+([issue #615](https://github.com/firejune/rigc/issues/615)). Structure at 1.000 is
+silent about the numbers inside it: a decompiler that halved every rotation, dropped
+every bone's `length` or mirrored every vertex would read 1.000 on all 49 measures and
+on every `(reported)` one. So the corpus round trip also compares **value by value**,
+with the format's defaults taken from the parser rather than from a table — both files
+are read through `spine-core` and the parsed forms are compared path by path, under a
+tolerance that is the sum of rigc's own 1e-6 emitted grid and one float32 step of the
+runtime's storage. Nine measures, printed on `IG16`'s own line and gated there — here
+is the `6-arcs` export's, wrapped to fit this page:
+
+```
+values: 9/9 measure(s) at 1.000 over 13865 compared value(s); skeleton 1.000 ·
+bones 1.000 · slots 1.000 · attachments 1.000 · constraints 1.000 · events 1.000 ·
+key_times 1.000 · key_values 1.000 · curves 1.000
+```
+
+Over the whole corpus that is **193,927 values** compared, and the twelve read 1.000
+on all nine.
+
+`docs/BENCHMARK.md`'s *The nine value measures* is the full statement. What it still
+does **not** cover, in the same breath:
+
+| Still uncovered | Why |
+| --- | --- |
+| `version` and `hash` | the rig spec has no field for either, and `ingest` reports both as findings — the header row above, unchanged |
+| anything below one float32 step | the parser stores frames, curves and vertices in a `Float32Array`, so a difference it cannot represent is invisible to any reading of the parsed form |
+| a Bezier's handles *as written* | the parser samples them into the curve, so a moved handle arrives as moved samples rather than as the handle it was |
+| how the file is **spelled** | field order, an omitted default written out, six decimals against eight — the second and third rows of the table above are values that agree, and this measure says so |
+| how it **looks** | that is `check`, and `--texture-from` is how its figure is attributed |
 
 The geometric row needs a real number, because a naive reading of `check` makes an
 exact transcription look wrong. Here is the 3-timing transcription against frames

package/docs/SPEC_COVERAGE.md

@@ -1052,7 +1052,7 @@ Nothing structurally new (attachment timeline, blend, inherit all arrived by run
 | (a) | **Transform constraints** — 🔴 first appearance (4). Full 4.3 `source` + `properties{from→to}` model (§1.4), which is the least-documented constraint in the format. ✅ Expressible and round-trips exactly; `RigTransformConstraint` already carried the 4.3 shape |
 | (a) | **Weighted meshes from authored geometry** — 🔴 first appearance. ~~rigc can emit weighted meshes, but only from `buildRingMesh`/`buildRibbonMesh`. An arbitrary 40-vertex/38-triangle mesh cannot be expressed~~ ⚠️ **This was wrong.** `RigMeshAttachment` takes authored `uvs`/`triangles`/`vertices`/`hull`, and `buildRigMesh` copies them verbatim. Both of 6-arcs' meshes round-trip to 1e-5 |
 | (a) | Mesh **`edges`** key ~~(rigc emits `hull` but not `edges`)~~ ✅ emitted from `RigMeshAttachment.edges` and byte-identical to the reference. 🚨 But **nothing measures it** — deleting `edges` from the rig still scores 1.000 on all nine attachment measures, so this rung's own gating feature is invisible to `bench` (issue #46) |
-| (b) | Mesh geometry as data — vertices, triangles, uvs, per-vertex bone weights — instead of a generator name plus a polygon. ✅ Present. ~~🚨 But the weights bind bones by **index into the emitted bone array**, not by name — inserting a bone rebinds every vertex with the gate still green (issue #45)~~ ✅ **Fixed.** Weights bind **by name** (`weights: [[{ bone, x, y, weight }, …], …]`) and the compiler resolves them at emit; an unknown name is a `CompileError` (selftest `R08`). Spine's index run survives behind an explicit `"boneIndexing": "raw"`, whose cost — silence — `MR07` still measures |
+| (b) | Mesh geometry as data — vertices, triangles, uvs, per-vertex bone weights — instead of a generator name plus a polygon. ✅ Present. ~~🚨 But the weights bind bones by **index into the emitted bone array**, not by name — inserting a bone rebinds every vertex with the gate still green (issue #45)~~ ✅ **Fixed.** Weights bind **by name** (`weights: [[{ bone, x, y, weight }, …], …]`) and the compiler resolves them at emit; an unknown name is a `CompileError` (selftest `RF08`). Spine's index run survives behind an explicit `"boneIndexing": "raw"`, whose cost — silence — `MR07` still measures |
 | (c) | **A20** (unweighted forbidden) is satisfied here. ~~Under `--profile spine-html` its extra clause fires 11 times instead — the editor writes zero-weight bindings and that profile forbids them~~ ✅ **Fixed with #44**: both of A20's policy clauses are statements about what a rigc *generator* produces, so neither applies to authored geometry. Its coherence clauses — present, in range, summing to 1 — still do, in every profile |
 | (c) | **A21_MESH_RIM_PINNED** and **A28** encode ring/ribbon topology and will fire on an arbitrary mesh. ~~✅ **Confirmed**: A21 fires 40 times on the `tail` mesh under the default profile, because `meshKinds` has no entry for an authored mesh and the lookup falls back to `'ring'`~~ ✅ **Fixed** (issue #44): `meshKinds` has a third state, `authored`, and both assertions SKIP on one with that as the reason. The whole transcription is green under the default profile; selftest `MR08` holds it |
 | (c) | A13's mesh budget (≤4 slots, ≤80 tris) is **satisfied** at this rung (2 slots, max 38 tris) |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spine-rigc",
-  "version": "0.24.0",
+  "version": "0.25.1",
   "description": "Rig compiler for Spine — declarative rig specs in, Spine 4.3 skeleton data out, verified by a spine-core round-trip. Built so AI agents can author rigs and check their own work; the output imports into the Spine editor.",
   "type": "module",
   "bin": {

package/skills/ingest/SKILL.md

@@ -29,14 +29,16 @@ not do for you.
 ## Start here: `rigc ingest`
 
 ```bash
-rigc ingest hero.json --out specs/ --stage 0,0,1024,768
+rigc ingest hero.json --out specs/
 rigc build --rig specs/rig.json --motion specs/motion.json --images parts/ --out build/
 ```
 
 It reads the skeleton — **only** the skeleton — and writes the rig spec and motion
-spec that rebuild it, byte for byte. Two values are not in the file and it refuses
-rather than guessing them: the **stage** (`--stage`, an editor export carries none)
-and each animation's **duration** (the largest key time, recorded as a finding).
+spec that rebuild it, byte for byte. Two values it refuses rather than guessing: the
+**stage** (`--stage`, for a skeleton that declares none — an editor export *may* be
+one, though every one in the example corpus carries a box, and passing the flag at a
+file that declares a box is refused rather than ignored) and each animation's
+**duration** (the largest key time, recorded as a finding).
 Read `findings.json`: a `BLOCK` line means the rebuild will be missing something and
 the command exits non-zero. Keep the `note` both specs carry. INGEST §2.0.