spine-rigc 1.5.2 → 1.5.3

package/docs/AUTHORING.md

@@ -1423,7 +1423,7 @@ it would simply be a second root.
 | `skin` | `BoneData.skinRequired` | `false` |
 | `color` | `rrggbbaa`, editor affordance | — |
 | `icon` | the editor's icon for this bone, e.g. `arrowsB`; editor affordance, no rendering effect. Copied through verbatim — no assertion checks the name, because the icon vocabulary is the editor's and an unknown one is not an error | — |
-| `from` | **rigc extension** — take `x`/`y` (and optionally `rotation`) from a cut manifest | — |
+| `from` | **rigc extension** — take `x`/`y` from a cut manifest: `from.anchor`, `from.slotWindow` or `from.meshCenter`, exactly one. `from.rotation` is `"axis"` (the manifest's `axis.deg`, negated into y-up) or `"anchor"` (the third element of the named anchor, a screen-space facing angle); any other value is refused by name — it used to build as no rotation at all | — |
 
 ⚠️ Spine 4.0/4.1 called `inherit` **`transform`**. That old key still *loads* in 4.3
 and the inheritance silently falls back to Normal — assertion `A02` refuses it.
@@ -1803,7 +1803,7 @@ region, a trigger volume — that moves with the skeleton and draws nothing.
 | `vertexCount` | **required**, 3 or more. No default — the paragraph above is why |
 | `vertices` | the unweighted `x, y` run, in the slot bone's local space; or the index-encoded weighted run, behind `boneIndexing` |
 | `weights` | the by-name form: one entry per vertex, each a list of `{ "bone": …, "x": …, "y": …, "weight": … }`, each pair in that bone's local space. Never beside `vertices` |
-| `boneIndexing` | `"name"` (the default) or `"raw"`, which opts a weighted `vertices` run into Spine's index encoding. `"raw"` beside `weights` is refused: `weights` always binds by name |
+| `boneIndexing` | `"name"` (the default) or `"raw"`, which opts a weighted `vertices` run into Spine's index encoding. `"raw"` beside `weights` is refused: `weights` always binds by name. Any other value — `"named"` included — is refused by name; it used to build as `"name"` |
 | `color` | `rrggbbaa`. **No default in the file** — omitted, the parser never calls `setFromString` and the attachment keeps the runtime's own colour. It is an editor affordance, the colour the polygon is drawn in there; rigc emits it verbatim when stated and leaves the key out when not |
 
 **Clipping polygon** ([Spine: clipping](http://esotericsoftware.com/spine-clipping)) —
@@ -1861,7 +1861,8 @@ is the wrap-around curve from `x = 180` back to `x = 0`, which nothing reads. Th
 `worldX = 45.000000`.
 
 The generators are `ring`, `ribbon`, `contour`, `grid` and `segments` (see
-[`src/mesh.ts`](../src/mesh.ts)); the first two encode a deformation model rather
+[`src/mesh.ts`](../src/mesh.ts)), and a generator's `kind` is required: any other
+value, or none, is refused naming the five; the first two encode a deformation model rather
 than a table of numbers, which is why they are code invoked by data. `contour`
 and `grid` are geometry: they pin every vertex to the slot bone and exist to give
 a `deform` timeline (§4.12) somewhere to push. `segments` is both at once — a
@@ -5450,11 +5451,12 @@ out of it.)
 
 🔢 **A fourth surface is a pose that is not finite**, which `render` and `check`
 refuse before drawing anything, naming the bone or vertex and its value.
-`A10_NO_NAN_AFTER_STEPPING` reads the same scan, so on a skeleton with an animation
-`validate` gets there first and in the same words: a bone `rotation` of `1e309`, in
-the setup pose or in a key, leaves the bone's world position finite and its matrix
-`NaN`, and A10 names the bone and the term. What it does not see is a skeleton with
-no animation (A10 SKIPs, so `render` is where that one is named) and a skin other
+`A10_NO_NAN_AFTER_STEPPING` reads the same scan, so `validate` gets there first and
+in the same words: a bone `rotation` of `1e309`, in the setup pose or in a key,
+leaves the bone's world position finite and its matrix `NaN`, and A10 names the bone
+and the term. That holds on a skeleton with no animation too — A10 reads its setup
+pose, which is the whole of what a static rig shows, and says on the stats line that
+it had nothing to step (`nanStepping=skipped`). What it does not see is a skin other
 than the default, which A10 does not pose. The sentence, and where to look for the
 number, is under *nothing to draw* in §3.4.
 
@@ -5581,7 +5583,8 @@ or the key's position in its own track. These are the frequent ones, verbatim:
 | `a rig spec needs a non-empty "bones" array` | §3.2 — a rig with no bones has nothing to hang a slot on; every one has at least a root |
 | `a rig spec needs a "slots" array (it may be empty; its ORDER is the draw order)` | §3.3 — write `[]` for a rig that draws nothing. ⚠️ These three arrive only when the key is really absent: **misspelt**, it is the unknown-key refusal above, naming what you wrote |
 | `bone "X" names parent "Y", which is not declared before it` | move `Y` earlier in `bones` |
-| `<file>: <where> is a string "5"; a number is required` (also `is a boolean true`, `is an array [1]`, `is null`, `is a number 7; a string is required`, `…; an array of numbers is required`, `…; a boolean (true or false) is required`, `…; a string or null is required`) | §3 / §4 — write the value as the JSON type its field holds: a number as a JSON number (`5`, not `"5"`), a flag as `true`/`false`, a name as a string. Every field of the three input files has one type, and a value of another is refused by the field before any reader does arithmetic on it — which it used to: `"x": "5"` built as `5`, `true` as `1` and `[1]` as `1`, and a `null` built too, all green. An array is typed element by element, so the refusal names the index (`weights[3][1].x`, `vertices[0]`). `null` is refused as `null` except where the field states it means something (`skeleton.width`/`height`, `skeleton.audio`, a slot's and a setup entry's `attachment`, a deform key's `vertices`, the manifest's `image`, `states`, `contact_depth` and `cap_containment_ceiling`). `<where>` is the rig spec's wording (`bone "hip" x`, `skin "default" slot "s" attachment "a" rotation`, `constraint "aim" mix`), the dotted path in the cut manifest (`crop.h`, `parts[2].offset[0]`), and the motion spec's own path (`` `animations."walk".ik[0].keys[0].mix` ``). In the rig spec and the manifest it runs right after the key scan and before every other check, so a field check that used to name a type (a mesh name that is not a string, a `lengths` entry spelt as a string) now reads as this row; in the motion spec it runs after that file's own field checks, which keep their sentences. A closed set of names (`blend`, `inherit`, a constraint's `type`, a generator's `kind`) keeps its own refusal, which lists the names that exist |
+| `<file>: <where> is a string "5"; a number is required` (also `is a boolean true`, `is an array [1]`, `is null`, `is a number 7; a string is required`, `…; an array of numbers is required`, `…; a boolean (true or false) is required`, `…; a string or null is required`) | §3 / §4 — write the value as the JSON type its field holds: a number as a JSON number (`5`, not `"5"`), a flag as `true`/`false`, a name as a string. Every field of the three input files has one type, and a value of another is refused by the field before any reader does arithmetic on it — which it used to: `"x": "5"` built as `5`, `true` as `1` and `[1]` as `1`, and a `null` built too, all green. An array is typed element by element, so the refusal names the index (`weights[3][1].x`, `vertices[0]`). `null` is refused as `null` except where the field states it means something (`skeleton.width`/`height`, `skeleton.audio`, a slot's and a setup entry's `attachment`, a deform key's `vertices`, the manifest's `image`, `states`, `contact_depth` and `cap_containment_ceiling`). `<where>` is the rig spec's wording (`bone "hip" x`, `skin "default" slot "s" attachment "a" rotation`, `constraint "aim" mix`), the dotted path in the cut manifest (`crop.h`, `parts[2].offset[0]`), and the motion spec's own path (`` `animations."walk".ik[0].keys[0].mix` ``). In the rig spec and the manifest it runs right after the key scan and before every other check, so a field check that used to name a type (a mesh name that is not a string, a `lengths` entry spelt as a string) now reads as this row; in the motion spec it runs after that file's own field checks, which keep their sentences. A closed set of names is not a type, and is the next row's |
+| `<file>: <where> is "foo"; one of "name", "raw" — anything else was read as …` (also `bone "b" from.rotation is 5; one of "axis", "anchor"`, the manifest's `parts[1].mesh.kind is "foo"; one of "ring", "ribbon"`, and `skin "s" slot "x" attachment "a" generator.kind is "foo"; one of "ring", "ribbon", "contour", "grid", "segments"`, or `… generator.kind is absent; …`) | §3.2 / §3.4 — write one of the names listed. A field that holds one of a closed set of names is refused, with the set, when it holds anything else — a number too, since a number is not a name. Most such fields have a reader that refuses by name with its own sentence (`blend`, `inherit`, a constraint's `type`, `scaleY`); these four had none, and each built green or crashed: `boneIndexing` read as `"name"`, `from.rotation` as no rotation, the manifest's `mesh.kind` as a ribbon by one reader and a ring by two others, and a generator `kind` threw a `TypeError`. The sentence after the dash says what the value used to be read as, which is the build you had before this refusal. The first three run right after the type row's walk, before every other check; the generator's `kind` is refused earlier, by the key scan, because it chooses which keys the rest of the generator may hold |
 | `<file>: <where> is Infinity; a number in this file is finite at float32 precision, at most ±3.4028234663852886e+38, because the skeleton is written as float32 — …` (also `is -Infinity`, `is 1e+308`, and `is NaN` from a library caller) | §3 — state the number you meant, inside float32's range. One walk over the whole file, run right after the key scan and before any other rig-spec check, so a range rule never prints `NaN`. `<where>` is every number in the rig spec — a bone (`bone "hip" x`), a slot, a skin's attachment down to its arrays (`skin "default" slot "s" attachment "a" weights[3][1].x`), a constraint (`constraint "aim" mixRotate`), an event, `skeleton`, `invariants.meshTriangles` — and the dotted path in the cut manifest (`crop.h`) and in the motion spec (`` `animations.idle.tracks[0].keys[1].v[0]` ``, after the motion spec's own field checks, which keep their sentences). ⚠️ It sees numbers only: `"x": "NaN"` is a string, and the row above refuses it as one |
 | `two bones are called "X"` | bone names are the join key; rename one |
 | `two ik constraints are called "X" — a constraint resolves by name AND type (\`SkeletonData.findConstraint\`), so names are unique PER KIND: an ik and a transform constraint may share one, two of a kind may not` | §3.5 — rename one of the two. The kind in the sentence is the pair's own, so `two transform constraints are called "X"` is the same refusal on another kind; a name shared **across** kinds is not this error |
@@ -5808,7 +5811,7 @@ Fix A00 and run it again.
 | `A07_ATLAS_TEXT_SHAPE` | both | atlas text: a region name with stray whitespace, or a blank line splitting a page block. rigc writes the atlas, so this means a hand-edited file. Three sentences are about blank lines and name three different repairs: `line 1: the file begins with a blank line` (or `with N blank lines` for a run, one finding) is a blank before the first page name — delete it; `line N: the file ends with a blank line` (or `with N blank lines`, one finding) is a blank after the last page block's final line — delete it, since rigc ends the file on one newline; `line N: consecutive blank lines` is two blank lines side by side between the first page and the last — delete one. None of the three is `the last page block declares no region`, which means a page name and its fields with no region after them. rigc writes none of the three: under `--atlas-in` the pack's blank lines are put in rigc's shape on re-emission (§0.2), so any of them means a file rigc did not write, handed to `validate`. ⚠️ An atlas with **no page block at all** — no non-blank line — is not one of those: its subject is absent, so this reports **SKIP** naming the byte count it read, and so do the four rules below whose subject is a page ([#608](https://github.com/firejune/rigc/issues/608)). A rig whose skins need no art writes exactly that file (§3.4), and before #608 this row refused it with two findings naming a page block that was not there. What an empty atlas does **not** excuse is an attachment that wants a region out of it — that is `A08` |
 | `A08_REGION_NAMES_MATCH_ATTACHMENTS` | both | three things, and the message says which: an attachment whose `path` names **no region** of this atlas; a `path` carrying **stray whitespace**, printed quoted so you can see it; an **atlas region name** carrying stray whitespace (`A07` names that same line with its line number). The first two are read off the raw file **before** the loader is asked, so the miss is named here with the skin, the slot, the placeholder and the attachment's own name — the four things `AtlasAttachmentLoader`'s own `Region not found in atlas: <path> (attachment: <name>)` does not carry. There is no `spine-html` clause here — a placeholder is free to differ from the region its `path` names **SKIP** when no attachment names a region *and* the atlas declares none — both of its subjects at once |
 | `A09_ANIMATION_DURATION_MATCHES_SPEC` | both | the loaded duration ≠ the declared one, or the two sides disagree about which animations exist (R7). Asymmetric by design: a frame of slack for an animation that ends early, and none worth the name for a key *past* the declared end, which is the same rule §4.5 states at compile time — held here against a skeleton the compiler never saw. **SKIP** when neither side has an animation at all — a static rig has no duration |
-| `A10_NO_NAN_AFTER_STEPPING` | both | stepping the animation produced a pose that is not finite. It reads the **whole world transform** — all six terms `a`, `b`, `c`, `d`, `worldX`, `worldY` of every bone — then every vertex of every region and mesh the slots show, at the **setup pose** and at every stepped frame of every animation, through the same scan `render` refuses on, so the two cannot disagree. The detail names where (`the setup pose`, or `animation "x" frame i of 120 (t=…s)`), then the bone and the term (`bone "x" has a NaN`), or the slot, attachment and vertex (`vertex 3 has x Infinity`) when every bone is finite and a vertex is not — a `scaleX` chain whose product stays under the largest double does that. A bone at `rotation: 1e309` has a finite position and a `NaN` matrix, which is why the position alone is not read. Look for a number past the largest double, a degenerate curve or a zero scale. 🦴 **It also poses every bone `inherit` key at its own time**: the runtime resolves a mode by folding the case of its first letter and nothing else, and a spelling that misses is stored as **NaN** — the world position stays finite, `updateWorldTransform` matches no mode, and the bone keeps the rotation, scale and shear it had. The detail names the animation, the bone, the key's time and its spelling, beside the five. A bone whose *setup* spelling misses poses no mode at all, and is named the same way from the stepping loop. Neither is reachable from a rig spec — `build` refuses both spellings by name (§5.1) — so on a green build this clause is about files rigc did not write. Which mode a correct spelling poses is not judged here, because the lookup that resolved it is the one that would be checked **SKIP** when the skeleton carries no animation: the NaN is produced by stepping, and a static rig is never stepped — the same subject `A09` skips on |
+| `A10_NO_NAN_AFTER_STEPPING` | both | stepping the animation produced a pose that is not finite. It reads the **whole world transform** — all six terms `a`, `b`, `c`, `d`, `worldX`, `worldY` of every bone — then every vertex of every region and mesh the slots show, at the **setup pose** and at every stepped frame of every animation, through the same scan `render` refuses on, so the two cannot disagree. The detail names where (`the setup pose`, or `animation "x" frame i of 120 (t=…s)`), then the bone and the term (`bone "x" has a NaN`), or the slot, attachment and vertex (`vertex 3 has x Infinity`) when every bone is finite and a vertex is not — a `scaleX` chain whose product stays under the largest double does that. A bone at `rotation: 1e309` has a finite position and a `NaN` matrix, which is why the position alone is not read. Look for a number past the largest double, a degenerate curve or a zero scale. 🦴 **It also poses every bone `inherit` key at its own time**: the runtime resolves a mode by folding the case of its first letter and nothing else, and a spelling that misses is stored as **NaN** — the world position stays finite, `updateWorldTransform` matches no mode, and the bone keeps the rotation, scale and shear it had. The detail names the animation, the bone, the key's time and its spelling, beside the five. A bone whose *setup* spelling misses poses no mode at all, and is named the same way from the stepping loop. Neither is reachable from a rig spec — `build` refuses both spellings by name (§5.1) — so on a green build this clause is about files rigc did not write. Which mode a correct spelling poses is not judged here, because the lookup that resolved it is the one that would be checked. 🧍 **A skeleton with no animation is still read**: its setup pose is the whole of what it shows, so A10 reads it — the world transform and the vertices as above, and the bone's mode and the slot colours a stepped frame is read for, which on a static rig nothing else would reach — and names it `the setup pose` (`the setup pose: slot "x" colour is non-finite`). The stepping half had nothing, and a PASS row carries no detail, so the stats line says so: `nanStepping=skipped`, beside `animations=0`. `A09` does not follow — a declared duration is a fact about an animation and nothing else, so a static rig still gives it nothing. **SKIP** only when the skeleton carries **no bone and no animation**: there is then no pose to read and nothing to step |
 | `A11_NO_CLIPPING_ATTACHMENTS` | renderer | a clipping attachment; the target renderer skips them silently |
 | `A12_NO_DARK_COLOR` | renderer | a slot `dark` colour or an `rgba2`/`rgb2` timeline; parsed, then ignored |
 | `A13_MESH_BUDGET` | renderer | more mesh slots than the rig's `invariants.meshSlots`, or a mesh over its `invariants.meshTriangles`. Thin the mesh, or raise the budget in the rig spec. **SKIP** when the rig declares neither — which means *unmeasured*, not that the budget is inert: the same `meshSlots` is a **compile-time** refusal for rigc's own generators, before the gate (§3.7) **SKIP** also when the rig budgets **only** triangles and the skeleton carries no mesh. A declared slot budget still PASSes there, because zero mesh slots is a count measured against a ceiling |

package/docs/MOTION.md

@@ -982,9 +982,11 @@ are entirely the motion spec's business.
 
 ### 4. In-between it
 
-Duration 0.55 s, proposed (§3.3). Three easings (§3.4). The arm is the driver; the flag
-is the next link out and it is light, so §3.7's table puts its extreme **+20–35 %** after
-the arm's and gives it an overshoot. *"Snap"* buys an anticipation (§3.6) and an
+Duration 0.55 s, proposed (§3.3). Three easings (§3.4). The arm is the driver. The flag
+is the last thing on it and it is cloth, which is the row §3.7's table gives to *a
+pennant* — not the *next link out* row, because nothing hangs off the flag — so its
+extreme lands **+20–35 %** after the arm's, it overshoots, and it settles last with one
+crossing. *"Snap"* buys an anticipation (§3.6) and an
 overshoot (§3.8). The post is planted: ⛔ **no timeline**.
 
 `semaphore.motion.json` — complete, nothing trimmed:
@@ -1020,8 +1022,8 @@ overshoot (§3.8). The post is planted: ⛔ **no timeline**.
           "keys": [
             { "t": 0, "v": [-22.2], "ease": "gather" },
             { "t": 0.09, "v": [-30.1], "ease": "charge" },
-            { "t": 0.38, "v": [-3.8], "ease": "settle" },
-            { "t": 0.48, "v": [-15.4], "ease": "settle" },
+            { "t": 0.47, "v": [-3.8], "ease": "settle" },
+            { "t": 0.51, "v": [-15.4], "ease": "settle" },
             { "t": 0.55, "v": [-11.7] }
           ]
         }
@@ -1040,8 +1042,8 @@ which is which is worth being able to point at:
 | arm `t: 0.55` = 18.3, flag `t: 0.55` = −11.7 | **given** — pose B. The flag's is `6.6 − 18.3`: both world rotations converted first, then differenced, because a child's track carries a **local** rotation under a rotated parent |
 | arm `t: 0.07` = −66.4 | §3.6 — 4.5° against an 80° excursion (5.6 %), at 13 % of the duration |
 | arm `t: 0.32` = 24.7 | §3.8 — 6.4° past the end value (8 %), at 58 % of the duration |
-| flag `t: 0.09`, `t: 0.38` | §3.7 — the flag's extreme lands at 69 % against the arm's 58 %, an offset of **+11 %**, and it drags the other way first |
-| flag `t: 0.48` = −15.4 | §3.7's *one crossing* for a loose part: it comes back past its own end value before settling |
+| flag `t: 0.09`, `t: 0.47` | §3.7 — the flag's extreme lands at 85 % of the duration against the arm's 58 %, an offset of **+27 %**, the middle of its row's band, and it drags the other way first. Not the top of the band: at 35 % (`t: 0.51`) the crossing and the settle below would share 0.04 s, and the 24 fps render would still show the flag at its extreme one frame before the last |
+| flag `t: 0.51` = −15.4 | §3.7's *one crossing* for a loose part: it comes back past its own end value before settling, keyed halfway between its extreme and the end |
 | the three easings | §3.4 — one that gathers, one that arrives slowly, one symmetric. The **last key of each track carries no easing**, because there is nothing after it to ease towards (AUTHORING §4.5) |
 | the post's absent track | §3.7 — a planted part gets no timeline |
 
@@ -1071,7 +1073,9 @@ Open `render/raise@24fps/contact.png` **before anything else** — fourteen fram
 grid, and spacing is a comparison across frames rather than a property of any one of
 them. What to check on it, and it is not a score: frame 0 is pose A — the flag hanging off
 the arm's collar, not over its middle — the last frame is pose B, the anticipation dips
-*after* frame 0, and the flag's extreme is visibly later than the arm's.
+*after* frame 0, and the flag's extreme is visibly later than the arm's: the arm peaks at
+frame 8 while the flag is still closing on the arm's line, it keeps closing through
+frame 11 as the arm eases back, and at frame 12 it drops past its resting angle.
 
 🚫 **Do not run `rigc check` against `poseA.png` and `poseB.png`.** Two pictures are not
 a frame set: `check` reads the second as the frame 1/12 s in, at its default rate. And
@@ -1115,21 +1119,21 @@ rigc vote --candidate spine --candidate spine-b
 
 ```
 rigc vote
-  ..    ballot    bce70ad82fe90941
+  ..    ballot    862f444c58d10e3e
   ..    animation raise
-  ..    A         sha256:6740d3dbf304…  3 page(s), 0.4 KiB  <- …/semaphore/spine/skeleton.json
+  ..    A         sha256:c49e458df44e…  3 page(s), 0.4 KiB  <- …/semaphore/spine/skeleton.json
   ..    B         sha256:d1bda24d7c36…  3 page(s), 0.4 KiB  <- …/semaphore/spine-b/skeleton.json
   ..    the page shows A/B and nothing else — the paths above are in its manifest, never on the screen
   ..    embedded every candidate's skeleton, atlas and page(s) as data URIs; the player itself loads from unpkg (@4.3.*), so the first open needs a network
 rigc: wrote …/semaphore/ballot.html  (22.3 KiB — open it in a browser)
-rigc: then record the saved vote with  rigc vote --record vote-bce70ad82fe90941.json --ballot …/semaphore/ballot.html
+rigc: then record the saved vote with  rigc vote --record vote-862f444c58d10e3e.json --ballot …/semaphore/ballot.html
 ```
 
 A person opens that page, watches two loops, picks one, and saves the small JSON it hands
 them. Then:
 
 ```bash
-rigc vote --record vote-bce70ad82fe90941.json --ballot ballot.html
+rigc vote --record vote-862f444c58d10e3e.json --ballot ballot.html
 ```
 
 ```
@@ -1140,8 +1144,8 @@ rigc vote --record vote-bce70ad82fe90941.json --ballot ballot.html
   PASS  V04_CHOICE_IS_ON_THE_BALLOT
   PASS  V05_REASON_CODE_FITS_THE_CHOICE
   PASS  V06_NOT_ALREADY_RECORDED
-  ..    winner A = sha256:6740d3dbf3043ff39c5f90577407c381f6841ff6af921517be7a0cfd3d7eb9d3, reason code preferred
-  ..    coverage 2 candidate(s): A=sha256:6740d3dbf304… B=sha256:d1bda24d7c36…
+  ..    winner A = sha256:c49e458df44efd277aa6e50ff8fa1962c1211c7617079d63fbc4cf8008eaf0c5, reason code preferred
+  ..    coverage 2 candidate(s): A=sha256:c49e458df44e… B=sha256:d1bda24d7c36…
 rigc: appended line 1 to …/semaphore/votes.jsonl
 ```
 
@@ -1169,9 +1173,13 @@ that the ends are stateable by construction (`pose`), that the file is checkable
 (`vote`).
 
 🚫 **No scoring of end-pose reach, and nothing here to add one to.** At L1 and L2 the
-end poses are given conditions; a number saying how near the animation got to them is a
-number about the pose estimator. This is why §6 does not run `check` on the two pictures
-and why no threshold, tolerance or pass bar appears anywhere in this document. The
+end poses are given conditions, and what a picture gives is a **pose**: the rotations are
+`pose`'s readings, which the spec states by construction, so a number for how near the
+animation got to *them* is a number about the pose estimator. The **offsets** are the
+other half — derived from the pictures rather than given — and a rig can miss its
+picture by a wrong one with every key exact. Catching that is a look, not a score (§6.5's
+frame-0 check). This is why §6 does not run `check` on the two pictures and why no
+threshold, tolerance or pass bar appears anywhere in this document. The
 residuals in a `pose` report are trust signals about *placements*, and AUTHORING §11.1
 says the same from the instrument's side.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spine-rigc",
-  "version": "1.5.2",
+  "version": "1.5.3",
   "description": "AI-authored Spine 2D rigging and animation, verified before it is written. rigc compiles a rig spec into Spine 4.3 skeleton data, round-trips it through spine-core and named assertions, and emits nothing that fails. Output imports into the Spine editor. Ships as an agent skill.",
   "type": "module",
   "bin": {

package/src/compile.ts

@@ -38,9 +38,9 @@ import { parseJsonWithPosition } from './json-position.ts';
 // The "did you mean" list on a missing atlas region, from the one implementation
 // of it — the same search serves `refuseUnknownKeys`, and a second copy here with
 // a threshold edited is how such a pair drifts apart.
-import { dottedPath, nearMisses, refuseNumbersTheFileCannotCarry, refuseValuesOfTheWrongType } from './keys.ts';
+import { dottedPath, nearMisses, refuseNumbersTheFileCannotCarry, refuseValuesOfTheWrongType, refuseValuesOutsideTheirSet } from './keys.ts';
 import type { ShapeVisit } from './keys.ts';
-import { MANIFEST_TYPES } from './types.ts';
+import { MANIFEST_ENUMS, MANIFEST_TYPES } from './types.ts';
 import { inEditorKeyOrder, withoutParserDefaults } from './keyorder.ts';
 import { EVERY_GLOBAL_PHYSICS, parseMotionSpec } from './motion.ts';
 import {
@@ -2062,7 +2062,13 @@ function compileInto(opts: CompileOptions, droppedStates: DroppedState[]): Compi
   // same rule over the other file whose numbers reach the skeleton.
   // Its values of the wrong type first (issue #890): `crop.h: "806"` built
   // green, the string coerced by whatever arithmetic read it.
-  if (manifest !== null && manifestPath !== null) refuseValuesOfTheWrongType(manifestShapeVisits(manifest), MANIFEST_TYPES, manifestPath);
+  if (manifest !== null && manifestPath !== null) {
+    const visits = manifestShapeVisits(manifest);
+    refuseValuesOfTheWrongType(visits, MANIFEST_TYPES, manifestPath);
+    // Then a name outside a stated set (issue #900): `mesh.kind: "foo"` was
+    // read as a ribbon by one reader and a ring by two others.
+    refuseValuesOutsideTheirSet(visits, MANIFEST_TYPES, MANIFEST_ENUMS, manifestPath);
+  }
   if (manifest !== null && manifestPath !== null) refuseNumbersTheFileCannotCarry(manifest, manifestPath, dottedPath);
 
   // The rig spec names its own path in every message `parseRigSpec` throws (its

package/src/keys.ts

@@ -219,8 +219,12 @@ export function dottedPath(path: ReadonlyArray<string | number>): string {
  *     kind of container is the refusal of the reader that walks it (a rig spec's
  *     `"bones"` that is not an array is *a rig spec needs a non-empty "bones"
  *     array*);
- *   - `enum` — a closed set of names, refused by name where it is read, with the
- *     names that exist listed (a slot's `blend`, a constraint's `type`);
+ *   - `enum` — a closed set of names. Every `enum` row has an entry in the
+ *     shape's enum table (`RIG_ENUMS`, `MOTION_ENUMS`, `MANIFEST_ENUMS`, typed by
+ *     `SpecEnumTable`), which either states the set — and
+ *     `refuseValuesOutsideTheirSet` refuses a value outside it — or names the
+ *     reader that refuses it where it reads it, with the names that exist listed
+ *     (a slot's `blend`, a constraint's `type`);
  *   - `mixed` — a union of kinds whose owner decides by the value (`MotionKey.v`
  *     is numbers on `rotate`, a name on `attachment`, a member map on a group).
  */
@@ -410,3 +414,73 @@ export function refuseValuesOfTheWrongType(
     }
   }
 }
+
+/**
+ * Who refuses a value outside an `enum` row's closed set (issue #900).
+ *
+ *   - `set` — the names the row accepts, refused from one place by
+ *     `refuseValuesOutsideTheirSet`; `readAs` is what the readers did with any
+ *     other value before the set was stated, which the refusal says, because
+ *     "one of" alone does not tell an author that the build they had was wrong;
+ *   - `owner` — the function that reads the value and refuses one outside its
+ *     set by name there, listing the names that exist. It keeps its own sentence,
+ *     which often says more than a set can (a first letter whose case is free, a
+ *     row chosen by the value itself).
+ */
+export type SpecEnumRule = { readonly set: readonly string[]; readonly readAs: string } | { readonly owner: string };
+
+/** The keys of a type row whose type is `enum`. */
+type EnumKeysOf<R> = { [K in keyof R]: R[K] extends 'enum' ? K : never }[keyof R];
+
+/**
+ * A type table's enum table: one entry per `enum` row, and nothing else.
+ *
+ * 🔒 `satisfies SpecEnumTable<typeof X_TYPES>` is what makes a fourth unowned
+ * enum a type error rather than a row nobody holds: a shape with an `enum` row
+ * must appear, with exactly its `enum` keys, and a key of another type cannot.
+ * A selftest control holds the same claim at runtime and reads each `owner`'s
+ * body for the key it is said to own.
+ */
+export type SpecEnumTable<T extends Readonly<Record<string, SpecTypeRow>>> = {
+  readonly [S in keyof T as [EnumKeysOf<T[S]>] extends [never] ? never : S]: { readonly [K in EnumKeysOf<T[S]>]: SpecEnumRule };
+};
+
+/**
+ * Refuse the first value of an `enum` row whose enum table states a set and
+ * that is not in it (issue #900).
+ *
+ * 🚨 The defect this closes was a green build again, one step past #890's:
+ * the type walk does not check `enum` (a name's type says nothing about which
+ * names exist), and three rows had nobody holding the name — `boneIndexing`,
+ * a bone's `from.rotation` and the cut manifest's `mesh.kind`. `"foo"` and `5`
+ * were each read as something the spec never said, in silence.
+ *
+ * It runs after the type walk and over the same visits, so a key the scan
+ * refused is never judged here, and before every reader. A row whose table
+ * entry names an `owner` is passed over: that reader refuses it with its own
+ * sentence. The order is the type walk's — visits in the scan's order, keys in
+ * the document's — so the refusal names the same value on every run.
+ */
+export function refuseValuesOutsideTheirSet(
+  visits: readonly ShapeVisit[],
+  types: Readonly<Record<string, SpecTypeRow>>,
+  enums: Readonly<Record<string, Readonly<Record<string, SpecEnumRule>>>>,
+  where: string,
+): void {
+  for (const visit of visits) {
+    const row = types[visit.shape];
+    if (row === undefined) throw new Error(`no type row for shape ${visit.shape} (a key scan visited a shape the type table does not have)`);
+    for (const key of Object.keys(visit.node)) {
+      if (row[key] !== 'enum') continue;
+      const rule = enums[visit.shape]?.[key];
+      if (rule === undefined) throw new Error(`${visit.shape}.${key} is an enum row with no entry in its enum table`);
+      if (!('set' in rule)) continue;
+      const value = visit.node[key];
+      if (typeof value === 'string' && rule.set.includes(value)) continue;
+      throw new CompileError(
+        `${where}: ${visit.name([key])} is ${JSON.stringify(value) ?? String(value)}; one of ` +
+          `${rule.set.map((name) => JSON.stringify(name)).join(', ')} — ${rule.readAs}`,
+      );
+    }
+  }
+}

package/src/motion.ts

@@ -54,8 +54,8 @@
  * [`keys.ts`](keys.ts) shared with the rig parser.
  */
 import { CompileError } from './errors.ts';
-import { dottedPath, refuseNumbersTheFileCannotCarry, refuseUnknownKeys, refuseValuesOfTheWrongType } from './keys.ts';
-import type { ShapeVisit, SpecValueType } from './keys.ts';
+import { dottedPath, refuseNumbersTheFileCannotCarry, refuseUnknownKeys, refuseValuesOfTheWrongType, refuseValuesOutsideTheirSet } from './keys.ts';
+import type { ShapeVisit, SpecEnumTable, SpecValueType } from './keys.ts';
 import { SEQUENCE_MODES } from './timelines.ts';
 import type { MotionSpec } from './types.ts';
 
@@ -165,9 +165,8 @@ export const MOTION_KEYS = {
  * fields nothing here reads — an ik key's `mix`, a deform key's `offset`, an
  * event key's `float`, a derive's `degrees`.
  *
- * Where an unchecked type is refused: `spec` — the version check; a track's
- * `property` — `compileTrack`; a derive's `kind` — `evaluateTrackDerive`; a deform
- * transform's `kind`, `along` and `axis` — `evaluateDeformTransform`;
+ * Where an unchecked type is refused: an `enum` row — the entry `MOTION_ENUMS`
+ * has for it, below, which is a table a control reads rather than a list here;
  * `MotionKey.v`, a key's `curve`, a derive's `depth` and `mix.pairs` (`mixed`)
  * — the track compiler by property, the curve reader, the derive evaluator and
  * `parseMix`. A sequence key's `mode` is a closed set too, but its interface
@@ -227,6 +226,24 @@ export const MOTION_TYPES = {
   DeformBend: { kind: 'enum', amount: 'number', from: 'number', to: 'number', power: 'number', along: 'enum', axis: 'enum' },
 } as const satisfies MotionTypeTable;
 
+/**
+ * Who refuses each `enum` row of `MOTION_TYPES` outside its set (issue #900);
+ * `SpecEnumTable` in [`keys.ts`](keys.ts) says what an entry means. Every one
+ * is an owner: measured when this table was written, a planted `5` and `"foo"`
+ * on each row was refused by name by the reader named here, listing the names
+ * that exist, so none of them states a set. A deform transform's and a derive's
+ * `kind` choose the row they are checked against, as a generator's does.
+ */
+export const MOTION_ENUMS = {
+  MotionSpec: { spec: { owner: 'parseMotionSpecInto' } },
+  MotionTrack: { property: { owner: 'compileTrack' } },
+  TrackDeriveTurn: { kind: { owner: 'evaluateTrackDerive' } },
+  DeformTurn: { kind: { owner: 'evaluateDeformTransform' } },
+  DeformAffine: { kind: { owner: 'evaluateDeformTransform' } },
+  DeformWave: { kind: { owner: 'evaluateDeformTransform' }, along: { owner: 'evaluateDeformTransform' }, axis: { owner: 'evaluateDeformTransform' } },
+  DeformBend: { kind: { owner: 'evaluateDeformTransform' }, along: { owner: 'evaluateDeformTransform' }, axis: { owner: 'evaluateDeformTransform' } },
+} as const satisfies SpecEnumTable<typeof MOTION_TYPES>;
+
 /** A deform key's `transform` kinds, and the shape each one's keys come from. */
 const DEFORM_TRANSFORM_SHAPE: Record<string, keyof typeof MOTION_KEYS> = {
   yaw: 'DeformTurn',
@@ -778,6 +795,9 @@ function parseMotionSpecInto(raw: unknown, where: string, visits: readonly Shape
   // as an event with no audio, a yaw transform's `"depth": "true"` as a radius
   // that is undefined.
   refuseValuesOfTheWrongType(visits, MOTION_TYPES, where);
+  // Every `enum` row here names an owner, so this refuses nothing today; it is
+  // called so that a row given a set is refused from the day it is given one.
+  refuseValuesOutsideTheirSet(visits, MOTION_TYPES, MOTION_ENUMS, where);
 
   // Last, so every field check above keeps its own sentence for a number that
   // is not finite; what reaches this line is a finite double the float32 file

package/src/rig.ts

@@ -60,8 +60,8 @@
  * with no manifest at all declares them here.
  */
 import { CompileError, NotImplementedError } from './errors.ts';
-import { dottedPath, refuseNumbersTheFileCannotCarry, refuseUnknownKeys, refuseValuesOfTheWrongType } from './keys.ts';
-import type { ShapeVisit, SpecValueType } from './keys.ts';
+import { dottedPath, refuseNumbersTheFileCannotCarry, refuseUnknownKeys, refuseValuesOfTheWrongType, refuseValuesOutsideTheirSet } from './keys.ts';
+import type { ShapeVisit, SpecEnumTable, SpecValueType } from './keys.ts';
 
 export { CompileError, NotImplementedError };
 
@@ -1866,29 +1866,20 @@ export const RIG_KEYS = {
  * field declared `number` and typed `string` here is a red run rather than a
  * refusal of correct work.
  *
- * Where an unchecked type (`object`, `enum`, `mixed` — see `SPEC_VALUE_TYPES`)
- * is refused, and by what:
- *
- *   - the version tag `spec` — `parseRigSpec`, before anything else;
- *   - `inherit` — `resolveBoneInherit`; `blend` — the slot loop
- *     (`RIG_SLOT_BLEND`); `consumerDrivenMix[].type` — the invariants block;
- *   - a constraint's `type` — `buildRigConstraint`; `scaleY` on ik, a path
- *     constraint's three modes and a slider's `property` — the builder of that
- *     constraint kind, each listing the names that exist;
- *   - an attachment's `type` — the attachment reader; `depth.near` — the depth
- *     map reader;
- *   - `RigSegmentsGenerator.bones` (`mixed`: a name, a chain of names or a span)
- *     — the segments generator, by index.
- *
- * 🚨 Measured when this table was written, three `enum` keys have **no** owner,
- * and the table does not pretend otherwise: `boneIndexing` built green at `5`
- * and at `"foo"` (on a weighted mesh too), `from.rotation` built green at `5`
- * and at `"foo"` on an anchored bone, and a generator `kind` of `5` or `"foo"`
- * threw a `TypeError` (*undefined is not an object (evaluating
- * 'generator.size')*) rather than the mesh builder's refusal. Each is a closed
- * set of names with nobody holding the name, which is a value refusal and not a
- * type one, so it is not fixed here. `scaleY` on a physics constraint was not
- * measured.
+ * Where an unchecked `object` or `mixed` row is refused: a nested shape by the
+ * reader that walks it; `RigSegmentsGenerator.bones` (`mixed`: a name, a chain
+ * of names or a span) by the segments generator, by index. Where an `enum` row
+ * is refused is not a list in prose any more: `RIG_ENUMS`, below, has one entry
+ * per `enum` row — a set refused by `refuseValuesOutsideTheirSet`, or the
+ * reader that refuses it — and `satisfies` makes a row without one a type error.
+ *
+ * ⚠️ Until issue #900 this comment carried that list, and ended by naming three
+ * `enum` keys with **no** owner: `boneIndexing`, `from.rotation` and a
+ * generator `kind`. The list was right about the three and wrong by omission
+ * about a fourth — the cut manifest's `mesh.kind`, which `MANIFEST_TYPES` said
+ * "the manifest mesh reader" held and which that reader read as a ribbon in one
+ * place and a ring in another. A list of owners in a comment is a claim nothing
+ * checks; the table is one a control reads.
  */
 type RigTypeTable = {
   readonly [S in keyof typeof RIG_KEYS]: { readonly [K in (typeof RIG_KEYS)[S][number]]: SpecValueType };
@@ -1998,6 +1989,70 @@ export const RIG_TYPES = {
   RigSoftRegion: { bone: 'string', mask: 'string' },
 } as const satisfies RigTypeTable;
 
+/** The two sources a bone's `from.rotation` names (`RigBoneFrom.rotation`). */
+export const RIG_FROM_ROTATIONS = ['axis', 'anchor'] as const satisfies ReadonlyArray<NonNullable<RigBoneFrom['rotation']>>;
+
+/** The two ways a weighted `vertices` run names its bones (`RigMeshAttachment.boneIndexing`). */
+export const RIG_BONE_INDEXING = ['name', 'raw'] as const satisfies ReadonlyArray<NonNullable<RigMeshAttachment['boneIndexing']>>;
+
+/** What `boneIndexing` outside its set was read as, measured before issue #900. */
+const BONE_INDEXING_READ_AS =
+  'anything else was read as the default "name" in silence: a weighted "vertices" run was refused as unflagged, ' +
+  'and every other attachment built byte for byte as if the key were absent';
+
+/**
+ * Who refuses each `enum` row of `RIG_TYPES` outside its set (issue #900) —
+ * `SpecEnumTable` in [`keys.ts`](keys.ts) says what the two kinds of entry
+ * mean, and `satisfies` makes an `enum` row without one a type error.
+ *
+ * ⭐ A `set` is stated for exactly the rows nobody held: measured when this
+ * table was written, `boneIndexing` built green at `5`, `"foo"` and `"named"`
+ * (the spelling the issue itself used) as the default, and `from.rotation`
+ * built green at `5` and `"foo"` with the bone's setup rotation dropped. Every
+ * other row already had a reader that refused a planted `5` and `"foo"` by
+ * name, and keeps it; the generator's `kind` is the one of those that is a
+ * dispatch, and its refusal is new — it threw a `TypeError` (*undefined is not
+ * an object (evaluating 'generator.size')*), because the scan skipped a `kind`
+ * it had no row for and the mesh builder fell through to the ring branch.
+ */
+export const RIG_ENUMS = {
+  RigSpec: { spec: { owner: 'parseRigSpec' } },
+  RigBone: { inherit: { owner: 'parseRigSpec' } },
+  RigBoneFrom: {
+    rotation: {
+      set: RIG_FROM_ROTATIONS,
+      readAs: 'anything else was read as no rotation source, and the bone was emitted without the setup rotation it asked for',
+    },
+  },
+  RigSlot: { blend: { owner: 'parseRigSpec' } },
+  RigConsumerDrivenMix: { type: { owner: 'parseRigSpec' } },
+  RigIkConstraint: { type: { owner: 'buildRigConstraint' }, scaleY: { owner: 'buildRigConstraint' } },
+  RigTransformConstraint: { type: { owner: 'buildRigConstraint' } },
+  RigPathConstraint: {
+    type: { owner: 'buildRigConstraint' },
+    positionMode: { owner: 'buildRigConstraint' },
+    spacingMode: { owner: 'buildRigConstraint' },
+    rotateMode: { owner: 'buildRigConstraint' },
+  },
+  RigPhysicsConstraint: { type: { owner: 'buildRigConstraint' }, scaleY: { owner: 'buildRigConstraint' } },
+  RigSliderConstraint: { type: { owner: 'buildRigConstraint' }, property: { owner: 'buildRigConstraint' } },
+  RigRegionAttachment: { type: { owner: 'buildRigAttachment' } },
+  RigMeshAttachment: { type: { owner: 'buildRigAttachment' }, boneIndexing: { set: RIG_BONE_INDEXING, readAs: BONE_INDEXING_READ_AS } },
+  RigLinkedMeshAttachment: { type: { owner: 'buildRigAttachment' }, boneIndexing: { set: RIG_BONE_INDEXING, readAs: BONE_INDEXING_READ_AS } },
+  RigBoundingBoxAttachment: { type: { owner: 'buildRigAttachment' }, boneIndexing: { set: RIG_BONE_INDEXING, readAs: BONE_INDEXING_READ_AS } },
+  RigClippingAttachment: { type: { owner: 'buildRigAttachment' }, boneIndexing: { set: RIG_BONE_INDEXING, readAs: BONE_INDEXING_READ_AS } },
+  RigPathAttachment: { type: { owner: 'buildRigAttachment' }, boneIndexing: { set: RIG_BONE_INDEXING, readAs: BONE_INDEXING_READ_AS } },
+  // The generator's `kind` chooses the row its other keys are checked against,
+  // so a `kind` outside the five has no row to be visited in: the scan that
+  // dispatches on it is where it is refused.
+  RigRingGenerator: { kind: { owner: 'checkRigSpecKeys' } },
+  RigRibbonGenerator: { kind: { owner: 'checkRigSpecKeys' } },
+  RigContourGenerator: { kind: { owner: 'checkRigSpecKeys' } },
+  RigGridGenerator: { kind: { owner: 'checkRigSpecKeys' } },
+  RigSegmentsGenerator: { kind: { owner: 'checkRigSpecKeys' } },
+  RigDepthMap: { near: { owner: 'sampleMeshDepth' } },
+} as const satisfies SpecEnumTable<typeof RIG_TYPES>;
+
 /**
  * The five constraint `type` names, and the shape each one's keys come from.
  *
@@ -2024,7 +2079,7 @@ const ATTACHMENT_SHAPE: Record<string, keyof typeof RIG_KEYS> = {
 };
 
 /** The generator `kind` names, and the shape each one's keys come from. */
-const GENERATOR_SHAPE: Record<string, keyof typeof RIG_KEYS> = {
+const GENERATOR_SHAPE: Record<(typeof RIG_GENERATOR_KINDS)[number], keyof typeof RIG_KEYS> = {
   ring: 'RigRingGenerator',
   ribbon: 'RigRibbonGenerator',
   contour: 'RigContourGenerator',
@@ -2239,10 +2294,21 @@ function checkRigSpecKeys(raw: Record<string, unknown>, where: string): Array<{
         }
         if (!isObj(att.generator)) continue;
         const gen = att.generator;
-        const genShape = GENERATOR_SHAPE[String(gen.kind)];
-        // Same rule as an unknown attachment type: an unknown `kind` is the mesh
-        // builder's refusal, which can name the four that exist.
-        if (genShape === undefined) continue;
+        const kind = RIG_GENERATOR_KINDS.find((k) => k === gen.kind);
+        const genShape = kind === undefined ? undefined : GENERATOR_SHAPE[kind];
+        // 🚨 An unknown `kind` used to be skipped here as "the mesh builder's
+        // refusal", and the mesh builder had none: `buildGeneratedMesh` fell
+        // through to the ring branch and threw a TypeError reading
+        // `generator.size` (issue #900). `kind` chooses the row every other key
+        // of the generator is checked against, so this dispatch is the one
+        // place that can refuse it — before any of those keys is judged.
+        if (genShape === undefined) {
+          const stated = gen.kind === undefined ? 'absent' : (JSON.stringify(gen.kind) ?? String(gen.kind));
+          throw new CompileError(
+            `${where}: ${who} generator.kind is ${stated}; one of ${RIG_GENERATOR_KINDS.map((k) => JSON.stringify(k)).join(', ')} — ` +
+              'the kind names the builder, and each builder reads its own keys, so nothing about the mesh can be checked or built without one',
+          );
+        }
         at(gen, genShape, `${who} generator (${String(gen.kind)})`, [...here, 'generator']);
         at(gen.bias, 'RigMeshBias', `${who} generator.bias`, [...here, 'generator', 'bias']);
         at(gen.depth, 'RigDepthMap', `${who} generator.depth`, [...here, 'generator', 'depth']);
@@ -2338,11 +2404,13 @@ export function parseRigSpec(raw: unknown, where: string): RigSpec {
   // `constraint.skin === true` reads `"skin": "true"` as a constraint that asks
   // for no skin. The price, measured, is three controls whose type half pinned an
   // older sentence (RF86, PS177, PS189); their other halves are unchanged.
-  refuseValuesOfTheWrongType(
-    visits.map((v) => ({ node: v.node, shape: v.shape, name: (tail) => place([...v.path, ...tail]) })),
-    RIG_TYPES,
-    where,
-  );
+  const shapeVisits: ShapeVisit[] = visits.map((v) => ({ node: v.node, shape: v.shape, name: (tail) => place([...v.path, ...tail]) }));
+  refuseValuesOfTheWrongType(shapeVisits, RIG_TYPES, where);
+  // A name outside an `enum` row's stated set (issue #900), after the type walk
+  // and over the same visits: `boneIndexing: "foo"` built as the default and
+  // `from.rotation: "foo"` as no rotation, both green. A row whose entry names
+  // an owner is that reader's to refuse, in its own words.
+  refuseValuesOutsideTheirSet(shapeVisits, RIG_TYPES, RIG_ENUMS, where);
   // After the key check, so a misspelled key is named as a misspelling before
   // its value is judged, and before every reader below, so no range rule or
   // derived number ever meets a value the file cannot carry (issue #881).

package/src/types.ts

@@ -17,7 +17,7 @@
 import type { AtlasRegion } from './atlas.ts';
 import type { DeformTransform, DeformTransformReport } from './deformgen.ts';
 import type { TurnCeiling } from './depth.ts';
-import type { SpecTypeRow } from './keys.ts';
+import type { SpecEnumTable, SpecTypeRow } from './keys.ts';
 import type { MeshKind } from './mesh.ts';
 import type { TrackDerive, TrackDeriveReport } from './trackgen.ts';
 
@@ -185,9 +185,9 @@ export interface FaceManifest {
  * wrong-typed plants on the three fixture manifests built green —
  * `crop.h: "256"` among them — and 4 threw a TypeError from `node:path`.
  *
- * Unchecked: `mesh.kind` and `mesh.hull` (`enum`) — the manifest mesh reader;
- * `crop` and the other nested shapes, `parts` and `mesh` (`object`) — the
- * readers that walk them.
+ * Unchecked by this walk: `mesh.kind` and `mesh.hull` (`enum`) — see
+ * `MANIFEST_ENUMS`, below; `crop` and the other nested shapes, `parts` and
+ * `mesh` (`object`) — the readers that walk them.
  */
 export const MANIFEST_TYPES = {
   FaceManifest: {
@@ -211,6 +211,34 @@ export const MANIFEST_TYPES = {
   'FaceManifestMesh.bias': { axis_deg: 'number', ramp: 'number[]', note: 'string' },
 } as const satisfies Record<string, SpecTypeRow>;
 
+/** The two mesh generators a manifest part may name (`FaceManifestMesh.kind`); absent means `ring`. */
+export const MANIFEST_MESH_KINDS = ['ring', 'ribbon'] as const satisfies ReadonlyArray<NonNullable<FaceManifestMesh['kind']>>;
+
+/**
+ * Who refuses each `enum` row of `MANIFEST_TYPES` outside its set (issue #900);
+ * `SpecEnumTable` in [`keys.ts`](keys.ts) says what an entry means.
+ *
+ * 🚨 `mesh.kind` was listed as held by "the manifest mesh reader", and it was
+ * not held at all: that reader has three places that ask the kind, and they
+ * disagreed about a value outside the two. The mesh checks read `"foo"` as a
+ * ribbon, while the control-bone reader and the geometry builder read it as a
+ * ring — so a ring part was refused as *a ribbon mesh needs mesh.rows and a
+ * mesh.chain*, and a ribbon part as *a mesh with no control bone deforms
+ * nothing*, both naming a fault the part did not have. `hull` is held: the ring
+ * check refuses anything but `"polygon"` by name, and keeps that sentence.
+ */
+export const MANIFEST_ENUMS = {
+  FaceManifestMesh: {
+    kind: {
+      set: MANIFEST_MESH_KINDS,
+      readAs:
+        'anything else was read as a ribbon by the mesh checks and as a ring by the control-bone reader and the ' +
+        'geometry builder, so the refusal it got named a fault the part did not have',
+    },
+    hull: { owner: 'compileInto' },
+  },
+} as const satisfies SpecEnumTable<typeof MANIFEST_TYPES>;
+
 // ---------------------------------------------------------------------------
 // Motion spec  (spec: "rigc-motion/1")
 // ---------------------------------------------------------------------------

package/src/validate.ts

@@ -289,16 +289,17 @@ export const SKIP_NO_ATLAS = 'the round trip did not produce an atlas to measure
  *     `A15_IDLE_NO_MESH_BONE_KEYS` is the pattern and already reads this way: no
  *     `idle` animation, or an `idle` with no bone timeline, is the named subject
  *     absent and SKIPs; no mesh-driving bone among the bones `idle` does key is
- *     the construct absent and passes. `A10_NO_NAN_AFTER_STEPPING` is the same
- *     shape — the stepping is per animation, so a skeleton with none has not
- *     been stepped.
+ *     the construct absent and passes. `A10_NO_NAN_AFTER_STEPPING` was the same
+ *     shape until issue #902, and is the next bullet's now: #882 gave it a
+ *     setup-pose clause whose subject is the bones, beside the stepping clause
+ *     whose subject is the animations.
  *   * An assertion with more than one clause SKIPs only when EVERY clause had
  *     nothing to measure, which is the shape `A09`, `A33` and `A38` already
- *     carry (`polygons.length === 0 && endsChecked === 0`). `A13_MESH_BUDGET` is
- *     why the clause is stated: a declared slot budget is measured against a
- *     count of mesh slots, and zero is a count, so that half passes on a rig
- *     with no mesh — while a rig that declares only a TRIANGLE budget has
- *     nothing left to measure and skips.
+ *     carry (`polygons.length === 0 && endsChecked === 0`), and `A10` since #902.
+ *     `A13_MESH_BUDGET` is why the clause is stated: a declared slot budget is
+ *     measured against a count of mesh slots, and zero is a count, so that half
+ *     passes on a rig with no mesh — while a rig that declares only a TRIANGLE
+ *     budget has nothing left to measure and skips.
  *
  * ⚠️ What the criterion is not allowed to become is a table of assertions with
  * their verdicts written beside them. Every row above is decided by reading the
@@ -318,6 +319,13 @@ export const SKIP_NO_ATLAS = 'the round trip did not produce an atlas to measure
 export const SKIP_NO_REGION_ATTACHMENT = 'the skeleton carries no region attachment';
 export const SKIP_NO_MESH_ATTACHMENT = 'the skeleton carries no mesh attachment';
 export const SKIP_NO_ANIMATION = 'the skeleton carries no animation';
+/**
+ * A10's (issue #902): its setup clause reads the bones and its stepping clause
+ * the animations, so it skips only when the skeleton carries neither — and the
+ * sentence is `SKIP_NO_ANIMATION`'s with the second subject added, so the two
+ * cannot drift into different words for the same absence.
+ */
+export const SKIP_NO_POSE = `${SKIP_NO_ANIMATION} and no bone, so there is no setup pose to read and nothing to step`;
 export const SKIP_NO_TIMELINE = 'no animation here carries a timeline';
 export const SKIP_NO_PHYSICS_CONSTRAINT = 'the skeleton declares no physics constraint';
 export const SKIP_NO_ATLAS_PAGE = 'the atlas declares no page';
@@ -4336,13 +4344,31 @@ export function validate(input: ValidateInput): ValidateReport {
 
     // --- A10: step every animation and look for NaN ------------------------
     check('A10_NO_NAN_AFTER_STEPPING', () => {
-      // The name carries a subject as well as a construct, and A15 is the
-      // pattern (#580): the NaN is produced by STEPPING, which happens once per
-      // animation, so a skeleton with none has not been stepped and has no pose
-      // to find non-finite. A09 already reads the same subject this way — a
-      // static rig has no duration to compare — and the two must not print
-      // different verdicts over one skeleton's empty animation list.
-      if (data.animations.length === 0) return skip('A10_NO_NAN_AFTER_STEPPING', SKIP_NO_ANIMATION);
+      // Two clauses, and since issue #902 each is read on its own subject. The
+      // SETUP POSE is posed from the bones, so it has something to read on any
+      // skeleton that carries one; the STEPPED FRAMES are posed once per
+      // animation, so a skeleton with none has nothing to step. This used to
+      // skip the whole rule on the second fact alone, which was A15's pattern
+      // (#580) for a rule whose only clause was the stepping — and #882 gave it
+      // the setup clause without moving the skip. Measured on the static probe
+      // with a leaf bone at `rotation: 1e309` in its emitted file: `validate`
+      // printed this rule as SKIP and the run green under both profiles, and
+      // `render` refused the same file by the bone. A static rig's setup pose
+      // is the whole of what it shows, so that was the one pose nothing read.
+      //
+      // ⇒ The multi-clause rule of #580 now governs, the shape A09, A13, A33
+      // and A38 carry: the rule SKIPs only when neither clause has anything to
+      // measure, the clause that ran decides PASS or FAIL, and the clause that
+      // had nothing is named on the stats line (`nanStepping=skipped`, beside
+      // `animations=0`) the way A47 names a constraint it did not measure. A
+      // PASS row carries no detail, which is why the stats line is where.
+      //
+      // ⚠️ A09 does not follow, and that is its own name read at its word: a
+      // declared duration is a fact about an animation and nothing else, so a
+      // static rig still gives it nothing at all.
+      if (data.animations.length === 0 && data.bones.length === 0) {
+        return skip('A10_NO_NAN_AFTER_STEPPING', SKIP_NO_POSE);
+      }
       /** Is this a mode `updateWorldTransform`'s switch has a case for? Read off the runtime's own enum. */
       const isMode = (inherit: unknown): boolean => typeof inherit === 'number' && Inherit[inherit] !== undefined;
 
@@ -4421,6 +4447,73 @@ export function validate(input: ValidateInput): ValidateReport {
       // below is posed AFTER `state.apply`, so a bone the animation keys from
       // t=0 never shows its setup value to the loop, and a runtime that shows
       // the rig at rest does show it.
+      //
+      // 🔸 Posed once, before any animation is set, rather than once per
+      // animation as it was until #902: `setAnimation` does not touch the
+      // skeleton, so every animation's copy of this pose was the same pose, and
+      // the first of them was the only one ever read.
+      if (data.animations.length === 0) stats.nanStepping = 'skipped';
+      const atRest = new Skeleton(data);
+      atRest.setupPose();
+      atRest.update(0);
+      atRest.updateWorldTransform(Physics.reset);
+      const atSetup = nonFiniteOfPosed('the setup pose', atRest);
+      if (atSetup !== null) {
+        fail('A10_NO_NAN_AFTER_STEPPING', atSetup);
+        return;
+      }
+
+      /**
+       * What a posed frame shows that the world-transform scan does not read: a
+       * bone posing no inheritance mode, and a slot colour that is not finite.
+       * `where` leads the sentence — the animation's name at a stepped frame,
+       * as it always has, or `the setup pose` on a skeleton with no animation.
+       */
+      const poseDefect = (where: string, skeleton: Skeleton): string | null => {
+        for (const bone of skeleton.bones) {
+          const pose = bone.appliedPose;
+          // The setup half of the inherit-key clause above: a bone's own
+          // `inherit` goes through the same lookup, and a miss there loads
+          // `undefined` into the setup pose, which every frame copies. Only
+          // reachable on a file rigc did not write — `parseRigSpec` refuses the
+          // spelling.
+          if (!isMode(pose.inherit)) {
+            const rawBone = Array.isArray(raw?.bones)
+              ? (raw.bones as unknown[]).find((b) => isObj(b) && b.name === bone.data.name)
+              : undefined;
+            return (
+              `${where}: bone "${bone.data.name}" poses inheritance mode ${String(pose.inherit)} — its setup ` +
+              `spells inherit ${JSON.stringify(isObj(rawBone) ? rawBone.inherit : undefined)}, which the ` +
+              `runtime's mode lookup does not resolve (${BONE_INHERIT_KNOWN}), so its world rotation, scale and shear ` +
+              'are never computed — they stay 0 and everything the bone carries collapses to a point'
+            );
+          }
+        }
+        for (const slot of skeleton.slots) {
+          const c = slot.appliedPose.color;
+          if (![c.r, c.g, c.b, c.a].every(Number.isFinite)) return `${where}: slot "${slot.data.name}" colour is non-finite`;
+          // The other colour a slot poses, and it was outside this loop until
+          // issue #690 for the reason every gap here has: nothing emitted one.
+          // `null` is the ordinary case — a slot with no `dark` allocates no
+          // dark colour at all — and is not a reading to make, so it is
+          // skipped rather than treated as zero.
+          const d = slot.appliedPose.darkColor;
+          if (d !== null && ![d.r, d.g, d.b].every(Number.isFinite)) {
+            return `${where}: slot "${slot.data.name}" dark colour is non-finite`;
+          }
+        }
+        return null;
+      };
+
+      // The stepping half, and on a static rig there is nothing to step: the
+      // setup pose is then the only frame the skeleton has, and the two readings
+      // a stepped frame gets are made on it instead, so a colour or an
+      // inheritance mode the rig shows at rest is not left to `render`.
+      if (data.animations.length === 0) {
+        const atRestDefect = poseDefect('the setup pose', atRest);
+        if (atRestDefect !== null) fail('A10_NO_NAN_AFTER_STEPPING', atRestDefect);
+        return;
+      }
       for (const anim of data.animations) {
         const skeleton = new Skeleton(data);
         const state = new AnimationState(new AnimationStateData(data));
@@ -4428,11 +4521,6 @@ export function validate(input: ValidateInput): ValidateReport {
         skeleton.setupPose();
         skeleton.update(0);
         skeleton.updateWorldTransform(Physics.reset);
-        const atSetup = nonFiniteOfPosed('the setup pose', skeleton);
-        if (atSetup !== null) {
-          fail('A10_NO_NAN_AFTER_STEPPING', atSetup);
-          return;
-        }
         const step = Math.max(anim.duration, 1) / STEP_FRAMES;
         for (let i = 0; i < STEP_FRAMES; i++) {
           state.update(step);
@@ -4447,42 +4535,10 @@ export function validate(input: ValidateInput): ValidateReport {
             fail('A10_NO_NAN_AFTER_STEPPING', found);
             return;
           }
-          for (const bone of skeleton.bones) {
-            const pose = bone.appliedPose;
-            // The setup half of the clause above: a bone's own `inherit` goes
-            // through the same lookup, and a miss there loads `undefined` into
-            // the setup pose, which every frame copies. Only reachable on a
-            // file rigc did not write — `parseRigSpec` refuses the spelling.
-            if (!isMode(pose.inherit)) {
-              const rawBone = Array.isArray(raw?.bones)
-                ? (raw.bones as unknown[]).find((b) => isObj(b) && b.name === bone.data.name)
-                : undefined;
-              fail(
-                'A10_NO_NAN_AFTER_STEPPING',
-                `${anim.name}: bone "${bone.data.name}" poses inheritance mode ${String(pose.inherit)} — its setup ` +
-                  `spells inherit ${JSON.stringify(isObj(rawBone) ? rawBone.inherit : undefined)}, which the ` +
-                  `runtime's mode lookup does not resolve (${BONE_INHERIT_KNOWN}), so its world rotation, scale and shear ` +
-                  'are never computed — they stay 0 and everything the bone carries collapses to a point',
-              );
-              return;
-            }
-          }
-          for (const slot of skeleton.slots) {
-            const c = slot.appliedPose.color;
-            if (![c.r, c.g, c.b, c.a].every(Number.isFinite)) {
-              fail('A10_NO_NAN_AFTER_STEPPING', `${anim.name}: slot "${slot.data.name}" colour is non-finite`);
-              return;
-            }
-            // The other colour a slot poses, and it was outside this loop until
-            // issue #690 for the reason every gap here has: nothing emitted one.
-            // `null` is the ordinary case — a slot with no `dark` allocates no
-            // dark colour at all — and is not a reading to make, so it is
-            // skipped rather than treated as zero.
-            const d = slot.appliedPose.darkColor;
-            if (d !== null && ![d.r, d.g, d.b].every(Number.isFinite)) {
-              fail('A10_NO_NAN_AFTER_STEPPING', `${anim.name}: slot "${slot.data.name}" dark colour is non-finite`);
-              return;
-            }
+          const defect = poseDefect(anim.name, skeleton);
+          if (defect !== null) {
+            fail('A10_NO_NAN_AFTER_STEPPING', defect);
+            return;
           }
         }
       }