spine-rigc 1.5.0 → 1.5.1

package/docs/AUTHORING.md

@@ -1298,6 +1298,14 @@ emitted as written, in the default skin or anywhere else.
 `spec` must be exactly `"rigc-rig/1"`. `name` must be a non-empty string. `bones`
 must be non-empty. `slots` must be present (it may be empty).
 
+🔢 **Every number in a rig spec is finite at float32 precision** — at most
+±3.4028234663852886e38 — whatever field it is in, so the ranges the tables below
+state are ranges *within* that. The skeleton is written as float32, and a number
+past that line would be emitted as Infinity, which JSON writes as `null`: `1e309`
+(which JSON reads as Infinity) and `1e308` (a finite double with no float32) are
+both refused by the field they are in, before anything is compiled (§5.1). The cut
+manifest and the motion spec are held to the same line.
+
 🚫 **Every example value below is invented.** Names, coordinates, vertex lists and
 payloads in this guide are written to illustrate a field, never copied out of a
 reference export — an example lifted from one would be handing an authoring agent an
@@ -5429,11 +5437,14 @@ corpus inventory, and a ladder run reads this guide without following its refere
 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. `validate`
-does not always get there first: a bone `rotation` of `1e309`, in the setup pose or
-in a key, was measured leaving `A10_NO_NAN_AFTER_STEPPING` green, because the bone's
-world position stays finite while its matrix is `NaN`. The sentence, and where to
-look for the number, is under *nothing to draw* in §3.4.
+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
+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.
 
 ### 5.1 Compile errors — before the gate
 
@@ -5558,6 +5569,7 @@ 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 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 is not refused by this row — write a number as a JSON number |
 | `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 |
 | `physics constraint "X" is declared in both the rig spec and the motion spec's physics table` | §4.6 — the rig spec declares a physics constraint's structure and the motion spec's `physics` table declares one outright; pick the file it belongs in. Per kind, like every other constraint name: an `ik` "X" in the rig spec beside a `physics` "X" here is two constraints and is not this error |
@@ -5783,7 +5795,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 `NaN` pose. Look for 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 **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 |
 | `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 |
@@ -8840,8 +8852,8 @@ Found within 2 px of the truth, out of 15 trials per cell (free search, default
 
 | texture level (mean) | 24 px | 32 px | 48 px | 64 px | 96 px | 128 px | 192 px |
 | --- | --- | --- | --- | --- | --- | --- | --- |
-| `native` (detail 3.49) | 13/15 (2 amb) | 15/15 | 15/15 | 15/15 | 13/15 (1 amb, 1 wrong) | 14/15 (1 wrong) | 14/15 (1 wrong) |
-| `blur1` (detail 1.58) | 12/15 (3 amb) | 12/15 (2 amb, 1 wrong) | 13/15 (2 amb) | 12/15 (3 amb) | 12/15 (2 amb, 1 wrong) | 11/15 (1 amb, 3 wrong) | 11/15 (2 amb, 2 wrong) |
+| `native` (detail 3.49) | 13/15 (2 amb) | 15/15 | 15/15 | 15/15 | 14/15 (1 wrong) | 14/15 (1 wrong) | 14/15 (1 wrong) |
+| `blur1` (detail 1.58) | 12/15 (3 amb) | 12/15 (3 amb) | 13/15 (2 amb) | 12/15 (3 amb) | 12/15 (2 amb, 1 wrong) | 11/15 (1 amb, 3 wrong) | 11/15 (2 amb, 2 wrong) |
 | `blur2` (detail 0.59) | 9/15 (5 amb, 1 wrong) | 9/15 (4 amb, 2 wrong) | 9/15 (4 amb, 2 wrong) | 8/15 (3 amb, 4 wrong) | 7/15 (3 amb, 5 wrong) | 6/15 (4 amb, 5 wrong) | 7/15 (3 amb, 5 wrong) |
 | `flat` (detail 0.00) | 0/15 (14 amb, 1 wrong) | 0/15 (14 amb, 1 wrong) | 0/15 (13 amb, 2 wrong) | 0/15 (11 amb, 4 wrong) | 0/15 (13 amb, 2 wrong) | 0/15 (12 amb, 3 wrong) | 0/15 (12 amb, 3 wrong) |
 
@@ -8850,14 +8862,14 @@ The same trials, grouped by `detail`:
 | detail | found | ambiguous | wrong | refused |
 | --- | --- | --- | --- | --- |
 | under 0.25 | 8/119 | 89 | 22 | 0 |
-| 0.25–0.5 | 1/3 | 1 | 1 | 0 |
-| 0.5–0.75 | 48/81 | 14 | 19 | 0 |
+| 0.25–0.5 | 0/3 | 2 | 1 | 0 |
+| 0.5–0.75 | 49/81 | 13 | 19 | 0 |
 | 0.75–1 | 17/34 | 14 | 3 | 0 |
 | 1–1.5 | 25/25 | 0 | 0 | 0 |
-| 1.5–2 | 34/48 | 12 | 2 | 0 |
+| 1.5–2 | 34/48 | 13 | 1 | 0 |
 | 2–3 | 40/44 | 1 | 3 | 0 |
 | 3–4 | 34/34 | 0 | 0 | 0 |
-| 4 and over | 30/32 | 2 | 0 | 0 |
+| 4 and over | 31/32 | 1 | 0 | 0 |
 
 **Method.** The truth set is `examples/spineboy`: its setup pose and one frame of
 `walk` (a third of the way in). For every trial the figure is rendered twice with one
@@ -8879,8 +8891,8 @@ part has a low per-pixel gradient and still places — and size alone has no
 measurable effect across 24–192 px at any level.
 
 **The edge**, derived by `deriveFloor` as the largest rung of a fixed ladder under
-which at most a tenth of the trials were found: **`detail` 0.5**. Under it, **7.4%**
-of the trials were found (9/122); at or over it, **76.5%** (228/298). A part is below
+which at most a tenth of the trials were found: **`detail` 0.5**. Under it, **6.6%**
+of the trials were found (8/122); at or over it, **77.2%** (230/298). A part is below
 the floor when its `detail` is under 0.5, or when its own longest side is under 24 px,
 the smallest size measured (there, nothing measured says `pose` can place it).
 
@@ -8911,16 +8923,29 @@ blurred part now reported with a second placement at the same spot and another
 scale, one of them with the truth itself as its best answer), for 43% more
 refinement samples and the coarse pass untouched.
 
-⚠️ **What this is and is not.** The grid is not a reliability line: five native cells
-place 14 or 15 of 15 and the trials at `detail` 3 and over place 64 of 66, but the
-goggles still place 12 of 42, and a threshold read off two dozen parts of one figure
+Since issue #886 the stopped polish tries **a quarter rung** (2^(1/12)) beside the
+half and keeps the better re-fit. The case was not a grid trial but §6's stationary
+post in [MOTION.md](MOTION.md): under `--scale 0.85,1.2` it came back at scale
+0.917, residual 0.0649, where the old placement at 0.975 still scores 0.0589. The
+half rung stepped from 0.917 to 1.029, where the best position scores 0.0980 — a part
+that fills its image pays for every pixel pushed past the figure, so above its truth
+the objective is a cliff, and half a rung crossed the basin onto it. With both, the
+post places at 0.971 (0.0593, 0.1 px from the old placement), and the grid goes from
+237 to 238 found and 8 to 6 misses (2 gained, 1 lost) for 16% more user CPU. The
+quarter alone found 234, losing the native arms #877 was made for. The one lost is a
+margin reading again: the blurred 32 px front shin (walk) now reports its truth as its
+best (0.07 px, 0.00968), with its old 0.51 px answer 0.0045 above it.
+
+⚠️ **What this is and is not.** The grid is not a reliability line: six native cells
+place 14 or 15 of 15 and the trials at `detail` 3 and over place 65 of 66, but the
+goggles still place 13 of 42, and a threshold read off two dozen parts of one figure
 would be a claim about that figure. What the grid can separate is **whose** failure a
 failure is. `bun tools/pose_floor.ts` prints the residual at the truth for every
 failed trial and marks it **missed** when the truth scores better than everything
 reported and nothing reported is on it — a failure the search could fix. The other
 failures are the objective preferring another placement (a blurred part shrunk into
 its own region scores better than its truth) or the truth reported and tied, and no
-search can fix those. After #877, 8 of the 183 failed trials are misses, and 7 of
+search can fix those. After #886, 6 of the 182 failed trials are misses, and 5 of
 those sit within 3.1 px of the truth rather than on another hill; the `--from`
 listing prints, for each, where the refinement left the truth level by level. All this was
 measured on **ideal cuts**, the frame's own pixels, where a residual at the truth is
@@ -8935,7 +8960,8 @@ print the table, derive the edge and list the misses per cell. `PO22` in
 no miss at all, and `PO23` places the 48 px fist #865 was made for; `PO28` and
 `PO29` place the four trials #877 was made for and read where the shin survived the
 cutoff, and `PO26` holds every polish to strictly descending residuals, read through
-the same trace.
+the same trace. `PO31` places §6's post at the old placement from the page's own
+input bytes, and `PO32` holds it to taking the quarter-rung escape and reading the same twice.
 
 ## 12. Reading the half of that picture `pose` refuses — `rigc chainfit`
 

package/docs/INGEST.md

@@ -370,6 +370,8 @@ rigc check --candidate examples/3-timing-and-spacing/export/3-timing-and-spacing
            --frames ref3/light
 ```
 
+**No run reproduces this:** abridged — the head's `atlas`, `frames`, `skin`, `scope`, `reference`, `content` and `in units` lines and its two ⚠️ notes are cut, so the `⤷ fit` line the run prints under `content` stands under `framed to`; the section's `frames` line and every `⤷` note are cut; and so is everything the run prints after `per-frame`
+
 ```
 rigc check
   candidate  …/examples/3-timing-and-spacing/export/3-timing-and-spacing-ess.json
@@ -378,14 +380,14 @@ rigc check
   declared   frames.json's own box: TAKEN, coincident — a fit there asks for 0.00 px, under the 1 px that separates a candidate in the frames' coordinates from one in its own, over 21 frame(s).
 
   ── light — candidate animation "light", 12 fps ──
-     MAE        mean 0.00  worst 0.00 at f00-1   (0..255 over the union alpha; over the whole frame, mean 0.00)
-     slot drift worst 0.5 px  "pendulum" at f0003
+     MAE        mean 0.00  worst 0.00 (exact: none of the 21 compared frame(s) differs from the reference)   (0..255 over the union alpha; over the whole frame, mean 0.00)
+     slot drift worst 0.4 px  "pendulum" at f0012
      per-frame all 20 adjacent pair(s) change by as much as the reference's own frames do
 ```
 
 Two things to take from the control, both of which you need before reading any real
 number: the **framing** resolved to the frames' own box at 0.00 px, so the MAE is a
-comparison of pictures rather than of framings; and **slot drift still reads 0.5 px at
+comparison of pictures rather than of framings; and **slot drift still reads 0.4 px at
 MAE 0.00**, which is that instrument's own floor rather than a difference.
 
 ⚠️ **`--texture-from` is not optional on ingest work, and the reason is structural.**
@@ -1339,7 +1341,9 @@ against one picture. A foreign export hands you a packed page instead, and point
 `pose` at one is worse than useless — it treats the whole page as a single part and
 answers confidently:
 
-```bash
+```bash setup
+rigc render --candidate examples/3-timing-and-spacing/export/3-timing-and-spacing-ess.json \
+            --fps 4 --max 900 --out ref-big
 mkdir -p packed-only
 cp examples/3-timing-and-spacing/export/3-timing-and-spacing.png packed-only/
 rigc pose --images packed-only --frame 'ref-big/light@4fps/f0002.png'
@@ -1350,12 +1354,12 @@ rigc pose
   ..    frame   …/ref-big/light@4fps/f0002.png  (900x409)
   ..    ground  rgb(232, 232, 232) over 100% of the border ring
   ..    parts   …/packed-only  (1 png)
-  ..    search  scale 0.5–2 in 7 step(s) · rotation -180°–180° step 15° · refuse above residual 0.25
-  PLACE  3-timing-and-spacing.png  x=  324.3  y=  188.2  rot=  -91.4°  scale=0.629  residual=0.2083  unexplained= 30%
-                                   found on a 7x3 anchor grid, step 4 at 32x reduction
+  ..    search  scale 0.5–2 in 7 step(s) · rotation -180°–180° in 24 step(s) of 15° · refuse above residual 0.25
+  PLACE  3-timing-and-spacing.png  x=  324.3  y=  188.3  rot=  -91.6°  scale=0.630  residual=0.2085  unexplained= 30%
+                                   found on a 14x7 anchor grid, step 4 at 16x reduction
 ```
 
-⚠️ **`residual=0.2083` is *under* the default 0.25 refusal bar**, so nothing refused
+⚠️ **`residual=0.2085` is *under* the default 0.25 refusal bar**, so nothing refused
 it, and `PLACE` rather than `AMBIG` means nothing flagged it either. With the same frame
 and the two real loose parts, the answer is what it should be:
 
@@ -1365,12 +1369,15 @@ rigc pose --images examples/3-timing-and-spacing/images \
 ```
 
 ```
+rigc pose
+  ..    frame   …/ref-big/light@4fps/f0002.png  (900x409)
+  ..    ground  rgb(232, 232, 232) over 100% of the border ring
   ..    parts   …/examples/3-timing-and-spacing/images  (2 png)
-  ..    search  scale 0.3–0.6 in 4 step(s) · rotation -180°–180° step 15° · refuse above residual 0.25
-  PLACE  pendulum.png  x=  319.3  y=  214.5  rot=  -88.9°  scale=0.412  residual=0.0425  unexplained=  7%
-                       found on a 12x5 anchor grid, step 5 at 16x reduction
-  PLACE  square.png    x=  437.2  y=  343.1  rot=   -0.1°  scale=0.410  residual=0.0331  unexplained=  4%
-                       found on a 57x26 anchor grid, step 4 at 4x reduction
+  ..    search  scale 0.3–0.6 in 4 step(s) · rotation -180°–180° in 24 step(s) of 15° · refuse above residual 0.25
+  PLACE  pendulum.png  x=  319.3  y=  214.6  rot=  -88.9°  scale=0.411  residual=0.0428  unexplained=  7%
+                       found on a 28x13 anchor grid, step 2 at 16x reduction
+  PLACE  square.png    x=  437.1  y=  343.1  rot=    0.0°  scale=0.410  residual=0.0334  unexplained=  4%
+                       found on a 113x51 anchor grid, step 2 at 4x reduction
 ```
 
 ⇒ **Check what is in `--images` before trusting a `pose` report on ingest work.** One

package/docs/MOTION.md

@@ -767,7 +767,7 @@ late, §3.8's overshoot is live; animation name → **`raise`**.
 
 ### 1. The art, and the two pictures
 
-```bash
+```bash setup
 mkdir -p semaphore/parts && cd semaphore
 bun -e '
 const files = {
@@ -806,15 +806,15 @@ rigc pose
   ..    frame   …/semaphore/poseA.png  (160x200)
   ..    ground  rgb(238, 238, 234) over 100% of the border ring
   ..    parts   …/semaphore/parts  (3 png)
-  ..    search  scale 0.5–2 in 7 step(s) · rotation -180°–180° step 15° · refuse above residual 0.25
-  PLACE  arm.png   x=   91.9  y=  122.8  rot=   61.9°  scale=0.968  residual=0.0320  unexplained=  4%
-                   found on a 10x13 anchor grid, step 4 at 4x reduction
-  PLACE  flag.png  x=  104.7  y=  156.1  rot=   84.3°  scale=0.955  residual=0.0135  unexplained=  0%
+  ..    search  scale 0.5–2 in 7 step(s) · rotation -180°–180° in 24 step(s) of 15° · refuse above residual 0.25
+  PLACE  arm.png   x=   92.0  y=  122.8  rot=   61.9°  scale=0.970  residual=0.0320  unexplained=  4%
                    found on a 20x25 anchor grid, step 4 at 2x reduction
-  AMBIG  post.png  x=   79.0  y=  141.7  rot=   -0.4°  scale=0.690  residual=0.0687  unexplained= 25%
-                   found on a 7x9 anchor grid, step 3 at 8x reduction
-                   alt 2: x=   78.9  y=  140.7  rot=   -0.4°  scale=0.650  residual=0.0692  unexplained= 26%
-                   alt 3: x=   78.4  y=  135.5  rot=   -0.5°  scale=0.500  residual=0.0702  unexplained= 23%
+  PLACE  flag.png  x=  104.7  y=  156.1  rot=   84.3°  scale=0.955  residual=0.0135  unexplained=  0%
+                   found on a 40x50 anchor grid, step 2 at 2x reduction
+  AMBIG  post.png  x=   79.9  y=  149.0  rot=   -0.1°  scale=0.971  residual=0.0593  unexplained= 16%
+                   found on a 14x17 anchor grid, step 6 at 2x reduction
+                   alt 2: x=   79.0  y=  141.7  rot=   -0.5°  scale=0.691  residual=0.0687  unexplained= 25%
+                   ambiguous: part is 14x96 px (span 93.2 frame px, opaque 1) with texture 0.0146, detail 1.406; 43 candidate(s), best 0.0593, next 0.0687, spread 0.0095 — above the measured floor (AUTHORING §11.5: detail 0.5, measured from 24 px up), so size and texture do not explain this; either the frame holds more than one place this part fits, or every candidate missed the true one — a narrower --scale or --rotation window around what you know of the part tells the two apart
 ```
 
 ⚠️ **The post came back at scale 0.690 with two alternates trailing it down to 0.500 —
@@ -830,17 +830,31 @@ rigc pose --images parts --frame poseB.png --scale 0.85,1.2 --out poseB.json
 ```
 
 ```
-  ..    search  scale 0.85–1.2 in 2 step(s) · rotation -180°–180° step 15° · refuse above residual 0.25
-  PLACE  arm.png   x=   91.9  y=  122.8  rot=   61.9°  scale=0.968  residual=0.0320  unexplained=  4%
-  PLACE  flag.png  x=  104.7  y=  156.1  rot=   84.3°  scale=0.955  residual=0.0135  unexplained=  0%
-  PLACE  post.png  x=   79.9  y=  148.6  rot=   -0.1°  scale=0.975  residual=0.0589  unexplained= 16%
+rigc pose
+  ..    frame   …/semaphore/poseA.png  (160x200)
+  ..    ground  rgb(238, 238, 234) over 100% of the border ring
+  ..    parts   …/semaphore/parts  (3 png)
+  ..    search  scale 0.85–1.2 in 2 step(s) · rotation -180°–180° in 24 step(s) of 15° · refuse above residual 0.25
+  PLACE  arm.png   x=   91.9  y=  122.8  rot=   61.9°  scale=0.970  residual=0.0320  unexplained=  4%
+                   found on a 20x25 anchor grid, step 4 at 2x reduction
+  PLACE  flag.png  x=  104.7  y=  156.1  rot=   84.1°  scale=0.956  residual=0.0135  unexplained=  0%
+                   found on a 40x50 anchor grid, step 2 at 2x reduction
+  PLACE  post.png  x=   79.9  y=  148.5  rot=   -0.1°  scale=0.971  residual=0.0593  unexplained= 16%
+                   found on a 14x17 anchor grid, step 6 at 2x reduction
 ```
 
 ```
-  ..    search  scale 0.85–1.2 in 2 step(s) · rotation -180°–180° step 15° · refuse above residual 0.25
-  PLACE  arm.png   x=  102.6  y=   94.8  rot=  -18.2°  scale=0.973  residual=0.0305  unexplained=  4%
-  PLACE  flag.png  x=  137.4  y=   86.0  rot=   -6.6°  scale=0.956  residual=0.0134  unexplained=  1%
+rigc pose
+  ..    frame   …/semaphore/poseB.png  (160x200)
+  ..    ground  rgb(238, 238, 234) over 100% of the border ring
+  ..    parts   …/semaphore/parts  (3 png)
+  ..    search  scale 0.85–1.2 in 2 step(s) · rotation -180°–180° in 24 step(s) of 15° · refuse above residual 0.25
+  PLACE  arm.png   x=  102.5  y=   94.8  rot=  -18.3°  scale=0.974  residual=0.0305  unexplained=  4%
+                   found on a 20x25 anchor grid, step 4 at 2x reduction
+  PLACE  flag.png  x=  137.4  y=   86.0  rot=   -6.6°  scale=0.956  residual=0.0134  unexplained=  0%
+                   found on a 40x50 anchor grid, step 2 at 2x reduction
   PLACE  post.png  x=   80.0  y=  148.0  rot=    0.0°  scale=0.995  residual=0.0394  unexplained=  9%
+                   found on a 14x17 anchor grid, step 6 at 2x reduction
 ```
 
 Three things to read out of that pair, none of which is a score:
@@ -1168,7 +1182,7 @@ skeleton — AUTHORING §10.3 and PROMPTING clause 4 both price it. Keys are str
 The bytes of `poseA.png` and `poseB.png`, so §6 runs end to end. Both are 160×200 on a
 flat ground; both are invented.
 
-```bash
+```bash setup
 bun -e '
 const frames = {
   "poseA.png": "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",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spine-rigc",
-  "version": "1.5.0",
+  "version": "1.5.1",
   "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,7 +38,7 @@ 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 { nearMisses } from './keys.ts';
+import { dottedPath, nearMisses, refuseNumbersTheFileCannotCarry } from './keys.ts';
 import { inEditorKeyOrder, withoutParserDefaults } from './keyorder.ts';
 import { EVERY_GLOBAL_PHYSICS, parseMotionSpec } from './motion.ts';
 import {
@@ -2030,6 +2030,11 @@ function compileInto(opts: CompileOptions, droppedStates: DroppedState[]): Compi
   // and which refusals it deliberately leaves in this file.
   const motion = parseMotionSpec(readJson<unknown>(motionPath), motionPath);
   const manifest = manifestPath === null ? null : readJson<FaceManifest>(manifestPath);
+  // The manifest is the record of what was measured, and its numbers become
+  // bone positions and the stage: a `crop.h` of 1e309 built as `"height": null`
+  // before issue #881. The rig spec's walk is `parseRigSpec`'s; this is the
+  // same rule over the other file whose numbers reach the skeleton.
+  if (manifest !== null && manifestPath !== null) refuseNumbersTheFileCannotCarry(manifest, manifestPath, dottedPath);
 
   // The rig spec names its own path in every message `parseRigSpec` throws (its
   // `where` argument, above). The motion spec gets no such treatment below —

package/src/keys.ts

@@ -115,3 +115,90 @@ export function refuseUnknownKeys(
       (known.length === 0 ? 'This shape has no fields at all.' : `Known here: ${[...known].sort().join(', ')}.`),
   );
 }
+
+/**
+ * The largest float32, `3.4028234663852886e38`. The skeleton file is written at
+ * float32 precision (`f32` in `src/compile.ts` rounds every emitted number), so
+ * this is the largest magnitude a stated number can have and still come out of
+ * the emitter as a number.
+ */
+export const FLOAT32_MAX = 3.4028234663852886e38;
+
+/**
+ * Refuse the first number in an input file that the skeleton file cannot carry
+ * — one that is not finite, or that is finite only as a double (issue #881).
+ *
+ * 🚨 The defect this closes was a green build. `JSON.parse` reads `1e309` as
+ * `Infinity`, the emitter wrote it, and `JSON.stringify(Infinity)` is `null`:
+ * a bone stated at `x: 1e309` built green on the overlay probe as `"x": null`
+ * and was read as 0, a value the spec never stated. `1e308` did exactly the same
+ * — it is a finite double, but every emitted number is rounded to a float32 and
+ * `Math.fround(1e308)` is `Infinity` — so the line is float32's range and not
+ * the double's: `3.4028234663852886e38` built green and was emitted as itself,
+ * the next double up that rounds past it (`3.4028235677973366e38`) was emitted
+ * as `null`. The predicate is therefore `Number.isFinite(Math.fround(n))`,
+ * which is `NaN`, both infinities and exactly that overflow.
+ *
+ * ⭐ It walks the file, not the emitter's route — `checkRigSpecKeys`'s design
+ * and its reason. Before this, a handful of readers in `compile.ts` carried a
+ * finite check of their own (vertex arrays, a path's lengths, a segments
+ * falloff, a slider's mapping, an event's payload), each right about its own
+ * field, and none of them was a rule. Measured when this was written, planting
+ * `1e309` at every numeric leaf of nine rig specs — 610 plants over 57 kinds
+ * of field: 19 kinds were refused by a rule of their own (30 of those 70
+ * refusals printing the Infinity as `null`, and some only by a later symptom
+ * such as *hull Infinity disagrees with the triangles*), 1 was caught only by
+ * the gate, and 37 built green with a `null` in them on at least one rig. One
+ * pass over every number the document holds cannot miss a reader added next
+ * month, and it runs before any of them — so a range rule further down (a
+ * radius that is positive, a weight in 0..1) never has to print `NaN`.
+ *
+ * 🔒 The report order is fixed: `Object.keys` of parsed JSON is the
+ * document's key order (integer-like keys first, as the language orders them)
+ * and arrays are visited by index, so the refusal names the same number on
+ * every run.
+ *
+ * ⚠️ What it cannot see is a number spelled as something else. `"x": "NaN"`
+ * is a string; there is no number here to refuse, and the reader downstream
+ * that coerces it is a type question this walk does not answer.
+ *
+ * `place` turns a path into the words the refusal uses for it.
+ */
+export function refuseNumbersTheFileCannotCarry(
+  raw: unknown,
+  where: string,
+  place: (path: ReadonlyArray<string | number>) => string,
+): void {
+  const visit = (node: unknown, path: Array<string | number>): void => {
+    if (typeof node === 'number') {
+      if (Number.isFinite(Math.fround(node))) return;
+      const why = Number.isNaN(node)
+        ? ''
+        : Number.isFinite(node)
+          ? ' This one is finite as a double and has no float32 but Infinity.'
+          : ' JSON has no spelling for Infinity: a literal past ±1.7976931348623157e308, such as 1e309, parses to it.';
+      throw new CompileError(
+        `${where}: ${place(path)} is ${String(node)}; a number in this file is finite at float32 precision, at most ` +
+          `±${String(FLOAT32_MAX)}, because the skeleton is written as float32 — past that it would be emitted as ` +
+          `Infinity, which JSON writes as null, a value the file never stated.${why}`,
+      );
+    }
+    if (Array.isArray(node)) {
+      node.forEach((child, i) => visit(child, [...path, i]));
+    } else if (node !== null && typeof node === 'object') {
+      const record = node as Record<string, unknown>;
+      for (const key of Object.keys(record)) visit(record[key], [...path, key]);
+    }
+  };
+  visit(raw, []);
+}
+
+/** A path as the file spells it: `.key`, `."odd key"`, `[3]`. */
+export function dottedPath(path: ReadonlyArray<string | number>): string {
+  let out = '';
+  for (const step of path) {
+    if (typeof step === 'number') out += `[${step}]`;
+    else out += /^[A-Za-z_][A-Za-z0-9_]*$/.test(step) ? `${out === '' ? '' : '.'}${step}` : `${out === '' ? '' : '.'}${JSON.stringify(step)}`;
+  }
+  return out;
+}

package/src/motion.ts

@@ -54,7 +54,7 @@
  * [`keys.ts`](keys.ts) shared with the rig parser.
  */
 import { CompileError } from './errors.ts';
-import { refuseUnknownKeys } from './keys.ts';
+import { dottedPath, refuseNumbersTheFileCannotCarry, refuseUnknownKeys } from './keys.ts';
 import { SEQUENCE_MODES } from './timelines.ts';
 import type { MotionSpec } from './types.ts';
 
@@ -665,5 +665,11 @@ export function parseMotionSpec(raw: unknown, where: string): MotionSpec {
     parseAnimation(anim, where, name);
   }
 
+  // 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
+  // cannot carry — a key at 1e308 built green with a `null` in it before issue
+  // #881 — and any number in a field no check above reads.
+  refuseNumbersTheFileCannotCarry(raw, where, (path) => `\`${dottedPath(path)}\``);
+
   return raw as unknown as MotionSpec;
 }

package/src/pose.ts

@@ -274,8 +274,9 @@ const MINIMA_PER_SCALE = 5;
 const REFINE_CANDIDATES = 15;
 
 /**
- * The factor a converged full-resolution polish tries its scale up by before it
- * stops — half a coarse scale rung, the resolution the coarse ladder itself had.
+ * The factors a converged full-resolution polish tries its scale up by before it
+ * stops — half a coarse scale rung, the resolution the coarse ladder itself had,
+ * and a quarter of one (issue #886); the better of the two re-fits wins.
  *
  * 🔍 What the pattern search cannot do, and the trace table of issue #877 is
  * how it was seen: every probe moves ONE degree of freedom, and the objective
@@ -306,8 +307,32 @@ const REFINE_CANDIDATES = 15;
  * margin, and the blurred 24 px front shin (walk) now places AT its truth
  * (0.03 px, 0.00989) where it placed 0.57 px off at 0.0191 — the old answer is
  * still reported beside it, 0.0094 above, inside the 0.01 absolute margin.
+ *
+ * 🔍 The quarter rung is issue #886, and the fixed-scale profile is what
+ * named it. MOTION.md §6's post (14x96, pose A, `--scale 0.85,1.2`) came back
+ * at scale 0.917 and residual 0.0649 where the page had recorded 0.975 at
+ * 0.0589 — the old placement still scores 0.0589 on this objective, so the
+ * search missed it. The trace: the coarse cell nearest the truth (2.4 px off
+ * it, at the 2x level) kept a half-turned post, its polish ended 6.7 px from
+ * the truth, the full-resolution rotation re-grid set it upright there, and
+ * the polish climbed the scale–position valley to 0.917.
+ * The half-rung escape then tried 1.029: best position there 0.0980, worse
+ * than 0.0649, so it declined — while the best position at every scale
+ * between 0.94 and 1.00 scores 0.0619–0.0589. A part whose material fills its
+ * image pays for every pixel pushed past the figure, so its profile above the
+ * truth is a cliff, and half a rung stepped over the basin onto it. A quarter
+ * rung lands at 0.971 (0.0593, 0.1 px off the page's placement).
+ *
+ * 📏 Both, not the quarter alone, and measured on the grid rather than argued:
+ * the quarter alone found 234 (3 gained, 6 lost — the native arms #877 was
+ * made for need the half); half then quarter, the quarter tried only when the
+ * half declines, 237 (1, 1); both, the better kept, 238 (2 gained, 1 lost) and
+ * misses 8 → 6, for 16% more user CPU over the grid. The one it loses is a
+ * margin reading of the kind named above: the blurred 32 px front shin (walk)
+ * now reports its truth as its BEST (0.07 px, 0.00968) with the old 0.51 px
+ * answer 0.0045 above it, inside the 0.01 absolute margin.
  */
-const POLISH_SCALE_ESCAPE = 2 ** (1 / (2 * SCALE_STEPS_PER_OCTAVE));
+const POLISH_SCALE_ESCAPES = [2 ** (1 / (4 * SCALE_STEPS_PER_OCTAVE)), 2 ** (1 / (2 * SCALE_STEPS_PER_OCTAVE))];
 
 /** Sample budgets per stage. The reported residual uses every pixel regardless. */
 const COARSE_SAMPLES = 96;
@@ -347,8 +372,8 @@ export const POSE_FLOOR = {
   span: 24,
   detail: 0.5,
   /** Found share of the grid's trials under `detail`, and over it — both measured by `deriveFloor`. */
-  rateBelow: 0.074,
-  rateAbove: 0.765,
+  rateBelow: 0.066,
+  rateAbove: 0.772,
 };
 
 /** Which side of `POSE_FLOOR` a part is on, from its own longest side in part pixels and its detail. */
@@ -1934,7 +1959,7 @@ function placePart(
     }
     const paths = seeds.map((): { start: number; steps: PoseTraceStep[] } => ({ start: 0, steps: [] }));
     candidates = seeds.map((seed, i) =>
-      polish(level, plate, s, seed, step, floor, smooth, scaleBounds, rotationBounds, li === 0 ? [POLISH_SCALE_ESCAPE] : [], trace === undefined ? undefined : paths[i]),
+      polish(level, plate, s, seed, step, floor, smooth, scaleBounds, rotationBounds, li === 0 ? POLISH_SCALE_ESCAPES : [], trace === undefined ? undefined : paths[i]),
     );
     const polished = candidates.slice();
     candidates.sort((a, b) => a.residual - b.residual);

package/src/render.ts

@@ -1288,6 +1288,38 @@ function firstNonFinite(where: string, entries: readonly PosedVertices[], bones:
   return null;
 }
 
+/**
+ * The same sentence for one skeleton as it stands posed now — its bones, then
+ * the vertices of every region and mesh its slots show, in draw order — or
+ * `null` when every one of those numbers is finite.
+ *
+ * ⭐ This is how `A10_NO_NAN_AFTER_STEPPING` reads each pose it steps (issue
+ * #882), so the gate and the renderer hold one definition of "not finite": the
+ * six terms `firstNonFinite` reads off a bone, and the vertices the runtime
+ * computes from them. Before it A10 read the world POSITION alone, and a bone at
+ * `rotation: 1e309` — finite position, NaN `a`, `b`, `c`, `d` — was gated green
+ * and then refused here. The vertices are read too because a bone can be finite
+ * and still carry one that is not: a two-bone `scaleX` chain of 1e154 × 1e154
+ * leaves the child's `a` at 1e308, finite, and every vertex of its attachment
+ * past the largest double. Only computed once every bone is finite, so a
+ * broken bone is named as the cause rather than through its vertices.
+ */
+export function nonFiniteOfPosed(where: string, skeleton: Skeleton): string | null {
+  const bones: WorldTransform[] = skeleton.bones.map((bone) => {
+    const { a, b, c, d, worldX, worldY } = bone.appliedPose;
+    return { name: bone.data.name, a, b, c, d, worldX, worldY };
+  });
+  const found = firstNonFinite(where, [], bones);
+  if (found !== null) return found;
+  const entries: PosedVertices[] = [];
+  for (const slot of skeleton.drawOrder.appliedPose) {
+    const attachment = slot.appliedPose.attachment;
+    if (!(attachment instanceof MeshAttachment) && !(attachment instanceof RegionAttachment)) continue;
+    entries.push({ slot: slot.data.name, attachment: attachment.name, vertices: worldVerticesOf(skeleton, slot, attachment) });
+  }
+  return firstNonFinite(where, entries, []);
+}
+
 /**
  * How a sampled frame is named in that sentence: the animation, the frame's
  * index at the rate it was sampled and its time — or the bare index for the one

package/src/rig.ts

@@ -60,7 +60,7 @@
  * with no manifest at all declares them here.
  */
 import { CompileError, NotImplementedError } from './errors.ts';
-import { refuseUnknownKeys } from './keys.ts';
+import { dottedPath, refuseNumbersTheFileCannotCarry, refuseUnknownKeys } from './keys.ts';
 
 export { CompileError, NotImplementedError };
 
@@ -1925,6 +1925,10 @@ function checkRigSequence(att: Record<string, unknown>, who: string, where: stri
   const whole = (field: string, min: number): void => {
     const value = seq[field];
     if (value === undefined) return;
+    // A number the file cannot carry is `refuseNumbersTheFileCannotCarry`'s,
+    // one sentence for the whole family. This check runs inside the key scan,
+    // before that walk, and printed a stated 1e309 as `null` (issue #881).
+    if (typeof value === 'number' && !Number.isFinite(Math.fround(value))) return;
     if (typeof value !== 'number' || !Number.isInteger(value) || value < min) {
       throw new CompileError(
         `${where}: ${at}.${field} is ${JSON.stringify(value) ?? String(value)}; it is a whole number` +
@@ -1946,7 +1950,7 @@ function checkRigSequence(att: Record<string, unknown>, who: string, where: stri
   whole('digits', 0);
   whole('setup', 0);
   const count = seq.count as number;
-  if (typeof seq.setup === 'number' && seq.setup >= count) {
+  if (typeof seq.setup === 'number' && Number.isFinite(Math.fround(seq.setup)) && Number.isFinite(Math.fround(count)) && seq.setup >= count) {
     throw new CompileError(
       `${where}: ${at}.setup is ${seq.setup}, and a ${count}-frame series has frames 0 to ${count - 1}. ` +
         '`Sequence.resolveIndex` clamps an index at or past the end to the LAST frame (measured: `setup: 7` on ' +
@@ -2100,6 +2104,42 @@ function checkRigSpecKeys(raw: Record<string, unknown>, where: string): void {
   }
 }
 
+
+/**
+ * A rig-spec path in the words the other refusals in this file use for it:
+ * `bone "hip" x`, `constraint "aim" mixRotate`, `skin "default" slot "tail"
+ * attachment "tail" weights[0][1].x`, `event "step" float`. Anything else is
+ * the dotted path, which names every number exactly.
+ */
+function rigPlace(raw: Record<string, unknown>): (path: ReadonlyArray<string | number>) => string {
+  const named = (list: unknown, i: number, kind: string, plural: string): string => {
+    const node = Array.isArray(list) ? list[i] : undefined;
+    return isObj(node) && typeof node.name === 'string' ? `${kind} ${JSON.stringify(node.name)}` : `${plural}[${i}]`;
+  };
+  const rest = (path: ReadonlyArray<string | number>): string => {
+    const tail = dottedPath(path);
+    return tail === '' ? '' : ` ${tail}`;
+  };
+  return (path) => {
+    const [head, second] = path;
+    if (typeof second === 'number') {
+      if (head === 'bones') return `${named(raw.bones, second, 'bone', 'bones')}${rest(path.slice(2))}`;
+      if (head === 'slots') return `${named(raw.slots, second, 'slot', 'slots')}${rest(path.slice(2))}`;
+      if (head === 'constraints') return `${named(raw.constraints, second, 'constraint', 'constraints')}${rest(path.slice(2))}`;
+    }
+    if (head === 'events' && typeof second === 'string') return `event ${JSON.stringify(second)}${rest(path.slice(2))}`;
+    if (head === 'skins' && typeof second === 'string') {
+      const inner = path[2] === 'attachments' ? path.slice(3) : path.slice(2);
+      const [slot, attachment] = inner;
+      if (typeof slot === 'string' && typeof attachment === 'string') {
+        return `skin ${JSON.stringify(second)} slot ${JSON.stringify(slot)} attachment ${JSON.stringify(attachment)}${rest(inner.slice(2))}`;
+      }
+      return `skin ${JSON.stringify(second)}${rest(path.slice(2))}`;
+    }
+    return dottedPath(path);
+  };
+}
+
 /**
  * Parse and check the envelope, then hand back a typed spec.
  *
@@ -2137,6 +2177,10 @@ export function parseRigSpec(raw: unknown, where: string): RigSpec {
   // throws directly below are the required-key checks, and each of them is the
   // consequence a typo at the root produces.
   checkRigSpecKeys(raw, 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).
+  refuseNumbersTheFileCannotCarry(raw, where, rigPlace(raw));
 
   if (typeof raw.name !== 'string' || raw.name.length === 0) {
     throw new CompileError(`${where}: a rig spec needs a "name" — a motion spec names it to pick this rig`);

package/src/validate.ts

@@ -82,6 +82,7 @@ import {
   type SpineGeneration,
 } from './generation.ts';
 import { colourTypeName, readPngHeader } from './png.ts';
+import { nonFiniteOfPosed } from './render.ts';
 import { BONE_INHERIT_KNOWN } from './rig.ts';
 import {
   CHANNELS_BY_KIND,
@@ -4400,6 +4401,26 @@ export function validate(input: ValidateInput): ValidateReport {
       }
       if (unresolved > 0) return;
 
+      // -- the whole world transform, at the setup pose and every stepped frame
+      //
+      // 🚨 Read through `nonFiniteOfPosed`, the scan `render` refuses on, and
+      // not a second opinion of it (issue #882). This loop read `worldX` and
+      // `worldY` alone until then, and a bone at `rotation: 1e309` — in its setup
+      // pose or as a `rotate` key — poses a finite position over a NaN `a`, `b`,
+      // `c` and `d` whenever it has no child offset from it: measured on every
+      // leaf bone of the three generated probes, 20 of 20 green through the whole
+      // gate, and `render` then refused the same file by the bone. So the gate
+      // said the skeleton was fine and the renderer said it was not, which is two
+      // definitions of one word. The scan reads the six terms of every bone, then
+      // the vertices of every region and mesh shown — because a bone can be
+      // finite over a vertex that is not (a `scaleX` chain whose product stays
+      // under the largest double while every corner of the child's region
+      // passes it) — and names the bone or the vertex, the term and the frame.
+      //
+      // ⚠️ The setup pose is its own surface and is read as such: every frame
+      // 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.
       for (const anim of data.animations) {
         const skeleton = new Skeleton(data);
         const state = new AnimationState(new AnimationStateData(data));
@@ -4407,18 +4428,27 @@ 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);
           state.apply(skeleton);
           skeleton.update(step);
           skeleton.updateWorldTransform(Physics.update);
+          const found = nonFiniteOfPosed(
+            `animation ${JSON.stringify(anim.name)} frame ${i + 1} of ${STEP_FRAMES} (t=${((i + 1) * step).toFixed(4)}s)`,
+            skeleton,
+          );
+          if (found !== null) {
+            fail('A10_NO_NAN_AFTER_STEPPING', found);
+            return;
+          }
           for (const bone of skeleton.bones) {
             const pose = bone.appliedPose;
-            if (!Number.isFinite(pose.worldX) || !Number.isFinite(pose.worldY)) {
-              fail('A10_NO_NAN_AFTER_STEPPING', `${anim.name}: bone "${bone.data.name}" world is (${pose.worldX}, ${pose.worldY})`);
-              return;
-            }
             // 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