spine-rigc 0.33.1 → 0.34.0

package/cli.ts

@@ -86,7 +86,7 @@ import {
   type AtlasRegion,
 } from './src/atlas.ts';
 import { parseJsonWithPosition } from './src/json-position.ts';
-import { KEY_TIME_EPSILON } from './src/timelines.ts';
+import { float32Step } from './src/timelines.ts';
 import { findRung, RUNG_IDS, type RungSkeleton } from './src/ladder.ts';
 import {
   DEFAULT_MAX_RESIDUAL,
@@ -623,8 +623,30 @@ function meshFit(m: CompileResult['meshes'][number]): string {
   // why, in the place the figures stood, and prints no figure.
   if (m.fitWithheld !== undefined) return `  fit not measured: ${m.fitWithheld}. ${PAGE_GRID_UNLOCATED}`;
   if (m.coverage === undefined) return '';
-  const hole = m.holePixels ? `, enclosing ${m.holePixels}px of hole` : '';
-  return `  covers ${(m.coverage * 100).toFixed(2)}% of the art, reaching ${m.overshoot?.toFixed(2) ?? '?'}px past it${hole}`;
+  // A count of the plate's own cells, so on a `scale:` page it is texels and
+  // says so rather than borrowing the overshoot's unit beside it (issue #762).
+  const hole = m.holePixels ? `, enclosing ${m.holePixels}${m.pageScale === undefined ? 'px' : ' texel(s)'} of hole` : '';
+  return `  covers ${(m.coverage * 100).toFixed(2)}% of the art, reaching ${m.overshoot?.toFixed(2) ?? '?'}px past it${meshFitGrid(m)}${hole}`;
+}
+
+/**
+ * The grid a fit was taken on, when it is not the drawing's own (issue #762).
+ *
+ * The overshoot is stated in the drawing's pixels on every route — the unit an
+ * attachment's size is in — and on a page that declares a `scale:` other than
+ * 1 it was measured on the page's texels and divided by that scale. So it
+ * carries the coarser grid's step: on `scale: 0.5` a figure moves in steps of
+ * 2.00px of the drawing, and it need not equal the figure the page it was
+ * packed from reads except where the distance falls on whole texels. Said
+ * beside the figure, and nothing at all on a loose part or a page at scale 1,
+ * where the line is the one it always was.
+ */
+function meshFitGrid(m: CompileResult['meshes'][number]): string {
+  if (m.pageScale === undefined) return '';
+  return (
+    ` (the drawing's pixels, measured on the page's texels at scale: ${m.pageScale} — a texel is ` +
+    `${(1 / m.pageScale).toFixed(2)}px of the drawing)`
+  );
 }
 
 /**
@@ -739,12 +761,14 @@ function deformKeyName(key: DeformKeyMeasure): string {
  * The report's is the spec's own `t`; the survey's came back through
  * `Float32Array`, because that is what `spine-core` reads a timeline's frames
  * into — a key written `0.62` arrives as `0.6200000047683716`. So the tolerance
- * is the compiler's own key-time grid plus one float32 ulp at this magnitude,
- * which is narrower than any key spacing the format can hold and wide enough for
- * both roundings.
+ * is one float32 step at this magnitude (`float32Step`): the compiler emits a
+ * key time as a float's name — the spec's own time when it names one, the float
+ * below it when it does not (issue #716) — so the loaded float is within one
+ * step of the spec's `t` either way, which is narrower than any key spacing the
+ * format can hold.
  */
 function sameKeyTime(specTime: number, loaded: number): boolean {
-  return Math.abs(specTime - loaded) <= KEY_TIME_EPSILON + Math.abs(loaded) * 2 ** -23;
+  return Math.abs(specTime - loaded) <= float32Step(loaded);
 }
 
 /**

package/docs/AUTHORING.md

@@ -324,6 +324,14 @@ texel count beside it so both numbers are visible:
 measures the PNG. Reach for `--atlas-in` when the pack is what you were handed, or
 when drawing through the pack's own texels is the point.
 
+📐 **What you make beside the art stays at the art's size**
+([#762](https://github.com/firejune/rigc/issues/762)). A depth sheet or a soft
+mask is read in the drawing's pixels on a `scale:` page as on loose parts — each
+vertex's texel position over the stated scale — and a mesh fit's overshoot is
+printed in them, with the texel it was measured on named beside it. What stays
+in texels is what is taken off them: a `contour`'s trace, whose `margin` and
+`tolerance` are applied on the texels there are (below).
+
 🚨 **A page that declares a size it does not have is a different thing, and it is
 refused** ([#715](https://github.com/firejune/rigc/issues/715)). The common shape
 is a pack whose `4096x4096` pages ship as `2048x2048` PNGs with the atlas
@@ -387,11 +395,34 @@ that cannot be withheld, because its outline *is* its geometry: it is refused as
 compile error carrying `A06`'s whole sentence — ratio and repair — on `explain`
 and on `build` alike, where on `build` it arrives before the gate would have said
 it. Carry out the repair and every figure comes back. ⚠️ They come back measured
-on the **coarser** texels the page really has, so they need not equal the figures
-of the pack the page was halved from: on the same fixture the `scale: 0.5`
-restatement reads the authored mesh at 100.00% coverage reaching **8.00px** past
-it (the overshoot is counted in the page's own texels), and traces the contour as
-11 vertices where the full-resolution page traced 15.
+on the **coarser** texels the page really has, so a figure that depends on the
+grid need not equal the one the pack the page was halved from reads: on the same
+fixture the `scale: 0.5` restatement traces the contour as 11 vertices where the
+full-resolution page traced 15, because a trace runs on the texels there are and
+its `margin` and `tolerance` are applied on them.
+
+📐 **A fit's overshoot is stated in the drawing's pixels on every page**
+([#762](https://github.com/firejune/rigc/issues/762)). It is a distance, and on a
+page that declares a `scale:` it is taken on the page's texels — so it used to be
+printed in them, under the same `px`: one mesh over one drawing read 16.00px on
+the declared-size page, **8.00px** on its `scale: 0.5` restatement and **32.00px**
+on a `scale: 2` one. It is now the texel distance over the scale the atlas states,
+which is the unit an attachment's `width` is in and the one you drew in, and the
+line says which grid it was taken on — a texel of a `scale: 0.5` page is 2.00px of
+the drawing, so that is the step the figure moves in:
+
+```bash
+#   fan          authored 9 vertices / 8 triangles  (budget 200)  bones=[fan]  covers 100.00% of the art, reaching 16.00px
+#         past it (the drawing's pixels, measured on the page's texels at scale: 0.5 — a texel is 2.00px of the drawing)
+```
+
+All three pages read the fan at 16.00px, because its rim lands on whole texels of
+each. A figure that does not is exact only to that step — the contour above reads
+6.00px on the `scale: 0.5` page (3.00 texels) against the full page's 3.16px, a
+different outline measured on a coarser grid, and the line's clause is what says
+so. On a loose part and a page at scale 1 the texels are the drawing, and the line
+is the one it always was. A `contour`'s hole count is a count of those cells and
+says `texel(s)` on such a page.
 
 🚨 **A page that is not a PNG is refused by name, before anything is compiled
 against it** ([#732](https://github.com/firejune/rigc/issues/732)). rigc reads PNG
@@ -707,7 +738,10 @@ bun cli.ts pose     --images path/to/parts --frame poseA.png [--out pose.json]
   count of vertices on undrawn texels — are replaced by `fit not measured: …` and
   `… is not measured: …` naming the page and the ratio. A `contour` on such a page
   is refused, since its outline is read off those texels. Why, the quoted lines,
-  and the repair: §0.2.
+  and the repair: §0.2. On a page that **does** declare a `scale:`, the overshoot
+  in that line is the drawing's pixels and the line names the texel it was taken
+  on (`… measured on the page's texels at scale: 0.5 — a texel is 2.00px of the
+  drawing`, [#762](https://github.com/firejune/rigc/issues/762)).
 - **`diff`** compares two skeletons and reports **a ratio per measure** in six
   sections (bones, slots, attachments, constraints, animations, events). It
   deliberately does not combine them into a score: a rig with the right skeleton
@@ -922,7 +956,7 @@ one frame (1/60 s) is a compile error, and assertion `A09` re-checks it against
 That frame of slack is for a duration declared *longer* than the motion — an
 animation may hold its final pose. In the other direction there is no slack to give:
 **no key may land past the declared duration**, and this is checked per timeline
-rather than per animation, within 1e-6 s. Both halves matter, and the second is not
+rather than per animation, within one float32 step of the duration. Both halves matter, and the second is not
 the first with a smaller number — see §4.5.
 
 **R8 — `from` needs a cut manifest.** `from.anchor` / `from.slotWindow` /
@@ -1092,7 +1126,7 @@ number where the box would be:
 | --- | --- | --- |
 | `build` | emits `x`/`y`/`width`/`height` | emits none of them |
 | `A14_NO_FULL_FRAME_MESH` | fails a mesh as big as the stage | **SKIP**, by name |
-| `A19_OVERLAY_PNGS_HAVE_ALPHA` | exempts the one image that covers the stage | exempts nothing, and says so |
+| `A19_OVERLAY_PNGS_HAVE_ALPHA` | exempts the base plate a cut manifest names — the part whose window is the crop — and, on a build that names none, the one image that covers the stage | a manifest build exempts the plate it names, exactly as with one ([#770](https://github.com/firejune/rigc/issues/770)). A rig-spec build names no base plate, so an opaque part is refused with *"this skeleton declares no stage size to measure one against, and the build names no base plate"* and the two ways to decide it: a `skeleton` stage the plate covers, or *"build from a cut manifest, whose base plate is the part whose window is the crop"* |
 | `diff` | `stage_present` and `stage_box` | `stage_present` 1/1 when neither side declares one (agreement), `stage_box` 0/0 |
 | `explain` | `stage  W x H` | `stage  none declared` |
 | `render` | frames the posed extent of every animation | the same frames, plus a line saying the viewport is the posed extent and no stage |
@@ -1869,7 +1903,7 @@ off a greyscale sheet in the part's own pixel grid:
 
 | Field | Meaning |
 | --- | --- |
-| `image` | **required.** The sheet, relative to the rig's `images` directory, and the **same pixel size as this attachment's `image`**. It is not packed into the atlas — it is a measurement rigc reads at compile time, not art anything draws |
+| `image` | **required.** The sheet, relative to the rig's `images` directory, and the **same pixel size as this attachment's `image`**. It is not packed into the atlas — it is a measurement rigc reads at compile time, not art anything draws. Under `--atlas-in` that is still the drawing's size, on a page that declares a `scale:` too: the sheet is read at each vertex's texel position over the scale the atlas states, so one sheet serves the loose parts and every pack of them ([#762](https://github.com/firejune/rigc/issues/762)) |
 | `near` | **required.** `"white"` or `"black"` — which end of the range is closest to the viewer. Stated rather than defaulted: both conventions are in use, and a sheet read with the wrong one turns the part inside out with every gate still green |
 | `zScale` | **required.** How many world units the map's full range spans, in the attachment's own units — the number `radius` used to carry. 8 bits of level say nothing about scale, so this is authored, never measured |
 | `gamma`, `contrast`, `bias` | the tone curve applied to the nearness, defaults `1` / `1` / `0`. State them when a consumer's own renderer curves the same sheet, so the mesh and that renderer describe one surface |
@@ -1936,7 +1970,7 @@ bun cli.ts build --rig gallery/look/rig.json \
           1st pct     yaw +19.32° x1.000 of 80 / -19.32° x1.000 of 80   pitch +22.92° x1.000 of 102 / -26.94° x1.000 of 130
                       first to fold: yaw + at 19.32°, triangle 174 [119,138,139], the sheet steps 28.50 level(s) across it, which is 0.112 of the range this mesh sampled
   MESH  hair_lock_l  grid     39 vertices / 48 triangles  (budget 320)  bones=[lock_l]  attachments=[hair_lock_l]
-        depth "lock_l_depth.png" 0c4eaeb36b7c5cac near=white zScale=64 z=[22.086275, 63.874511]
+        depth "lock_l_depth.png" 0c4eaeb36b7c5cac near=white zScale=64 z=[22.086275, 63.87451]
         32 of 39 vertices sample a texel the part image does not draw — their z is the sheet's reading of somewhere the part is not
         turn ceiling  yaw +17.04° / -45.80°   pitch +none / -none
           1st pct     yaw +unranked of 12 / -unranked of 36   pitch +none / -none
@@ -2034,6 +2068,8 @@ refuses it instead:
 | a sheet cut to the art's alpha, on a **contour** | `does not cover 12 of the mesh's 12 vertices … A contour mesh puts every vertex ON the silhouette and pushes it out by the margin … Dilate the sheet past the mesh margin, or lower the margin.` |
 | a sheet cut to the art's alpha, on a **grid** | `does not cover 36 of the mesh's 81 vertices … A grid spans the whole part window, corners included … Dilate the sheet to the window, or state "us"/"vs" that keep the lattice inside the art.` — the two topologies run out of sheet for different reasons, and the message says which |
 | a sheet that is not the part's size | `the depth map … is 32x32 and the part is 64x64. A depth map is sampled in the part's own pixel grid` |
+| a sheet at the page's texel size, on a page that declares a `scale:` | `the depth map "lattice_texels.png" is 48x32 and the part is a 96x64 drawing — 48x32 texels on a page that declares scale: 0.5, which makes a texel 2px of the drawing. … so the sheet is 96x64, the size of the loose art, whatever the page holds.` — the part's own pixel grid is the drawing's on every route, and the message names the ratio and all three sizes, because the drawing's is in neither file |
+| a sheet cut to the art, on a `scale:` page | the coverage refusal above, with the vertex's position in the page's texels **and** `pixel (x, y) of the drawing-sized sheet` — the pixel of the file you made |
 | a colour sheet | `the depth map … is not greyscale — pixel (0, 0) is rgb(10, 200, 10)` |
 | `zScale` at or below 0 | `it is how many units the map's full range spans, so a positive number. To put the near end at the back, say "near": "black"` |
 | `gamma` or `contrast` at or below 0 | `collapses the range onto the midpoint … so the map would describe a flat part` |
@@ -2101,7 +2137,7 @@ hanging sleeve.
 | Field | Meaning |
 | --- | --- |
 | `bone` | **required.** The bone the region is carried by. It has to already exist — a bone a physics constraint targets is part of the skeleton, not a side effect of a mesh |
-| `mask` | **required.** A greyscale sheet in the part's own pixel grid: the level IS the weight, black still and white fully carried, sampled at each vertex. Alpha is not read — a transparent pixel is black |
+| `mask` | **required.** A greyscale sheet in the part's own pixel grid: the level IS the weight, black still and white fully carried, sampled at each vertex. Alpha is not read — a transparent pixel is black. The grid is the drawing's, as for a depth map: on a `scale:` page the mask is still the art's size ([#762](https://github.com/firejune/rigc/issues/762)) |
 
 The remainder always stays on the slot bone, so every vertex closes at 1 by
 construction rather than by `A20` catching it later. `build` and `explain` report
@@ -2131,7 +2167,7 @@ bone, must close at 1, and at least one must actually be carried.
 | the slot's own bone | `moves nothing — a soft region needs a bone that can move independently` |
 | a mask that is black everywhere | `carries no vertex of this mesh — every one of its 49 vertices samples black` |
 | a colour mask | `is not greyscale — pixel (0, 0) is rgb(10, 200, 10)` |
-| a mask that is not the part's size | `is 48x32 and the part is 96x64` |
+| a mask that is not the part's size | `is 48x32 and the part is 96x64` — on a `scale:` page, `and the part is a 96x64 drawing — 48x32 texels on a page that declares scale: 0.5` |
 | a mask that is not on disk | `the soft mask "x.png" is not at …` |
 
 ⭐ **One depth pass buys both, on one part.** A carried mesh has two bones on the
@@ -2987,10 +3023,11 @@ the mapping above and drives the bone to the value it names, rather than playing
 the animation on a track while the slider sits at its neutral. §4.11.4 is what
 that changes and why it matters at `mix: 1`.
 
-🔸 **`scale` is rounded to six decimals on emit**, like every other number rigc
-writes, so `1/60` ships as `0.016667` — 2e-5 relative. Invisible in the middle of
-the range; it shows at the top of it, where a 60° turn then applies at 1.00002 s
-rather than 1 s. With `loop: false` that is the last frame and harmless, with
+🔸 **`scale` is emitted as its float32**, like every other number rigc writes, so
+`1/60` ships as `0.016666668` — 8e-8 relative (it was `0.016667`, 2e-5, on the
+six-decimal grid before issue #716). Invisible in the middle of the range; it
+shows at the top of it, where a 60° turn then applies at 1.00000008 s rather than
+1 s. With `loop: false` that is the last frame and harmless, with
 `loop: true` it wraps to the start. When the range comes from a *measured* ceiling
 — the turn ceiling `build` reports for a depth mesh (§3.4, `depth`) is the natural
 one — pick `to`/`scale` so the endpoint lands **inside** the duration rather than
@@ -3561,26 +3598,33 @@ consumer's, decided by dressing the skeleton rather than by the animation.
   Seconds, not frames: nothing requires a key to land on any frame grid, and a
   reference rendered at some rate says nothing about where its keys are. Put keys
   where the motion changes.
-- **Key times are quantised onto a 1e-6 s grid by rounding DOWN, never to
-  nearest.** A key time is a position against the sample grid a player will step,
+- **Key times are emitted as float32s like every other number, and never stored
+  LATER than you wrote them.** Every emitted number is the shortest decimal naming
+  its float32 — the text the editor writes, and the precision the runtime keeps,
+  because `spine-core` reads a timeline's frames into a `Float32Array` (issue #716).
+  A time that already names a float — `0.5`, `0.2`, the editor's `1.4333333` — is
+  written as you wrote it. A time that does not — `2/12` computed in doubles, a key
+  moved by `lag` or `stagger` — steps to the **largest float not above it**, never
+  to nearest. A key time is a position against the sample grid a player will step,
   and the two directions of a half-step error are not the same size. `2/12 s` and
-  `5/30 s` are both 0.16666666…; `0.166667` is *larger* than either, so a key
-  emitted there is applied at sample **3** of a 12 fps playback and not sample 2 —
-  a whole frame late, with nothing raised. On a **stepped** timeline (an attachment
-  timeline always is) that is the wrong picture rather than a slightly wrong value:
-  the spineboy run's muzzle flare fired a frame late for exactly this until the
-  run's own frame check caught it (issue #99). Rounding down cannot do that; the
-  worst it can do is put a key a millionth of a second early, on the sample it was
-  written for. ⚠️ What this does **not** protect you from is rounding your own
-  times before you write them — write `2/12`, not `0.1667`, and let the compiler
+  `5/30 s` are both 0.16666666…, and the nearest float to that, 0.1666666716…, is
+  *larger* than either, so a key stored there is applied at sample **3** of a 12 fps
+  playback and not sample 2 — a whole frame late, with nothing raised. On a
+  **stepped** timeline (an attachment timeline always is) that is the wrong picture
+  rather than a slightly wrong value: the spineboy run's muzzle flare fired a frame
+  late for exactly this, on the six-decimal grid rigc emitted until #716, until the
+  run's own frame check caught it (issue #99). Stepping down cannot do that; the
+  worst it can do is store a key one float early — 1.5e-8 s at 1/6 s — on the sample
+  it was written for. ⚠️ What this does **not** protect you from is rounding your
+  own times before you write them — write `2/12`, not `0.1667`, and let the compiler
   do the quantising.
-- 🚨 **Nor does it protect a stepped key whose time is ALREADY on the 1e-6 grid.**
-  Rounding down leaves such a time exactly where you wrote it, and the sampler does
-  not arrive there: a player — and `sampleAnimation`, and therefore `check` — reaches
-  sample *i* by accumulating `1/fps` *i* times, which for many *i* lands a few ULPs
-  **below** `i/fps`. `2/12` is saved by the rule above precisely because it is *not*
-  on the grid; `0.25`, `0.5`, `0.75`, `1` and every other multiple of `0.25 s` is, and
-  a stepped key there sits above the sample that was meant to see it. On an
+- 🚨 **Nor does it protect a stepped key whose time ALREADY names a float.**
+  Such a time is written exactly as you wrote it, and the sampler does not arrive
+  there: a player — and `sampleAnimation`, and therefore `check` — reaches sample *i*
+  by accumulating `1/fps` *i* times, which for many *i* lands a few ULPs **below**
+  `i/fps`. `2/12` is saved by the rule above precisely because it is *not* a float;
+  `0.25`, `0.5`, `0.75`, `1` and every other multiple of `0.25 s` is one exactly,
+  and a stepped key there sits above the sample that was meant to see it. On an
   interpolated timeline that costs a few ULPs of value and nothing else. On a
   **stepped** one it is the whole frame — and on the last sample it is the whole
   event, because there is no later sample to catch it. Measured on rung 5's 6.5 s
@@ -3590,16 +3634,22 @@ consumer's, decided by dressing the skeleton rather than by the animation.
   `6.499999999999994` — which read as a frame-change disagreement the pose series had
   already fixed, and cost that run three builds
   ([`2026-08-26-rung5-1`](https://github.com/firejune/rigc/blob/main/bench/runs/2026-08-26-rung5-1/LOOP.md), §8). ⇒ **For a
-  stepped timeline, write `T − 1e-6` rather than `T`.** One grid step early cannot
-  reach the previous sample — 83,333 µs away at 12 fps — and is always seen by the
-  sample it was written for; one ULP late loses the frame. This is the same asymmetry
-  the rule above turns on, one grid step further in.
+  stepped timeline, write a time a little below `T` — `T − 1e-6` still works, at
+  any magnitude — rather than `T`.** What makes it work is not the size of the step:
+  any time below `T` is stored on a float below `T`, because a time that names a
+  float is stored at that float and one that does not steps down, and the float
+  below `T` is below the accumulated sample too (one float step is 3.0e-8 s at
+  0.5 s and 4.8e-7 s at 6.5 s, against the few-ULP shortfall of the sampler). What
+  bounds it from the other side is the frame: `T − 1e-6` cannot reach the previous
+  sample, 83,333 µs away at 12 fps. One ULP late loses the frame. This is the same
+  asymmetry the rule above turns on, one float further in.
 - **No key may land past the animation's `duration`.** Nothing that plays the
   animation for the duration it declares ever reaches such a key, so it is a
   compile error — checked on **every timeline**, not just on the latest key in the
-  animation. The tolerance is 1e-6 s, which is one step of the grid rigc rounds key
-  times onto, so a key you put exactly *on* a duration that is not a round number
-  of microseconds is fine. R7's frame of slack does not apply in this direction and
+  animation, against the float the key is stored at. The tolerance is one float32
+  step at the duration — 4.8e-7 s at 5 s, 3.8e-6 s at 32 s — which is the most a
+  key you put exactly *on* a duration the float cannot hold is stored past it, so
+  such a key is fine. R7's frame of slack does not apply in this direction and
   would not see this: rung 6 rounded its key times to 4 dp somewhere upstream, its
   one-frame reveal landed 0.000034 s past a 68/12 s duration, another track was
   already sitting on the declared duration so the animation's *longest* key time
@@ -3787,7 +3837,7 @@ group members  (the per-member values of one track, side by side — issue #295)
             t = 0.20944 rad
             cos t − 1 = -0.021852
             sin t = 0.207912
-            shift the parent carries = −carried·sin t = -35.344987
+            shift the parent carries = −carried·sin t = -35.344986
             eye_l       5.513083  <- -62 at depth 150
             eye_r       2.803385  <-  62 at depth 150
             brow_l      3.849789  <- -62 at depth 158
@@ -4443,15 +4493,15 @@ bun cli.ts explain --rig gallery/portrait/rig.json \
                  t = 0.20944 rad
                  cos t − 1 = -0.021852
                  sin t = 0.207912
-                 centre shift = −radius·sin t = -35.344987
-               25 vertices, largest offset 35.344987px at vertex 2
-                 v  0 (-7.17493, 0)  v  1 (-22.413595, 0)  v  2 (-35.344987, 0)  v  3 (-27.658171, 0)
+                 centre shift = −radius·sin t = -35.344986
+               25 vertices, largest offset 35.344986px at vertex 2
+                 v  0 (-7.17493, 0)  v  1 (-22.413595, 0)  v  2 (-35.344986, 0)  v  3 (-27.65817, 0)
                  v  4 (-14.255108, 0)  v  5 (-14.255108, 0)  v  6 (-14.255108, 0)  v  7 (-14.255108, 0)
-                 v  8 (-14.255108, 0)  v  9 (-27.658171, 0)  v 10 (-35.344987, 0)  v 11 (-22.413595, 0)
+                 v  8 (-14.255108, 0)  v  9 (-27.65817, 0)  v 10 (-35.344986, 0)  v 11 (-22.413595, 0)
                  v 12 (-7.17493, 0)  v 13 (-7.17493, 0)  v 14 (-7.17493, 0)  v 15 (-7.17493, 0)
-                 v 16 (-22.413595, 0)  v 17 (-35.344987, 0)  v 18 (-27.658171, 0)  v 19 (-22.413595, 0)
-                 v 20 (-35.344987, 0)  v 21 (-27.658171, 0)  v 22 (-22.413595, 0)  v 23 (-35.344987, 0)
-                 v 24 (-27.658171, 0)
+                 v 16 (-22.413595, 0)  v 17 (-35.344986, 0)  v 18 (-27.65817, 0)  v 19 (-22.413595, 0)
+                 v 20 (-35.344986, 0)  v 21 (-27.65817, 0)  v 22 (-22.413595, 0)  v 23 (-35.344986, 0)
+                 v 24 (-27.65817, 0)
 ```
 
 The curve reads `stepped` where the spec says `"ease": "swell"`, and that is
@@ -4459,12 +4509,17 @@ The curve reads `stepped` where the spec says `"ease": "swell"`, and that is
 offsets, so the segment between them would draw nothing and is written the way
 the editor writes it.
 
-📌 **Float behaviour, stated.** The closed forms are evaluated in float64 and
-quantised to six decimals like every other emitted number, so the same spec emits
-the same bytes and `A18_DETERMINISTIC_EMIT` proves it on a second compile. The
-runtime then loads those decimals into a `Float32Array`, which is equally true of
-a hand-written table — the difference the generator makes is that the decimals
-now agree with a stated model instead of with a transcription.
+📌 **Float behaviour, stated.** The closed forms are evaluated in float64,
+quantised onto the model's own 1e-6 grid and emitted as that value's float32 name
+like every other number, so the same spec emits the same bytes and
+`A18_DETERMINISTIC_EMIT` proves it on a second compile. The grid is absolute on
+purpose: a model's identities — a wave sampled on its zero crossings, a whole
+revolution — are exact zeros float64 misses by ~1e-16, and the refusal of a key
+that states a deformation and evaluates to nothing is decided on it (issue #350);
+a float32 alone is relative and has no zero to land on. The runtime then loads
+the numbers into a `Float32Array`, which is equally true of a hand-written table —
+the difference the generator makes is that the numbers now agree with a stated
+model instead of with a transcription.
 
 🔭 **Both adjacent asks have since landed.**
 [#295](https://github.com/firejune/rigc/issues/295) was the same complaint about
@@ -5444,7 +5499,7 @@ Fix A00 and run it again ([#568](https://github.com/firejune/rigc/issues/568)).
 | `A16_SKELETON_VERSION_4_3` | both | the `skeleton.spine` label is not on the 4.3 line (`4.3`, `4.3.N`, `4.3.N-suffix`) |
 | `A17_ATLAS_PAGE_FILES_EXIST` | both | a page the atlas declares is not a file. Check `--images` and `--out`. **SKIP** when the atlas declares no page ([#580](https://github.com/firejune/rigc/issues/580)) — as it is for `A06`, `A19` and `A27`; see `A07` ([#608](https://github.com/firejune/rigc/issues/608)) |
 | `A18_DETERMINISTIC_EMIT` | both | a second compile of the same inputs differed. That is a compiler bug, not a spec bug — report it |
-| `A19_OVERLAY_PNGS_HAVE_ALPHA` | renderer | an overlay part image can never be transparent: no alpha channel (colour type 4 or 6) and no `tRNS` chunk either, so it would paint a solid rectangle over what is behind it. Re-export it as RGBA, or as an indexed / greyscale PNG that keeps its `tRNS`. Only the full-stage base plate may be opaque. Indexed-with-`tRNS` — the usual output of ImageMagick, "Export as PNG-8", GIMP's indexed mode, aseprite and pngquant — **passes**: it is transparent art. On a **shared** page the question is asked per REGION over the decoded page rather than per file, because a packed page's own file all but always declares transparency — its gutter is transparent — and the file-level question would then be answered by the packing rather than by the art ([#266](https://github.com/firejune/rigc/issues/266)). ⚠️ **That scan states its verdict over the texels it READ, and never over texels that are not on the page** ([#705](https://github.com/firejune/rigc/issues/705)): a rectangle partly on its page is judged over the part that is on it, and the message carries both counts — `opaque in every one of the 77 texels of its 12x8 rectangle at -1,-1 … the other 19 of the 96 it declares are not on the page and are not measured here`. A rectangle with **no** texel on the page is reported **not measured** by name — the region, its rectangle, the page image's size, and the pointer to `A06`, which is the rule that judges a region's rectangle — and no verdict about opacity is printed at all. ⚠️ **A page whose IMAGE is not the size the atlas declares for it is the same non-measurement for every region on it** ([#715](https://github.com/firejune/rigc/issues/715)), and #705's clause does not cover that case: a page rescaled after packing leaves most rectangles partly on it, at coordinates that address a different part of the picture, so the scan came back with a confident verdict over texels nobody had located — on a two-region pack at a uniform 0.5 an opaque part's failure **disappeared**, the scan having found a transparent texel 32 texels away from it. The row names the page's two sizes and points at `A06`, which judges the page grid and prints the header that repairs it (§0.2). It stays a failure rather than becoming a SKIP because a SKIP is per ASSERTION: it would delete the verdicts on every other part of the same page, and an assertion cannot be skipped and failed at once without the report counting it twice. Before #705 the walk was silent about its own reach, so a part nobody could read printed *opaque in every one of its 12x8 texels* over zero of them, which is a refusal pointing at the wrong file: the art it names may be transparent, and the repair is the rectangle in `A06`'s row above. ⚠️ **A page file that cannot be read as PNG at all is the same non-measurement for every part on it** ([#732](https://github.com/firejune/rigc/issues/732)): one row per page naming its parts and pointing at `A06`, which names what the file is — where it used to print `threw: cannot decode PNG …: unexpected end of file`, an inflate error about a file that was never a PNG. **SKIP** when the atlas declares no page ([#580](https://github.com/firejune/rigc/issues/580)) |
+| `A19_OVERLAY_PNGS_HAVE_ALPHA` | renderer | an overlay part image can never be transparent: no alpha channel (colour type 4 or 6) and no `tRNS` chunk either, so it would paint a solid rectangle over what is behind it. Re-export it as RGBA, or as an indexed / greyscale PNG that keeps its `tRNS`. Only the base plate may be opaque, and which image that is is decided once for both routes ([#770](https://github.com/firejune/rigc/issues/770)): the plate the build names — on a cut manifest, the part whose window is the crop — and, only when it names none, an image at least the stage's size. The rig's statement comes first because the two can disagree: a stage stated small enough for an overlay to cover would otherwise exempt that overlay. A rig spec cannot name a base plate, so a stageless rig-spec build, and `validate <dir>` on a stageless skeleton, has nothing to decide it; an opaque part there is refused with *"nothing here decides which image that is: this skeleton declares no stage size to measure one against"* and the two ways to decide it — a `skeleton` stage the plate covers, or a cut manifest (for `validate`, the specs it was built from: `--rig`, `--motion` and the `--manifest`). Indexed-with-`tRNS` — the usual output of ImageMagick, "Export as PNG-8", GIMP's indexed mode, aseprite and pngquant — **passes**: it is transparent art. On a **shared** page the question is asked per REGION over the decoded page rather than per file, because a packed page's own file all but always declares transparency — its gutter is transparent — and the file-level question would then be answered by the packing rather than by the art ([#266](https://github.com/firejune/rigc/issues/266)). ⚠️ **That scan states its verdict over the texels it READ, and never over texels that are not on the page** ([#705](https://github.com/firejune/rigc/issues/705)): a rectangle partly on its page is judged over the part that is on it, and the message carries both counts — `opaque in every one of the 77 texels of its 12x8 rectangle at -1,-1 … the other 19 of the 96 it declares are not on the page and are not measured here`. A rectangle with **no** texel on the page is reported **not measured** by name — the region, its rectangle, the page image's size, and the pointer to `A06`, which is the rule that judges a region's rectangle — and no verdict about opacity is printed at all. ⚠️ **A page whose IMAGE is not the size the atlas declares for it is the same non-measurement for every region on it** ([#715](https://github.com/firejune/rigc/issues/715)), and #705's clause does not cover that case: a page rescaled after packing leaves most rectangles partly on it, at coordinates that address a different part of the picture, so the scan came back with a confident verdict over texels nobody had located — on a two-region pack at a uniform 0.5 an opaque part's failure **disappeared**, the scan having found a transparent texel 32 texels away from it. The row names the page's two sizes and points at `A06`, which judges the page grid and prints the header that repairs it (§0.2). It stays a failure rather than becoming a SKIP because a SKIP is per ASSERTION: it would delete the verdicts on every other part of the same page, and an assertion cannot be skipped and failed at once without the report counting it twice. Before #705 the walk was silent about its own reach, so a part nobody could read printed *opaque in every one of its 12x8 texels* over zero of them, which is a refusal pointing at the wrong file: the art it names may be transparent, and the repair is the rectangle in `A06`'s row above. ⚠️ **A page file that cannot be read as PNG at all is the same non-measurement for every part on it** ([#732](https://github.com/firejune/rigc/issues/732)): one row per page naming its parts and pointing at `A06`, which names what the file is — where it used to print `threw: cannot decode PNG …: unexpected end of file`, an inflate error about a file that was never a PNG. **SKIP** when the atlas declares no page ([#580](https://github.com/firejune/rigc/issues/580)) |
 | `A20_MESH_WEIGHTS_COHERENT` | both ◑ | a weighted vertex with no bone, a negative weight, a bone index out of range, or weights that do not sum to 1. Under `spine-html` also: an unweighted mesh, a binding at weight 0, or **a bone the mesh declares that no vertex binds** — `mesh "x" declares bone "grip_b" and none of its 25 vertices binds it; the weights reference "box", "grip_a"`. Those three are one sentence about rigc's own generators: the bone set a generated mesh declares is the bone set its weights reference, so a `controls` or `chain` name that moves nothing is a defect where a foreign mesh's is not ([#684](https://github.com/firejune/rigc/issues/684)). Fix the rig spec's `controls`/`chain`, or the manifest's `control_bones`. **SKIP** when the skeleton carries no mesh attachment ([#580](https://github.com/firejune/rigc/issues/580)) |
 | `A21_MESH_RIM_PINNED` | archetype | a generated ring's rim, a ribbon's entry row, or a contour's outline (which is all of it) is not pinned to its anchor bone at weight 1 |
 | `A22_MESH_UVS_IN_UNIT_RANGE` | both | a mesh UV outside its region, or a UV array that disagrees with the vertex count. **SKIP** when the skeleton carries no mesh attachment ([#580](https://github.com/firejune/rigc/issues/580)) |
@@ -7844,11 +7899,14 @@ under 4.3.26 (`[152.7006, 305.4012, 458.1019, 610.8025]`) and on an open one und
 ⚠️ **That last reading settles the model and cannot settle the spelling.** A
 4-sample chord sum agrees with the runtime's forward difference to about **nine
 significant digits** — *below* what float32 can hold, which is why both spellings
-reproduce both exports exactly, and *above* the six decimals rigc emits, which is
-why the file can tell them apart. On both rigs above they round apart on the
-**last** curve, where the running total has accumulated most: `610.802519` against
-`610.802520`, `1127.735817` against `1127.735818`. So the editor is the evidence
-for *what* is computed, and only `PathConstraint` itself is evidence for *how*.
+reproduce both exports exactly, and since issue #716 below what rigc's own file
+holds too, because rigc now writes each number as its float32. Under the six fixed
+decimals it wrote until then the file could tell them apart: on both rigs above
+they rounded apart on the **last** curve, where the running total has accumulated
+most — `610.802519` against `610.802520`, `1127.735817` against `1127.735818`. So
+the editor is the evidence for *what* is computed, and only `PathConstraint`
+itself is evidence for *how* — `PS67`/`PS68` compare the transcription with it at
+double precision.
 
 ⭐ **rigc emits the forward difference itself** since
 [#560](https://github.com/firejune/rigc/issues/560) — `pathCurveLengths` in
@@ -7989,6 +8047,7 @@ Per part:
 | --- | --- |
 | `part`, `path`, `width`, `height` | the PNG, by the name every message uses |
 | `placement` | the best placement found — `null` **only** for `empty-part` and `larger-than-canvas`, where nothing was searched |
+| `walls` | the walls of the search window `placement` stands **on**, whatever the verdict: `[]` when it settled inside, otherwise one `{ axis, edge, window }` per axis — `axis` is `scale` or `rotation`, `edge` is `floor` or `ceiling`, `window` is the flag's own `min,max`. A value on a wall is where the search was held, not where it came to rest — see §11.4 |
 | `alternates` | other optima worth reporting, best first. Non-empty means the answer was not unique |
 | `ambiguous` | at least one alternate is inside the ambiguity margin. **Choose with something this instrument cannot see** — anatomy, the other frame, or `rigc vote` |
 | `rotationFree` | the part is self-similar under rotation, so `rotationDeg` is a placeholder and the value is yours |
@@ -8043,9 +8102,22 @@ holds nothing because it already contains every angle.
   That is the case where the window is the first thing to move rather than the
   frame or the threshold — eleven parts of one frame came back refused at
   `scale=0.500` against art rendered at `0.311` per part pixel, and the message
-  said only that the residual was above `--max-residual`. It is printed on a
-  **refusal and nowhere else**: an accepted placement sitting on a wall is a window
-  chosen to bracket the answer, which is the flag working.
+  said only that the residual was above `--max-residual`. The sentence — with its
+  *"may lie below"* — is printed on a refusal only.
+- 🔒 **An accepted placement that stopped on a wall says which wall too**, beside
+  the value it holds on the console line and in `walls`:
+  `PLACE  head.png     x=   45.5  y=   37.5  rot=    0.0°  scale=2.000 (the ceiling of --scale 0.5,2)  residual=0.0394  unexplained= 10%`
+  is a part drawn at twice the scale of a frame rendered at 1.15 px/unit, whose
+  truth is **2.30** — outside the window — and whose residual at the ceiling still
+  cleared `--max-residual`. *On* a wall is not *near* one: the refinement is clamped
+  to the window, so a value the window held **is** the bound, while a correct
+  placement a window brackets closely settles strictly inside it and carries no
+  mark. A window with no interior (`min === max`) marks nothing — being at its only
+  value says nothing about the answer. ⚠️ The mark names the wall and not the side
+  the truth is on: over the rendered example corpus, a floor held both truths below
+  the window and parts shrunk into their own region whose truth was inside it. An
+  empty `walls` is not evidence either way — a window that excludes the truth can
+  still settle inside on another optimum, which is the caveat two bullets up.
 - ⚠️ **A frame whose border has no dominant colour reports `background.unknown`.**
   Every pixel then counts as material, the silhouette signal is gone, and the
   residual is colour agreement alone. The report says so rather than being quietly
@@ -8293,7 +8365,7 @@ simply unused; a name the directory lacks is refused `no-part-image` by name.
 | --- | --- |
 | `--anchor <pose.json>` | use this `rigc pose` report instead of running one. Refused together with `--scale` / `--rotation`, which size the internal pass that then does not happen |
 | `--atlas` | **refused by name.** Every other `--candidate` command takes it, so trying it here is reasonable — but the part art comes from `--images` and the skeleton is all this needs of the candidate, so a flag that silently did nothing would be worse than one that says why |
-| `--hinge <min,max>` | the window each child's local rotation is searched over, in Spine degrees about its setup value. Default `-180,180` — **a full turn, on purpose**: one degree of freedom is cheap enough to sweep exhaustively, and §11.4's warning about a window that does not contain the truth applies here too |
+| `--hinge <min,max>` | the window each child's local rotation is searched over, in Spine degrees about its setup value. Default `-180,180` — **a full turn, on purpose**: one degree of freedom is cheap enough to sweep exhaustively, and §11.4's warning about a window that does not contain the truth applies here too. The hinge step `3°` is a **ceiling** on the step, not the step: a window it does not divide is divided into whole steps no coarser than it, and `search` states the step that division produced, so `--hinge -20,20` prints `hinge -20°–20° step 2.857° (15 rungs)` and each chain part's note says it was searched `in 2.857° steps`. The full turn divides it exactly, so the default walks the same rungs it always did |
 | `--stretch <ratio>` | also search a uniform bone scale, this ratio either way. Without it, stretch is searched **only where your own animations key a `scale` timeline on that bone** — a rig that never scales a bone is a rig saying that bone does not stretch |
 | `--min-visible <0..1>` | below this visible share a placement is refused `occluded` instead of reported flat (default `0.25`). A reporting threshold, not a pass bar; the placement is still in the JSON. ⚠️ **It is not inert, though**: a bone whose frozen share is under this floor gets one *unmasked* look before its visible set is fixed, so the flag also changes **where parts land** and not only which rows are refused. Two runs at different `--min-visible` are two fits, and their shares are not one column |
 | `--max-residual <0..1>` | as §11, over the visible pixels (default `0.25`) |

package/docs/FACE.md

@@ -1187,13 +1187,14 @@ declares it: `"from": -19, "to": 0, "scale": 0.05, "max": 19, "local": true,
 and `to`** — and `to: 0` says nothing more than *the bottom of the range is the
 animation's first frame*. `from`, `max` and the duration are all the ceiling.
 
-🔸 **And `scale` is chosen for the endpoint.** rigc rounds every number it emits
-to six decimals, so a `scale` that is not exact there moves the top of the dial:
-`1/60` ships as `0.016667`, and a 60° turn then applies at 1.00002 s rather than
-1 s — the last frame under `loop: false`, the *first* under `loop: true`
-(AUTHORING §3.5.2). `0.05` is exact at six decimals, which is the only reason the
-example can put its endpoint exactly on the duration. Pick a `scale` that is not,
-and land the endpoint inside the duration instead.
+🔸 **And `scale` is chosen for the endpoint.** rigc emits every number as its
+float32's shortest name, so a `scale` the float cannot hold moves the top of the
+dial: `1/60` ships as `0.016666668`, and a 60° turn then applies at 1.00000008 s
+rather than 1 s — the last frame under `loop: false`, the *first* under
+`loop: true` (AUTHORING §3.5.2). `0.05` is its own float's name, so the file states
+exactly `0.05`, which is the only reason the example can put its endpoint exactly
+on the duration. Pick a `scale` that is not, and land the endpoint inside the
+duration instead.
 
 ⚠️ **The ceiling is per mesh, and the face's is not the smallest one on the
 face.** The same run prints one for every depth mesh, and in this example each

package/docs/INGEST.md

@@ -762,18 +762,28 @@ State the ambition in the right units, because three different things get called
 `build(ingest(x))` is byte-identical for a skeleton **rigc** emitted — that is the
 contract `bun run selftest` gates on every run — and it is not, for a skeleton the
 editor emitted. Measured over all twelve corpus exports, a field-by-field walk of the
-rebuild against its source produces differences of exactly three kinds, in every file:
+rebuild against its source produces differences of exactly two kinds, in every file:
 
 | Kind | Example, candidate vs reference | Why |
 | --- | --- | --- |
 | **header bookkeeping**, 3 per file | `skeleton.hash: undefined vs "VFWbaK2UoCM"`, `skeleton.audio: undefined vs null`, `skeleton.spine: "4.3.13" vs "4.3.75-beta"` | the rig spec has no field for `hash` or `audio`, and the version is the runtime rigc links. `ingest` reports all three as findings — `HEADER_BOOKKEEPING` and `HEADER_REDERIVED` |
 | **an omitted default written out** | `…rotate[0].time: 0 vs undefined` | the editor omits a zero `time`; rigc writes it. AUTHORING §10.5's *do not imitate the exporter's omissions*, from the other side. The header has one of these too and it is the one `ingest` now names: a stage at the origin is written `width`/`height` with no `x`/`y`, and the rebuild spells both — `LOSS HEADER_ORIGIN`, with the box unchanged ([#622](https://github.com/firejune/rigc/issues/622)). No file in this corpus takes that branch: all twelve declare an origin away from 0 |
-| **the emitted precision** | `…curve[0]: 0.066667 vs 0.06666667`, `uvs[0]: 0 vs 2.554152e-7` | rigc emits six decimals |
+
+🔢 **A third row stood here until issue #716: the emitted precision** —
+`…curve[0]: 0.066667 vs 0.06666667`, `uvs[0]: 0 vs 2.554152e-7` — because rigc wrote
+six fixed decimals where the editor writes each number as the shortest decimal naming
+its float32. It rewrote every number with more digits than that, by up to 7e-7, with
+no `LOSS` line, and the `uvs[0]` case was that rounding taking a carried value to 0 —
+`ingest` carries every number as the double it parsed, so no derivation was involved.
+rigc now writes the editor's text, and `IG73` holds every number of the twelve
+rebuilds to its source's spelling; `IG75` counts what still differs by kind, and none
+of it is a number. The whitespace of an export is not compared at all — it is an
+export setting, pretty-printed in the examples and one line from the command line.
 
 ⇒ **So the corpus gate is `diff` at 1.000 rather than a byte comparison**, and it is
 worth being exact about what that does and does not cover. `diff` compares structure —
 counts, names, parentage, order, timeline kinds, key counts, curve kinds — and **not
-the values inside the keys**, which is why the precision row above is invisible to it.
+the values inside the keys**, which is why a moved value is invisible to it.
 On rigc's own rigs byte identity covers both; on a foreign export it used to be
 `check` (pixels) or nothing, depending on what you render.
 
@@ -784,8 +794,9 @@ every bone's `length` or mirrored every vertex would read 1.000 on all 49 measur
 on every `(reported)` one. So the corpus round trip also compares **value by value**,
 with the format's defaults taken from the parser rather than from a table — both files
 are read through `spine-core` and the parsed forms are compared path by path, under a
-tolerance that is the sum of rigc's own 1e-6 emitted grid and one float32 step of the
-runtime's storage. Nine measures, printed on `IG16`'s own line and gated there — here
+tolerance that is the sum of the 1e-6 grid rigc's closed-form models are evaluated on
+— the one absolute grid it still emits on — and one float32 step of the runtime's
+storage. Nine measures, printed on `IG16`'s own line and gated there — here
 is the `6-arcs` export's, wrapped to fit this page:
 
 ```
@@ -805,7 +816,7 @@ does **not** cover, in the same breath:
 | `version` and `hash` | the rig spec has no field for either, and `ingest` reports both as findings — the header row above, unchanged |
 | anything below one float32 step | the parser stores frames, curves and vertices in a `Float32Array`, so a difference it cannot represent is invisible to any reading of the parsed form |
 | a Bezier's handles *as written* | the parser samples them into the curve, so a moved handle arrives as moved samples rather than as the handle it was |
-| how the file is **spelled** | field order, an omitted default written out, six decimals against eight — the second and third rows of the table above are values that agree, and this measure says so |
+| how the file is **spelled** | field order and an omitted default written out — the second row of the table above is values that agree, and this measure says so. A number's spelling is `IG73`'s, which reads the rebuild as text |
 | how it **looks** | that is `check`, and `--texture-from` is how its figure is attributed |
 
 The geometric row needs a real number, because a naive reading of `check` makes an

package/package.json

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