spine-rigc 0.24.0 → 0.25.0

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 `--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 |
@@ -613,7 +613,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

@@ -2961,9 +2961,11 @@ 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',
   help: "show this command's flags and exit",
 };
 
@@ -3312,9 +3314,10 @@ const USAGE = [
   '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) 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.',

package/docs/AUTHORING.md

@@ -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 |
 | `--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,26 @@ 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.
+
+⚠️ **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
@@ -822,7 +835,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 +950,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/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,9 +456,12 @@ 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.
 
@@ -605,8 +627,39 @@ rebuild against its source produces differences of exactly three kinds, in every
 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.0",
   "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

@@ -34,9 +34,10 @@ rigc build --rig specs/rig.json --motion specs/motion.json --images parts/ --out
 ```
 
 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 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.
 

package/src/diff.ts

@@ -66,6 +66,11 @@
  * instrument — [`bonedist.ts`](bonedist.ts), the ladder's stage 3.
  */
 import { walkTimelines } from './timelines.ts';
+// Type only, and erased: the values themselves are read by `skeletonValues` in
+// `src/validate.ts`, which is one of the three modules CLAUDE.md allows to link
+// spine-core. This file stays what its header says it is — see
+// `diffSkeletonValues` for why the reading and the comparing are split there.
+import type { SkeletonValue } from './validate.ts';
 
 type Json = Record<string, unknown>;
 
@@ -1021,7 +1026,11 @@ function diffEvents(c: Json, r: Json): DiffSection {
  */
 interface StageFacts {
   present: boolean;
-  /** The four fields as stated, `null` where the header omits one. */
+  /**
+   * The four fields as the header MEANS them: the extent exactly as stated, and
+   * the origin of a declared stage as stated or `0` where it is omitted. See
+   * `stageFacts` for why the second half is a reading and not a fallback.
+   */
   box: Array<number | null>;
 }
 
@@ -1035,11 +1044,48 @@ const STAGE_FIELDS = ['x', 'y', 'width', 'height'] as const;
  * own. It is also what the compiler requires and what `A14_NO_FULL_FRAME_MESH`
  * and `A19_OVERLAY_PNGS_HAVE_ALPHA` measure against, so the three agree on the
  * word by construction rather than by memory.
+ *
+ * ⭐ **Inside a declared stage, an omitted `x`/`y` IS `0`** (issue #620). That is
+ * a reading of the format, not a value invented for a gap — the distinction this
+ * file lives or dies by — and four measurements carry it, none of them anybody's
+ * word for the convention:
+ *
+ * - **This tree had already decided it, one file over.** `compile.ts` assembles
+ *   the header as `header.x = rig.skeleton?.x ?? 0`, under the same guard: only
+ *   when the extent is there. So a rig spec that omits its origin emits `0`, and
+ *   reading the same omission in a file as absence made the compiler and the
+ *   comparison disagree about one value in one header. This measure is not
+ *   adopting the editor's convention so much as stopping contradicting the
+ *   emitter it is pointed at.
+ * - **The header's writer omits a field at its default.** All twelve exports
+ *   under `examples/` omit `referenceScale`, whose default the parser itself
+ *   spells two lines below the four raw assignments (`SkeletonJson.js:74`,
+ *   `getValue(skeletonMap, "referenceScale", 100)`), and none of the 389 bone
+ *   `x`/`y`/`rotation`/`shearX`/`shearY` values those same files DO write is an
+ *   explicit `0`. A stage at the origin therefore has no spelling but the
+ *   omission, so reading the omission as absence reads a value the format cannot
+ *   express.
+ * - **The binary reader supplies it unconditionally.** `SkeletonBinary.js:69-72`
+ *   reads the four as four floats with no key to be missing, so one skeleton's
+ *   origin is `0` in a `.skel` and absent in a `.json`. A measure that called
+ *   those two different boxes would be reporting the container.
+ * - **The JSON reader's silence is an oversight rather than a meaning.**
+ *   `SkeletonJson.js:70-73` is `skeletonData.x = skeletonMap.x`, a raw
+ *   assignment that overwrites `SkeletonData`'s own `0` with `undefined`. The
+ *   line beside it does the same to `fps`, whose default is `30` and which every
+ *   one of the twelve omits — so taking `undefined` for a meaning would say the
+ *   editor has never exported a frame rate.
+ *
+ * ⚠️ **The default is the ORIGIN's alone**, and the guard is the paragraph above
+ * it: the extent is what declares a stage, so defaulting it would turn the
+ * stage-less header of issue #578 into a `0x0` stage at `0,0` and answer the
+ * question instead of reading it.
  */
 function stageFacts(root: Json): StageFacts {
   const header = isObj(root.skeleton) ? root.skeleton : {};
   const box = STAGE_FIELDS.map((k) => num(header[k]));
-  return { present: num(header.width) !== null && num(header.height) !== null, box };
+  const present = box[2] !== null && box[3] !== null;
+  return { present, box: present ? [box[0] ?? 0, box[1] ?? 0, box[2], box[3]] : box };
 }
 
 /**
@@ -1047,13 +1093,20 @@ function stageFacts(root: Json): StageFacts {
  *
  * ⚠️ **The box is compared EXACTLY, and that is a measurement rather than a
  * choice.** The brief this was built from asked for "the tolerance the other
- * measures use"; `src/diff.ts` has exactly one tolerance in it — `FRAME`, one
- * sixtieth of a second, used once, for `animations.duration` — and no spatial
- * one anywhere, because this file compares no position at all (that is
+ * measures use"; the structural measures in this file have exactly one —
+ * `FRAME`, one sixtieth of a second, used once, for `animations.duration` — and
+ * no spatial one anywhere, because they compare no position at all (that is
  * `bonedist.ts`). A stage is a box an exporter *wrote down*, not a pose anybody
  * measured, so there is nothing for it to be within a tolerance *of*; inventing
  * a spatial epsilon here would be a number nobody measured, in the file whose
  * whole job is to report measured ones.
+ *
+ * ⭐ `diffSkeletonValues` (issue #615) is the second tolerance in the file and
+ * it does not weaken this one. It compares positions, so it needs one; both its
+ * terms are read off other code — rigc's own 1e-6 quantiser and the parser's
+ * float32 storage — rather than chosen here; and the four numbers above are the
+ * one place the two overlap, where `stage_box` stays the stricter reading and
+ * says so by staying exact.
  */
 function diffHeader(c: Json, r: Json): DiffReported {
   const a = stageFacts(c);
@@ -1072,7 +1125,7 @@ function diffHeader(c: Json, r: Json): DiffReported {
       ),
       measure(
         'skeleton.stage_box',
-        'the stage is the same box (x, y, width, height, exactly as stated)',
+        'the stage is the same box (x, y, width, height — the extent as stated, an omitted origin as the 0 it means)',
         agreed,
         both ? STAGE_FIELDS.length : 0,
         both
@@ -1148,6 +1201,212 @@ export function movedReportedMeasures(report: DiffReport): string[] {
     .map((m) => m.id);
 }
 
+// ---------------------------------------------------------------------------
+// The value level — what the structural measures above are blind to
+// ---------------------------------------------------------------------------
+
+/**
+ * rigc's own emitted grid. `r6` in [`compile.ts`](compile.ts) rounds every
+ * emitted number to 1e-6 and `keyTime` rounds a key time DOWN over the same
+ * step, so a rebuild of a file written with more decimals than that may sit up
+ * to one whole step from where it started — through no fault of anything this
+ * measure is looking for.
+ */
+export const VALUE_EMITTED_GRID = 1e-6;
+
+/**
+ * One float32 ULP, relative. `spine-core` holds every frame, curve sample and
+ * vertex in a `Float32Array` (`Utils.newFloatArray`), so two decimals that
+ * differ by the grid above can land on adjacent float32s, and the difference
+ * the walk sees is the decimal gap plus that step.
+ *
+ * ⚠️ It is also the floor of what this measure can see AT ALL: a difference
+ * smaller than one float32 step is invisible to the parser and therefore to
+ * this. The tolerance states that rather than hiding it.
+ */
+export const VALUE_PARSED_ULP = 2 ** -23;
+
+/**
+ * What two readings of one number are allowed to differ by, and nothing more.
+ *
+ * Both terms are derived rather than fitted: the first is rigc's own quantiser,
+ * the second is the parser's storage. Measured over the twelve editor exports
+ * in `examples/`, the widest gap between a rebuild and the file it was read
+ * from reaches **0.81** of this — so the corpus sits inside a bound that was
+ * not drawn around it.
+ */
+export function valueTolerance(magnitude: number): number {
+  return VALUE_EMITTED_GRID + VALUE_PARSED_ULP * magnitude;
+}
+
+/** Whether two readings of one path agree. `NaN` on both sides is agreement: neither file states it. */
+function valuesAgree(a: number | string, b: number | string): boolean {
+  if (typeof a !== 'number' || typeof b !== 'number') return a === b;
+  if (Number.isNaN(a) && Number.isNaN(b)) return true;
+  if (!Number.isFinite(a) || !Number.isFinite(b)) return a === b;
+  return Math.abs(a - b) <= valueTolerance(Math.max(Math.abs(a), Math.abs(b)));
+}
+
+/**
+ * The measures `diffSkeletonValues` defines, in the order it prints them, and
+ * what each one is. The set is fixed rather than derived from the paths in
+ * front of it, so that a run can say a measure compared NOTHING — the same
+ * distinction `DiffMeasure.total` draws everywhere else in this file.
+ */
+const VALUE_MEASURES: ReadonlyArray<{ id: string; what: string; prefix: string }> = [
+  { id: 'values.skeleton', what: 'the header and the setup-pose stage', prefix: 'skeleton/' },
+  { id: 'values.bones', what: 'every bone setup pose, its length and its colour', prefix: 'bones/' },
+  { id: 'values.slots', what: 'every slot colour, dark colour, blend mode and setup attachment', prefix: 'slots/' },
+  { id: 'values.attachments', what: 'every attachment offset, size, vertex, weight, uv and triangle', prefix: 'skins/' },
+  { id: 'values.constraints', what: 'every constraint pose field and flag', prefix: 'constraints/' },
+  { id: 'values.events', what: 'every event payload in the setup pose', prefix: 'events/' },
+  { id: 'values.key_times', what: 'every key time, and each animation\'s duration', prefix: 'animations/' },
+  { id: 'values.key_values', what: 'every keyed value: poses, deform vertices, draw orders, event payloads', prefix: 'animations/' },
+  { id: 'values.curves', what: 'every curve type and the Bezier samples the parser built from its handles', prefix: 'animations/' },
+];
+
+/**
+ * Which measure a path belongs to. The first path segment decides it, except
+ * under `animations/`, where the three arms are the three questions that fail
+ * differently: a timing that moved, a value that moved, and an easing that
+ * moved. A segment nothing here names becomes a measure of its own rather than
+ * disappearing into one of these — a walk that grows a top-level kind should
+ * arrive as a new line, not as a silently wider denominator.
+ */
+function valueMeasureFor(path: string): string {
+  const head = path.slice(0, path.indexOf('/') + 1);
+  if (head === 'animations/') {
+    if (path.endsWith('/duration') || /\/key\/\d+\/time$/.test(path)) return 'values.key_times';
+    if (/\/curves\/\d+$/.test(path)) return 'values.curves';
+    return 'values.key_values';
+  }
+  const known = VALUE_MEASURES.find((m) => m.prefix === head);
+  return known === undefined ? `values.${head.slice(0, -1) || path}` : known.id;
+}
+
+/** How many offending paths a note spells out before it counts the rest. */
+const VALUE_OFFENDERS_SPELLED_OUT = 3;
+
+/**
+ * The value-level comparison: are the numbers inside the structure the same
+ * numbers?
+ *
+ * ## Why it is a separate call rather than a section of `diffSkeletons`
+ *
+ * Because its inputs are not JSON. Every default in the format — `time` absent
+ * is 0, `scaleX` absent is 1, a physics key's `value` absent is 0 while its
+ * `mix` is 1 — has to be applied before two files can be compared value by
+ * value, and writing that table here would be a second spelling of the format
+ * inside the gate. So the defaults come from the parser, through
+ * `skeletonValues` in [`validate.ts`](validate.ts), and this function compares
+ * what it returns: an ordered list of `path → value` with every default already
+ * applied by the one reader that owns them.
+ *
+ * ⚠️ **It reports; it does not gate the ladder.** A rung's brief withholds
+ * coordinates on purpose, so no reading of the reference frames could decide
+ * these — `docs/GATE.md`'s *What never gates* applies word for word. The corpus
+ * gate is the one place they DO decide a verdict, and for the reason `IG16`
+ * already gives about `mesh_edges`: there the reference is the very file the
+ * specs were read from, so a value that moved is a decompiler loss rather than
+ * a candidate's entitlement.
+ *
+ * ## What a difference means, and what it cannot mean
+ *
+ * A path missing on one side is counted as unmatched and named as such: it is a
+ * structural finding too, and the measures above it are where that is
+ * diagnosed. A number present on both sides is compared under
+ * `valueTolerance`, which is derived from rigc's quantiser and the parser's
+ * float32 storage — never from the corpus.
+ */
+export function diffSkeletonValues(candidate: SkeletonValue[], reference: SkeletonValue[]): DiffMeasure[] {
+  const left = new Map<string, number | string>();
+  for (const v of candidate) left.set(v.path, v.value);
+  const right = new Map<string, number | string>();
+  for (const v of reference) right.set(v.path, v.value);
+
+  interface Tally {
+    matched: number;
+    total: number;
+    offenders: string[];
+    unpaired: number;
+  }
+  const tallies = new Map<string, Tally>();
+  const order: string[] = VALUE_MEASURES.map((m) => m.id);
+  const tallyFor = (id: string): Tally => {
+    const held = tallies.get(id);
+    if (held !== undefined) return held;
+    const fresh: Tally = { matched: 0, total: 0, offenders: [], unpaired: 0 };
+    tallies.set(id, fresh);
+    if (!order.includes(id)) order.push(id);
+    return fresh;
+  };
+  for (const id of order) tallyFor(id);
+
+  // The candidate's paths in the candidate's own order, then whatever the
+  // reference has that the candidate does not — an iteration over the two
+  // lists as they were built, never over a set.
+  for (const { path, value } of candidate) {
+    const tally = tallyFor(valueMeasureFor(path));
+    tally.total++;
+    const other = right.get(path);
+    if (other === undefined) {
+      tally.unpaired++;
+      if (tally.offenders.length < VALUE_OFFENDERS_SPELLED_OUT) tally.offenders.push(`${path} (candidate only)`);
+      continue;
+    }
+    if (valuesAgree(value, other)) {
+      tally.matched++;
+      continue;
+    }
+    if (tally.offenders.length < VALUE_OFFENDERS_SPELLED_OUT) {
+      const gap =
+        typeof value === 'number' && typeof other === 'number'
+          ? `, off by ${Math.abs(value - other).toExponential(3)} against ${valueTolerance(
+              Math.max(Math.abs(value), Math.abs(other)),
+            ).toExponential(3)} allowed`
+          : '';
+      tally.offenders.push(`${path} ${JSON.stringify(value)} vs ${JSON.stringify(other)}${gap}`);
+    }
+  }
+  for (const { path } of reference) {
+    if (left.has(path)) continue;
+    const tally = tallyFor(valueMeasureFor(path));
+    tally.total++;
+    tally.unpaired++;
+    if (tally.offenders.length < VALUE_OFFENDERS_SPELLED_OUT) tally.offenders.push(`${path} (reference only)`);
+  }
+
+  return order.map((id) => {
+    const tally = tallyFor(id);
+    const defined = VALUE_MEASURES.find((m) => m.id === id);
+    const missed = tally.total - tally.matched;
+    const note =
+      tally.total === 0
+        ? 'neither side carries one'
+        : missed === 0
+          ? undefined
+          : `${missed} moved` +
+            (tally.unpaired === 0 ? '' : `, ${tally.unpaired} of them on one side only`) +
+            `: ${tally.offenders.join('; ')}` +
+            (missed > tally.offenders.length ? `; …and ${missed - tally.offenders.length} more` : '');
+    return measure(id, defined?.what ?? 'values under a path kind this report does not define', tally.matched, tally.total, note);
+  });
+}
+
+/** Every value measure that is not a perfect match, by id. What a test asserts on. */
+export function movedValueMeasures(measures: DiffMeasure[]): string[] {
+  return measures.filter((m) => m.ratio < 1).map((m) => m.id);
+}
+
+/**
+ * `skeleton 1.000 · bones 1.000 · …`, the same one-line shape `reportedFigures`
+ * has, and with no roll-up for the same reason: a mean over "did the times move"
+ * and "did the vertices move" is a number with no referent.
+ */
+export function valueFigures(measures: DiffMeasure[]): string {
+  return measures.map((m) => `${m.id.slice(m.id.indexOf('.') + 1)} ${fmt(m.ratio)}`).join(' · ');
+}
+
 const fmt = (n: number): string => n.toFixed(3);
 
 /**

package/src/validate.ts

@@ -3952,3 +3952,271 @@ export function reportLines(report: ValidateReport): string[] {
 export function atlasDirOf(atlasPath: string): string {
   return dirname(resolve(atlasPath));
 }
+
+// ---------------------------------------------------------------------------
+// skeletonValues — the round trip read as VALUES rather than as assertions
+// ---------------------------------------------------------------------------
+
+/**
+ * One value the parser read out of a skeleton file, at a path that names it.
+ *
+ * `bones/hip/setup/rotation`, `skins/default/head/head/regionUVs/12`,
+ * `animations/walk/RotateTimeline/bone:hip/key/3/v1`. Numbers stay numbers so
+ * that a comparison can state a tolerance; everything else — a blend mode the
+ * runtime holds as an enum, an attachment name, a boolean, an absent object —
+ * is a string, and is compared exactly.
+ */
+export interface SkeletonValue {
+  /** Stable, name-keyed, and never an index into an emitted array (issue #45). */
+  path: string;
+  value: number | string;
+}
+
+/**
+ * Keys the walk below does not read, each with the reason it is not a value the
+ * file carries. It is a SKIP list rather than an include list on purpose: the
+ * field names come from the parser, so a field spine-core starts reading is
+ * compared the day it starts reading it, and the only hand-kept part is the
+ * short list of things that are demonstrably not in the file.
+ *
+ * ⚠️ `id` is the sharp one. `VertexAttachment.id` is a process-wide counter, so
+ * two parses in one process disagree about it by construction — and it reaches
+ * `DeformTimeline.getPropertyIds()`, which is why the timeline key below is
+ * built from the resolved owner rather than from the property ids.
+ */
+const NOT_A_VALUE_IN_THE_FILE: Record<string, string> = {
+  a: 'the derived world matrix',
+  b: 'the derived world matrix',
+  c: 'the derived world matrix',
+  d: 'the derived world matrix',
+  world: 'derived by the runtime',
+  local: 'derived by the runtime',
+  worldX: 'derived by the runtime',
+  worldY: 'derived by the runtime',
+  region: 'the atlas, which is not the skeleton',
+  regions: 'the atlas, which is not the skeleton',
+  uvs: 'computed from the region',
+  offsets: 'computed from the region',
+  tempColor: 'runtime scratch',
+  deform: 'runtime scratch on the setup pose',
+  id: 'a process-wide counter, not a value in the file',
+  index: 'the array position this walk already iterates by name',
+  timelineIds: 'derived from the timelines',
+  timelineSlots: 'derived from the skin',
+  properties: 'derived from the constraint',
+  propertyIds: 'carries an attachment id, which is a counter (see above)',
+};
+
+/** How deep a chain of unnamed objects may go before the walk says so and stops. */
+const VALUE_WALK_DEPTH = 10;
+
+/**
+ * Reflection over the parsed form: numbers and strings as they are, arrays by
+ * index, objects by their own keys in **sorted** order, and any nested object
+ * that carries a `name` by that name rather than by expansion — which is what
+ * makes a cross-reference (`parent`, `boneData`, `endSlot`, a constraint's
+ * `bones`) a name and terminates every cycle the runtime's back-references
+ * would otherwise walk forever.
+ *
+ * Sorted rather than insertion-ordered because `A18_DETERMINISTIC_EMIT`'s rule
+ * applies here too: nothing whose order is the runtime's business may decide
+ * what this function emits.
+ */
+function pushValue(value: unknown, path: string, out: SkeletonValue[], depth: number): void {
+  if (value === null || value === undefined) {
+    out.push({ path, value: '(none)' });
+    return;
+  }
+  if (typeof value === 'number' || typeof value === 'string') {
+    out.push({ path, value });
+    return;
+  }
+  if (typeof value === 'boolean') {
+    out.push({ path, value: value ? 'true' : 'false' });
+    return;
+  }
+  if (typeof value === 'function') return;
+  if (ArrayBuffer.isView(value) || Array.isArray(value)) {
+    const list = value as ArrayLike<unknown>;
+    for (let i = 0; i < list.length; i++) pushValue(list[i], `${path}/${i}`, out, depth + 1);
+    return;
+  }
+  if (typeof value !== 'object') return;
+  const obj = value as Record<string, unknown>;
+  if (depth > 0 && typeof obj.name === 'string') {
+    out.push({ path, value: obj.name });
+    return;
+  }
+  if (depth > VALUE_WALK_DEPTH) {
+    out.push({ path, value: '(deeper than the walk goes)' });
+    return;
+  }
+  for (const key of Object.keys(obj).sort()) {
+    if (key in NOT_A_VALUE_IN_THE_FILE) continue;
+    pushValue(obj[key], `${path}/${key}`, out, depth + 1);
+  }
+}
+
+/**
+ * Which timeline this is, in words that both sides of a comparison can reach.
+ *
+ * The class name and the OWNER'S NAME — never the property ids, which carry
+ * array indices and, for a deform timeline, a counter. A rig that reorders its
+ * bones is a structural finding `diff` already makes; it must not also arrive
+ * here as a timeline nobody can pair.
+ */
+function timelineKey(timeline: Timeline, data: ReturnType<SkeletonJson['readSkeletonData']>): string {
+  const kind = timeline.constructor?.name ?? 'Timeline';
+  const asBone = timeline as Timeline & Partial<{ boneIndex: number }>;
+  if (isBoneTimeline(asBone)) return `${kind}/bone:${data.bones[asBone.boneIndex]?.name ?? `#${asBone.boneIndex}`}`;
+  const asSlot = timeline as Timeline & Partial<{ slotIndex: number }>;
+  if (isSlotTimeline(asSlot)) {
+    const slot = data.slots[asSlot.slotIndex]?.name ?? `#${asSlot.slotIndex}`;
+    const attachment = (timeline as Timeline & Partial<{ attachment: { name: string } }>).attachment;
+    return `${kind}/slot:${slot}${attachment === undefined ? '' : `:${attachment.name}`}`;
+  }
+  const asConstraint = timeline as Timeline & Partial<{ constraintIndex: number }>;
+  if (isConstraintTimeline(asConstraint)) {
+    return `${kind}/constraint:${data.constraints[asConstraint.constraintIndex]?.name ?? `#${asConstraint.constraintIndex}`}`;
+  }
+  return `${kind}/skeleton`;
+}
+
+/**
+ * Every value a skeleton file carries, as the **parser** understands it.
+ *
+ * ## Why this is here and not in `diff.ts`
+ *
+ * `diff` compares structure over raw JSON and says so in its own header:
+ * *"Pure JSON reading — no spine-core, no filesystem."* Comparing the values
+ * inside that structure needs the format's per-field defaults — `time` absent
+ * is 0, `scaleX` absent is 1, a physics key's `value` absent is 0 but its `mix`
+ * is 1 — and a second spelling of those inside the gate is exactly what this
+ * repository refuses (CLAUDE.md, *The compiler never invents a value*). So the
+ * defaults are taken from the one reader that owns them, which means the
+ * runtime, which means this file: `CLAUDE.md`'s *Conventions* names the three
+ * modules allowed to link spine-core and `src/validate.ts` is the one that
+ * "owns the round trip". `src/bonedist.ts` is the precedent for the other half
+ * — an instrument that needs the runtime and reaches it through `render.ts`
+ * rather than linking it itself. `diff.ts` compares what this returns.
+ *
+ * ## What it covers
+ *
+ * Everything on `SkeletonData` that is not on the skip list above: the header
+ * and stage, every bone's setup pose and `length`, every slot's colours, blend
+ * and setup attachment, every attachment in every skin (a region's offsets,
+ * rotation, scale and size; a mesh's vertices, weights, `regionUVs`,
+ * triangles, hull and edges; a bounding box's, path's and clipping shape's
+ * vertices), every constraint's pose and flags, every event's payload, and for
+ * every timeline every frame — time and values, from the runtime's own
+ * `getFrameEntries()` — its curve type and Bezier samples, and its deform
+ * vertices, attachment names, draw orders and event payloads.
+ *
+ * ## What it does not
+ *
+ * - **`version` and `hash`.** The rig spec has no field for either; `ingest`
+ *   reports them as `HEADER_REDERIVED` and `HEADER_BOOKKEEPING` findings, and
+ *   a rebuild restating the runtime rigc links is the whole reason the corpus
+ *   gate is `diff` at 1.000 rather than a byte comparison (`docs/INGEST.md`
+ *   §2.3). They are named here so that skipping them is a decision a reader
+ *   can see rather than an omission.
+ * - **Anything below one float32 step.** `spine-core` stores frames, curves and
+ *   vertices in `Float32Array`, so two values that round to the same float32
+ *   are equal to this walk whatever the file says. The comparison's tolerance
+ *   states that bound rather than hiding it.
+ * - **A Bezier's control points as such.** The parser samples them into
+ *   `curves` (`setBezier`), so what is compared is the sampled curve; a moved
+ *   handle moves the samples, but by a different amount than it moved the
+ *   handle.
+ */
+export function skeletonValues(skeletonText: string, atlasText: string): SkeletonValue[] {
+  const data = new SkeletonJson(new AtlasAttachmentLoader(new TextureAtlas(atlasText))).readSkeletonData(
+    JSON.parse(skeletonText),
+  );
+  const out: SkeletonValue[] = [];
+  const header = data as unknown as Record<string, unknown>;
+  for (const field of ['x', 'y', 'width', 'height', 'referenceScale', 'fps', 'imagesPath', 'audioPath', 'name']) {
+    pushValue(header[field], `skeleton/${field}`, out, 1);
+  }
+  for (const bone of data.bones) {
+    const at = `bones/${bone.name}`;
+    const rec = bone as unknown as Record<string, unknown>;
+    for (const key of Object.keys(rec).sort()) {
+      if (key in NOT_A_VALUE_IN_THE_FILE || key === 'name') continue;
+      pushValue(rec[key], `${at}/${key === 'setupPose' ? 'setup' : key}`, out, 1);
+    }
+  }
+  for (const slot of data.slots) {
+    const at = `slots/${slot.name}`;
+    const rec = slot as unknown as Record<string, unknown>;
+    for (const key of Object.keys(rec).sort()) {
+      if (key in NOT_A_VALUE_IN_THE_FILE || key === 'name') continue;
+      pushValue(rec[key], `${at}/${key === 'setupPose' ? 'setup' : key}`, out, 1);
+    }
+  }
+  for (const skin of data.skins) {
+    const at = `skins/${skin.name}`;
+    pushValue(skin.color, `${at}/color`, out, 1);
+    pushValue(skin.bones, `${at}/bones`, out, 1);
+    pushValue(skin.constraints, `${at}/constraints`, out, 1);
+    for (const [slotIndex, held] of skin.attachments.entries()) {
+      if (held === undefined || held === null) continue;
+      const slot = data.slots[slotIndex]?.name ?? `#${slotIndex}`;
+      const byName = held as unknown as Record<string, unknown>;
+      for (const placeholder of Object.keys(byName).sort()) {
+        const attachment = byName[placeholder] as Record<string, unknown>;
+        const where = `${at}/${slot}/${placeholder}`;
+        // The attachment's TYPE, which is the one thing reflection cannot see:
+        // a region and a mesh differ in their fields, and a walk that only read
+        // the fields would call a swap a pile of unpaired paths rather than a
+        // kind that changed.
+        pushValue(attachment.constructor?.name ?? '(unknown)', `${where}/kind`, out, 1);
+        pushValue(attachment, where, out, 0);
+      }
+    }
+  }
+  for (const constraint of data.constraints) {
+    const at = `constraints/${constraint.name}`;
+    pushValue(constraint.constructor?.name ?? '(unknown)', `${at}/kind`, out, 1);
+    pushValue(constraint, at, out, 0);
+  }
+  for (const event of data.events) pushValue(event, `events/${event.name}`, out, 0);
+  for (const animation of data.animations) {
+    const at = `animations/${animation.name}`;
+    pushValue(animation.duration, `${at}/duration`, out, 1);
+    // Timelines are grouped by their key and numbered within the group, so that
+    // two timelines a runtime distinguishes by object identity — one deform per
+    // skin over the same slot and attachment — still pair up in file order
+    // rather than colliding on one path.
+    const grouped = new Map<string, Timeline[]>();
+    for (const timeline of animation.timelines) {
+      const key = timelineKey(timeline, data);
+      const held = grouped.get(key);
+      if (held === undefined) grouped.set(key, [timeline]);
+      else held.push(timeline);
+    }
+    for (const key of [...grouped.keys()].sort()) {
+      const group = grouped.get(key) ?? [];
+      for (const [n, timeline] of group.entries()) {
+        const where = `${at}/${key}${group.length > 1 ? `#${n}` : ''}`;
+        // The frames, split into time and values by the runtime's own count of
+        // entries per frame rather than by a table of what each timeline kind
+        // keys. Entry 0 is the time for every timeline spine-core defines.
+        const entries = timeline.getFrameEntries();
+        for (let i = 0; i < timeline.frames.length; i++) {
+          const slot = i % entries;
+          pushValue(timeline.frames[i], `${where}/key/${Math.floor(i / entries)}/${slot === 0 ? 'time' : `v${slot}`}`, out, 1);
+        }
+        const rec = timeline as unknown as Record<string, unknown>;
+        for (const field of Object.keys(rec).sort()) {
+          if (field in NOT_A_VALUE_IN_THE_FILE || field === 'frames') continue;
+          // The owner is in the path already; comparing the index as well would
+          // report one reordering twice, in a measure that is not about order.
+          if (field === 'boneIndex' || field === 'slotIndex' || field === 'constraintIndex') continue;
+          pushValue(rec[field], `${where}/${field}`, out, 1);
+        }
+      }
+    }
+  }
+  return out;
+}

package/tools/editor_roundtrip.ts

@@ -9,6 +9,12 @@
  * emitter defects (#368 `hull`/`edges`, #369 hold curves, #370
  * `skeleton.images`) before proving that a human edit survives the trip.
  *
+ * ⭐ Every step quotes what its child said when that child did not do what it was
+ * for (#541, and step 5 since #621). A skin NEITHER side can draw is a SKIP
+ * naming that rather than a red — `check` had nothing to compare, and `validate`
+ * and `diff` have already measured the rig — while a skin only ONE side draws is
+ * the divergence this whole file exists to find and stays a failure.
+ *
  * It ran from a shell script in a local scratch directory. A tool nobody can
  * find is not a tool, hence this file.
  *
@@ -308,6 +314,107 @@ function editorSaid(ran: Ran): string[] {
   return lines;
 }
 
+/**
+ * The line a rigc child REFUSED on, out of the stream it printed it on.
+ *
+ * ⚠️ Not `editorSaid`, which quotes both streams whole. A rigc refusal is a
+ * `UsageError` and `cli.ts` prints the entire usage under one — some sixty lines
+ * of correct prose that would bury the one sentence somebody needs. Every
+ * refusal rigc prints starts, at column zero, with its own name and a colon:
+ * `rigc:`, `rigc check error:`, `rigc compile error:`. The usage block has
+ * neither shape — its `rigc <command> …` lines are indented, and its unindented
+ * ones carry no colon — so none of them is mistaken for one.
+ */
+function refusalLines(text: string): string[] {
+  return text.split('\n').filter((line) => /^rigc\b[^\n]*:/.test(line));
+}
+
+/**
+ * What one rigc child said, under the step that ran it.
+ *
+ * 🚨 Issue #621, and it is `editorSaid`'s defect one surface over. Step 5 was
+ * the one step that printed a child's exit code and threw its words away: on a
+ * rig whose only attachment is a `boundingbox` it reported a bare `exit=1`, and
+ * the renderer's own refusal — *"posed no drawable attachment in any animation
+ * or in its setup pose — there is nothing to draw"* — reached nobody. A reader
+ * of that log cannot tell a crashed renderer from a rig with no frames, which is
+ * the same silence this file already has a judgment about.
+ *
+ * ⭐ The fallback is the half that keeps the fix from being the defect again one
+ * level down: a child that dies with a stack trace prints no `rigc…:` line at
+ * all, so when nothing matched, the tail of stderr is quoted rather than
+ * nothing.
+ */
+function rigcSaid(what: string, ran: Ran): string[] {
+  const said = [
+    ...refusalLines(ran.stderr),
+    // `check` reports its failures on stdout, in the FAIL lines `verdictLines`
+    // keeps for the green path.
+    ...ran.stdout.split('\n').filter((line) => /^\s*FAIL/.test(line)),
+  ];
+  if (said.length === 0) {
+    said.push(...ran.stderr.replace(/\s+$/, '').split('\n').slice(-6).filter((line) => line !== ''));
+  }
+  const head = `  ${what}  exit=${String(ran.status)}${ran.timedOut ? '  TIMED OUT' : ''}`;
+  // Silence is a finding, for the reason `editorSaid` states: "it said nothing"
+  // and "this harness threw its words away" look identical from the outside.
+  if (said.length === 0) return [head, '    | it printed nothing on stdout or stderr'];
+  return [head, ...said.map((line) => `    | ${line.trimEnd()}`)];
+}
+
+/**
+ * The clause `rigc render` refuses on when the skeleton draws nothing, and the
+ * exit code it leaves it with.
+ *
+ * ⚠️ The clause is the part of that message that does not move: `cli.ts` splices
+ * ` under skin "x"` in after "setup pose" when `--skin` was passed, and ends on
+ * `— there is nothing to draw` either way.
+ */
+const NOTHING_TO_DRAW = 'posed no drawable attachment in any animation or in its setup pose';
+
+/** `cli.ts` exits 2 on a `UsageError`, which is what that refusal is. */
+const RIGC_USAGE_EXIT = 2;
+
+/**
+ * Did this `render` call refuse because there was nothing to draw?
+ *
+ * 🔒 **Both signals, and the second one is why** (issue #621). The exit code
+ * alone is every `UsageError` there is — an unknown flag, a candidate that is
+ * not there, a `--skin` the skeleton does not declare — so reading a 2 as
+ * "nothing to draw" would turn the export dropping a skin the build declares
+ * into a SKIP, which is the one outcome this must never produce. The sentence
+ * alone is a string found on a stream however the child exited, including a path
+ * that echoed it and then did something else.
+ *
+ * ⛔ What was rejected: reading the two skeletons here and deciding for
+ * ourselves whether either draws. That is a second implementation of
+ * `framingViewport` — atlas resolution, the setup pose and every animation — and
+ * two answers that need not agree is a checker agreeing with itself. The verdict
+ * belongs to the child that refused.
+ *
+ * ⛔ Also rejected, and it is the more structural signal: an exit code of its own
+ * from `cli.ts` for this refusal. `src/render.ts` emits no code at all —
+ * `framingViewport` returns null and `cli.ts` turns that into a `UsageError` — so
+ * that is a change to rigc's CLI contract rather than to this harness, and it is
+ * wider than the card it would be landing under.
+ */
+function nothingToDraw(ran: Ran): boolean {
+  return !ran.timedOut && ran.status === RIGC_USAGE_EXIT && ran.stderr.includes(NOTHING_TO_DRAW);
+}
+
+/**
+ * Step 5's verdict when NEITHER side draws (issue #621).
+ *
+ * The question this step asks is *does what comes back still play the same*. A
+ * rig that draws nothing on both sides gives `check` nothing to compare, and the
+ * honest answer to a question with no measurement behind it is the one this file
+ * gives everywhere else: SKIP by name, never a pass and never a red. `validate`
+ * and `diff` have already measured the rig — this is the shape #608 removed from
+ * `build`, one tool further out.
+ */
+const NOTHING_MEASURED =
+  'neither side draws a frame, so the check is not measured; `diff` and `validate` carry this rig';
+
 function run(cmd: string, args: string[], timeoutS: number): Ran {
   const r = spawnSync(cmd, args, { encoding: 'utf8', timeout: timeoutS * 1000 });
   return {
@@ -497,6 +604,16 @@ export function skinsDeclaredBy(path: string): string[] {
   return out;
 }
 
+/**
+ * How one step-5 block ended (issue #621).
+ *
+ * Three states rather than an exit code, because `check` not having run and
+ * `check` having returned 0 are different facts and used to print the same:
+ * `measured` is the only one that carries a figure, and `not measured` is the
+ * only one that does not fail the run.
+ */
+export type BlockVerdict = 'measured' | 'not measured' | 'no frames';
+
 /** One render-and-check block of step 5: which skin, where its frames go. */
 export interface SkinBlock {
   /** The skin this block poses under — `null` when the skeleton declares none. */
@@ -901,21 +1018,63 @@ function main(): void {
   // export dropped altogether then reads as a block whose check fails by name,
   // where enumerating the export's own skins would quietly stop looking for it.
   const blocks = skinBlocks(skinsDeclaredBy(source), opts.out, opts.fps);
-  const checks: Array<{ skin: string | null; status: number | null; mae: number | null }> = [];
+  const checks: Array<{ skin: string | null; verdict: BlockVerdict; status: number | null; mae: number | null }> = [];
   for (const block of blocks) {
     emit('');
     emit(block.heading);
-    run(rigc.cmd, [...rigc.prefix, 'render', '--candidate', opts.build, '--fps', String(opts.fps), ...block.args, '--out', block.buildFrames], 900);
-    run(rigc.cmd, [...rigc.prefix, 'render', '--candidate', cand, '--fps', String(opts.fps), ...block.args, '--out', block.exportFrames], 900);
+    const args = ['--fps', String(opts.fps), ...block.args];
+    const drawBuild = run(rigc.cmd, [...rigc.prefix, 'render', '--candidate', opts.build, ...args, '--out', block.buildFrames], 900);
+    const drawExport = run(rigc.cmd, [...rigc.prefix, 'render', '--candidate', cand, ...args, '--out', block.exportFrames], 900);
+    // 🚨 Both renderers are quoted the moment either did not do what it was for
+    // (issue #621) — the rule steps 1 and 2 have followed since #541, and step 5
+    // was the one step that did not.
+    for (const [what, ran] of [
+      ['render (the build)', drawBuild],
+      ['render (the export)', drawExport],
+    ] as const) {
+      if (ran.status !== 0 || ran.timedOut) for (const line of rigcSaid(what, ran)) emit(line);
+    }
+    const buildBlank = nothingToDraw(drawBuild);
+    const exportBlank = nothingToDraw(drawExport);
+    const buildDrew = drawBuild.status === 0 && !drawBuild.timedOut;
+    const exportDrew = drawExport.status === 0 && !drawExport.timedOut;
+
+    if (buildBlank && exportBlank) {
+      emit(`  SKIP  ${NOTHING_MEASURED}`);
+      checks.push({ skin: block.skin, verdict: 'not measured', status: null, mae: null });
+      continue;
+    }
+    // 🔒 One side only, and it stays red. "Nothing to draw" is an honest answer
+    // about a RIG; about one side of a round trip it is the loss the trip exists
+    // to find, so the SKIP above is guarded by `&&` and never by `||`.
+    if ((buildBlank && exportDrew) || (exportBlank && buildDrew)) {
+      const blank = buildBlank ? 'the build' : 'the export';
+      const drawn = buildBlank ? 'the export' : 'the build';
+      emit(
+        `  FAIL  ${blank} has nothing to draw and ${drawn} draws — one side drawing where the other does not IS ` +
+          'the divergence this step measures, so it is a failure and never a SKIP',
+      );
+      checks.push({ skin: block.skin, verdict: 'no frames', status: null, mae: null });
+      continue;
+    }
+    if (!buildDrew || !exportDrew) {
+      emit(
+        '  FAIL  a render did not do what it was for, so there is no frame set to compare — `check` is not run, ' +
+          'because with a frame set missing its message would name the directory rather than the refusal above',
+      );
+      checks.push({ skin: block.skin, verdict: 'no frames', status: null, mae: null });
+      continue;
+    }
     const check = run(
       rigc.cmd,
       [...rigc.prefix, 'check', '--candidate', cand, '--frames', block.buildFrames, ...block.args, '--json', block.checkJson],
       900,
     );
     emit(`  exit=${check.status}`);
+    if (check.status !== 0 || check.timedOut) for (const line of rigcSaid('check', check)) emit(line);
     for (const line of verdictLines(check.stdout)) emit(`  ${line}`);
     for (const line of checkFigures(block.checkJson)) emit(`  ${line}`);
-    checks.push({ skin: block.skin, status: check.status, mae: worstMeanMae(block.checkJson) });
+    checks.push({ skin: block.skin, verdict: 'measured', status: check.status, mae: worstMeanMae(block.checkJson) });
   }
   // The roll-up, so a loss in one skin of many is a line somebody reads rather
   // than a row buried in the block above it. The mark is on the LARGEST figure
@@ -923,22 +1082,41 @@ function main(): void {
   // against and this tool does not get to invent one, but "these skins did not
   // come back the same" is a fact the run itself produced.
   if (blocks.length > 1) {
-    const figures = checks.map((c) => c.mae).filter((v): v is number => v !== null);
+    // ⚠️ Off the MEASURED blocks only (issue #621). A skin nobody could render
+    // has no figure, and folding it in as one would put a number in the column a
+    // reader looks at for a block where nothing was compared.
+    const figures = checks.filter((c) => c.verdict === 'measured').map((c) => c.mae).filter((v): v is number => v !== null);
     const worst = figures.length === 0 ? null : Math.max(...figures);
     const agreed = figures.length === checks.length && new Set(figures).size === 1;
     emit('');
     emit(`  per skin  ${checks.length} block(s)`);
-    for (const { skin, status, mae } of checks) {
+    for (const { skin, verdict, status, mae } of checks) {
+      // 🔒 Never a pass and never an MAE of 0: a block that measured nothing
+      // says so in the column the figures would have been in.
+      if (verdict !== 'measured') {
+        emit(
+          `    ${String(skin).padEnd(20)} ` +
+            (verdict === 'not measured'
+              ? 'NOT MEASURED — neither side draws a frame under this skin'
+              : '⚠️ NOT MEASURED — a render did not do what it was for, and this skin is red for it'),
+        );
+        continue;
+      }
       emit(
         `    ${String(skin).padEnd(20)} check exit=${status}  worst mean MAE ` +
           `${mae === null ? '(no report)' : mae.toFixed(4)}` +
           `${status === 0 ? '' : '   ⚠️ this skin did not come back'}` +
-          `${!agreed && mae !== null && mae === worst ? `   ⚠️ the worst of the ${checks.length} skins` : ''}`,
+          // The mark compares figures, so it needs two of them: crowning the one
+          // skin that WAS measured "the worst" says nothing and reads as a loss.
+          `${!agreed && figures.length > 1 && mae !== null && mae === worst ? `   ⚠️ the worst of the ${figures.length} measured skins` : ''}`,
       );
     }
     if (agreed) emit(`    ⤷ every skin came back at the same figure, so no skin is carrying a difference the others are not.`);
   }
-  const checksClean = checks.every((c) => c.status === 0);
+  // 🔒 `not measured` is the one verdict that does not fail the run: nothing was
+  // compared, and a round trip that ends red on a correct rig is the shape #608
+  // removed from `build` (issue #621).
+  const checksClean = checks.every((c) => c.verdict === 'not measured' || (c.verdict === 'measured' && c.status === 0));
 
   emit('');
   emit('## 6 what the editor rewrote');