spine-rigc 0.14.1 → 0.15.0

package/README.md

@@ -386,7 +386,7 @@ limits: [AUTHORING.md §11](docs/AUTHORING.md). The parts it refuses because
 something is drawn over them are `rigc chainfit`'s, once a candidate exists —
 [§12](docs/AUTHORING.md).
 
-## The gallery — five complete rigs over art that ships with them
+## The gallery — six complete rigs over art that ships with them
 
 Each directory in [`gallery/`](https://github.com/firejune/rigc/tree/main/gallery) is
 one rig spec, one motion spec and the PNGs they name, small enough to read in one
@@ -402,6 +402,7 @@ was verified, and what writing it cost. Repository material: a clone and
 | [`gallery/flex`](https://github.com/firejune/rigc/tree/main/gallery/flex) | **`contour` meshes** | A swallow-tailed banner and a serrated leaf: four meshes traced off their own alpha, waved by bone timelines and rippled by a `deform` |
 | [`gallery/ride`](https://github.com/firejune/rigc/tree/main/gallery/ride) | `path` attachments + **path constraints** | A trolley coasting down a drawn rail and rolling back, driven by a `position` timeline, with `groups` + `stagger` keying the wheels and the ears |
 | [`gallery/portrait`](https://github.com/firejune/rigc/tree/main/gallery/portrait) | **deform `transform`** + `derive` group tracks | A 2.5D head turn: two meshes and six feature bones all keyed from one stated expression, `dx = x(cos t − 1) − z·sin t`, with the depths in the spec rather than a README |
+| [`gallery/nod`](https://github.com/firejune/rigc/tree/main/gallery/nod) | the **`pitch`** and **`wave`** transform kinds | A head bowing and two lop ears rippling, on three meshes each laid out for the closed form that moves it — a fold angle solved for before authoring, and a shear whose winding no amplitude can reverse |
 
 <p align="center">
   <img src="https://raw.githubusercontent.com/firejune/rigc/main/assets/rigc-scene.gif" alt="A portrait rig breathing, glancing aside, then turning its head in 2.5D — hair and features sliding at different depths" width="600" />
@@ -413,6 +414,12 @@ feature carries its own depth. Scene direction of this kind was Live2D's territo
 split was authoring cost, and the cost is now one stated expression per key. Compiled and
 rendered entirely by the published package.</em></p>
 
+🎞️ **How the three films on this page were made** is kept with them, one directory per
+film in [`films/`](https://github.com/firejune/rigc/tree/main/films) — a `run.sh` that
+names every step, the assembler that cuts the shots and draws the type, and a README
+saying what the film claims and which tool printed each figure on screen. Repository
+material, like the gallery: a clone runs them.
+
 ## Commands
 
 Every command takes its paths explicitly. `rigc <command> --help` prints its flags, and

package/cli.ts

@@ -727,9 +727,10 @@ function cmdBuild(flags: Record<string, string>): void {
   const { label, opts } = resolveCut(flags);
   const profile = readProfile(flags);
   const packing = flags.pack !== undefined;
-  // Three combinations are refused rather than silently resolved, because in each
+  // Two combinations are refused rather than silently resolved, because in each
   // one the two flags disagree about a single question and there is no answer
-  // that is not a guess about which the caller meant.
+  // that is not a guess about which the caller meant. (There were three until
+  // issue #266 — see the note below the second.)
   if (packing && opts.atlasInPath !== undefined) {
     throw new UsageError(
       '--pack and --atlas-in are opposite directions through the same door: --pack MAKES an atlas out of the ' +
@@ -742,13 +743,12 @@ function cmdBuild(flags: Record<string, string>): void {
         'the loose part PNGs, which a packed atlas does not reference. Drop --copy-images',
     );
   }
-  if (packing && profile === 'spine-html') {
-    throw new UsageError(
-      "--profile spine-html asserts one part per page (A06's full-page coverage clause), which is rigc's unpacked " +
-        'convention and exactly what --pack stops being true. A packed atlas is valid Spine — build it under the ' +
-        'default --profile spine',
-    );
-  }
+  // `--pack --profile spine-html` used to be the third refusal here, because
+  // A06's coverage clause was "one part per page" flat and a legitimate pack
+  // arrived at the gate reading as a defect. Since issue #266's second follow-up
+  // that clause is "one part per page OR a tiling page", so the combination is
+  // now a build like any other — and it is the only one that puts the renderer's
+  // own rulebook over shared-page sampling.
   if (!packing) {
     for (const name of ['page-size', 'padding'] as const) {
       if (flags[name] !== undefined) throw new UsageError(`--${name} only means something with --pack`);

package/docs/AUTHORING.md

@@ -196,10 +196,16 @@ unweighted meshes, packed atlases) — reach for it when you are shipping into
 *that* project, not to be thorough. A report always prints which profile ran and
 lists what that profile left out, on `PROF` lines.
 
-⚠️ *Packed atlases* in that list includes the ones rigc now writes itself, so
-`--pack --profile spine-html` is refused by name rather than compiled and then
-failed: `A06`'s full-page-coverage clause **is** the unpacked convention, and a
-legitimate pack cannot satisfy it. Build a pack under the default `spine`.
+🆕 *Packed atlases* used to be in that list twice over: `--pack --profile
+spine-html` was **refused by name**, because `A06`'s coverage clause said "one
+part per page" flat and rigc's own pack could not satisfy it. Since
+[#266](https://github.com/firejune/rigc/issues/266) that clause is **one part per
+page OR a tiling page**, so the combination is an ordinary build — and it is the
+only one that puts the renderer's own rulebook over shared-page sampling. What a
+*tiling* page has to satisfy is stated where the clause is, §7's `A06` row: every
+region wholly inside the page it names, and no two regions on one page
+overlapping. Rotation is still refused, and that is a separate clause about
+rigc's packer never turning a region.
 
 ### 0.1 Packing the parts onto shared pages — `--pack`
 
@@ -1455,7 +1461,7 @@ is that a **depth** is the decision while a **residual** is not.
 | `kind` | Reads | `translatex` / `translatey` | `scalex` / `scaley` | Worked case |
 | --- | --- | --- | --- | --- |
 | `yaw` | each member's setup `x` | `d = (x−about)·(cos t − 1) − (depth − carried)·sin t` — FACE §3 | `cos(α − t)/cos α`, `α = atan2(x−about, depth)` — FACE §5 | `gallery/portrait` |
-| `pitch` | each member's setup `y` | the same expression with `y` for `x` — a nod | the same | — |
+| `pitch` | each member's setup `y` | the same expression with `y` for `x` — a nod | the same | `gallery/nod` |
 
 ⭐ **The `property` says which half of the turn a key is.** A turn does two
 things to a rigid part on a curved surface: it moves it, and it narrows it. Those
@@ -1464,7 +1470,19 @@ which one the track is — so a `derive` on a property its kind has no projectio
 onto is refused by name rather than quietly driven by the wrong half.
 
 **The parameters.** `degrees` and `depth` are required; `depth` is
-`{ "member": z, … }` on a group track and one number on a bone track. `carried`
+`{ "member": z, … }` on a group track and one number on a bone track.
+
+⚠️ **`z` runs toward the viewer (FACE §1), so a larger depth is nearer.** A nose
+in front of the skull surface takes a **bigger** number than the socket beside
+it, and a **negative** depth is behind the axis — which is what makes the back of
+a head swing the other way (FACE §2). That sign is the one parameter here no
+assertion can check, so the closed form is the arbiter: a part with
+`depth > carried` gets a **negative** residual, and FACE §3 makes exactly that
+the nose diagnostic — *if the nose's residual is not negative, the depths are
+wrong*. ([#351](https://github.com/firejune/rigc/issues/351) was this sentence
+missing here and stated backwards in the field reference.)
+
+`carried`
 (default 0) is **the depth whose shift a parent bone already applies** — FACE
 §3's shared-shift split, stated: put a bone at the plate's own origin, key
 `−carried·sin t` there, and each member then keys only its residual. That split
@@ -1943,7 +1961,9 @@ where the remedy is a line you own. `A35` does **not** refuse it: it is pointed
 other people's files, and a rule stricter than the runtime tells its reader to go
 and break correct data.
 
-🖼️ **Worked examples, and they use a deform for three different things.**
+🖼️ **Worked examples, and they use a deform for four different things** — all
+four are repository material rather than part of the published package, so the
+links go to GitHub.
 [`gallery/squash`](https://github.com/firejune/rigc/tree/main/gallery/squash) — a 9-vertex ball squashed about its contact point,
 from the two affine transforms its keys now **state**.
 [`gallery/portrait`](https://github.com/firejune/rigc/tree/main/gallery/portrait) — a 2.5D head turn, where the keys are the
@@ -1951,6 +1971,11 @@ from the two affine transforms its keys now **state**.
 placed to sample a cosine, and a measured account of the angle past which the
 mesh folds. [`gallery/flex`](https://github.com/firejune/rigc/tree/main/gallery/flex) — a leaf whose blade bends on a
 `contour` mesh no bone can bend, and the measurement that picked the model.
+[`gallery/nod`](https://github.com/firejune/rigc/tree/main/gallery/nod) — the
+projection on the **other** axis (a `pitch`, §4.11.1), and a **travelling wave**
+whose only moving parameter is `phase`: each of its three meshes is laid out for
+the model that bends it, so the rows are the argument rather than the vertex
+count.
 
 📘 **[FACE.md](FACE.md) is the recipe for that second case**, and it is where the
 grid questions this section leaves to its reader are answered: where to put the
@@ -1996,9 +2021,9 @@ example needed it:
 | `kind` | Parameters | What it evaluates | Worked case |
 | --- | --- | --- | --- |
 | `yaw` | `radius`, `degrees`, `about` | `dx = (x−about)·(cos t − 1) − z·sin t`, `z = √(radius² − (x−about)²)` — the 2.5D turn (FACE §1) | `gallery/portrait` |
-| `pitch` | the same | the same expression with `y` for `x` — a nod rather than a turn | — |
+| `pitch` | the same | the same expression with `y` for `x` — a nod rather than a turn | `gallery/nod` |
 | `affine` | `scale`, `about` | `dx = (sx−1)·(x−ax)`, `dy = (sy−1)·(y−ay)` — a scale about a fixed point | `gallery/squash` |
-| `wave` | `amplitude`, `wavelength`, `phase`, `along`, `axis` | `d = amplitude · sin(2π·along/wavelength + phase)` | — |
+| `wave` | `amplitude`, `wavelength`, `phase`, `along`, `axis` | `d = amplitude · sin(2π·along/wavelength + phase)` | `gallery/nod` |
 | `bend` | `amount`, `from`, `to`, `power`, `along`, `axis` | `d = amount · u^power`, `u = (along − from)/(to − from)` | `gallery/flex` |
 
 `along` names the coordinate a wave or a bend reads and `axis` the one it
@@ -2008,7 +2033,7 @@ axis is a stretch and `affine` states that. `power: 1` is an affine shear and
 instead of tilting. `about` defaults to 0 (or `[0, 0]`), `phase` to 0 and `power`
 to 2; nothing else has a default.
 
-Five things this construct is bounded by, and each one is a refusal rather than a
+Six things this construct is bounded by, and each one is a refusal rather than a
 convention:
 
 **It covers every vertex, always.** A transform is a model of the attachment, not
@@ -2039,6 +2064,22 @@ consequences. One kind is the exception and it is an exception with a proof:
 `affine` refuses a determinant at or below zero, and above zero a positive
 determinant means no triangle **can** reverse.
 
+**A model that evaluates to nothing is refused too**
+([#350](https://github.com/firejune/rigc/issues/350)). Every parameter can be
+individually legal and the model still come out as a **run of zeros** — a `wave`
+whose wavelength puts every vertex on a zero crossing, a `bend` over a span the
+part barely enters. The key then claims a deformation, emits the identity and
+gates green: `A35` is right that the run fits and `A39` is right that no triangle
+moved, so the compiler is the only place it can be said. ⭐ **What distinguishes
+it is where the identity is stated.** A key that *means* the setup pose says so
+in its own parameters — `degrees: 0` (or any whole revolution), `amplitude: 0`,
+`amount: 0`, `scale: [1, 1]` — or carries no run at all, and those compile. The
+refused pair is parameters that state a deformation beside an evaluation that is
+the identity. The message names the vertex count, the largest value the closed
+form reached before quantising, and the measured fact behind the usual cause: for
+a wave, the closest two distinct coordinates it read and the ratio the wavelength
+makes against them.
+
 **It is auditable.** `explain` prints the model, the scalars the closed form
 derived from it, and every offset it produced — the emitted ones, not a second
 evaluation:
@@ -2154,6 +2195,15 @@ inverted build is the case worth reading — `A39` passes it (correctly: nothing
 reverses), and the block is what says `x1.362834` where the model's own table
 says `x1.319121`, with no reference render anywhere.
 
+📘 **[`gallery/nod`](https://github.com/firejune/rigc/tree/main/gallery/nod)'s
+README is a second reading of the same block** (repository material, hence the
+GitHub link), and it is the one where the figures are checked from two directions
+at once. Its `pitch` band ratios are *derived* from the mesh's own row table and
+*measured* off the posed vertices, and the two agree to six decimals. Its `wave`
+keys then report an area ratio of `1.000000 ± 1e-6` at **every** amplitude — not
+a measurement but a **proof** showing up as one, because a wave that reads `y`
+and displaces `x` over row-major quads preserves every signed area exactly.
+
 ---
 
 ### 4.12 `path` and `slider` timelines — tracks, not their own groups
@@ -2310,6 +2360,7 @@ or the key's position in its own track. These are the frequent ones, verbatim:
 | `deform … (t=…): … has no single space to evaluate it in` | §4.11.1 — the attachment's vertices are in several bind spaces; key the control bone, or write the pairs with `offset` |
 | `deform … (t=…): transform yaw has radius R, and vertex v sits at x=… past it` | §4.11.1 — the cylinder has no surface there; raise the radius to where the part sits |
 | `deform … (t=…): transform affine has scale […], whose determinant is …` | §4.11.1 — at or below zero the map reverses every triangle |
+| `deform … (t=…): transform <kind> states …, and every one of this attachment's N vertices evaluates to an offset of 0` | §4.11.1 — the parameters state a deformation and the geometry sampled it to nothing; the message names the measured cause. A key that means the setup pose states the identity in its parameters, or carries no run |
 | `vertexCount is N, which is not a multiple of 3` | §3.4 — a path's vertices are knots and handles read in groups of three: `3(K + 1)` open, `3K` closed |
 | `vertexCount is N and an open path needs at least 6` | §3.4 — an open path drops its first and last point, so it needs six for one curve |
 | `"lengths" is not authored — rigc measures the setup arc length of each curve` | §3.4 — delete the array; it is a measurement of the vertices above it |
@@ -2355,7 +2406,7 @@ The report prints one line per assertion:
 | `A03_REGION_WIDTH_HEIGHT_FINITE` | both | a region loaded `NaN` or a non-positive size — the attachment has no `image` and no `width`/`height` |
 | `A04_MESH_TRIANGLES_AND_ENCODING` | both | authored mesh geometry: triangle count not a multiple of 3, an index out of range, or a `vertices` length that disagrees with `uvs` (the weighted/unweighted trap) |
 | `A05_CURVE_ARRAY_LENGTH` | both | a raw `curve` with the wrong number of values, a non-finite number in one, or a curve on a timeline that cannot take one. Four numbers **per value channel** |
-| `A06_ATLAS_PAGE_SIZE_MATCHES_PNG` | both ◑ | the atlas `size:` disagrees with the PNG on disk. Under `spine-html` also: `pma`, rotation, and a region that does not cover its page |
+| `A06_ATLAS_PAGE_SIZE_MATCHES_PNG` | both ◑ | the atlas `size:` disagrees with the PNG on disk. Under `spine-html` also: `pma`, rotation, and a page that is neither **one part covering it exactly** (the unpacked convention) nor a **tiling** — a page whose regions all sit inside it and none of which overlap ([#266](https://github.com/firejune/rigc/issues/266)). A packed atlas therefore gates under this profile; what the message names is the region that runs off its page, or the pair that shares texels |
 | `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 |
 | `A08_REGION_NAMES_MATCH_ATTACHMENTS` | both ◑ | an attachment resolves to a region the atlas does not have — usually a `path`/`image` basename mismatch. Under `spine-html` the placeholder and the region name must also be *identical* |
 | `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 |
@@ -2368,7 +2419,7 @@ The report prints one line per assertion:
 | `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` |
 | `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 |
+| `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)) |
 | `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, or a binding at weight 0 |
 | `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 |
@@ -2773,6 +2824,14 @@ measurement, while segment lengths taken off a folded pose are an estimate — s
 disagree, suspect the estimate. And do this **per chain, before its first fit**, because
 the surgery to fix it invalidates every pose already fitted with the short chain.
 
+⚠️ **The paragraph above is written for a chain that is too *short*, and the check bites
+in both directions.** A chain that is too *long* fails differently — the fits converge,
+every residual is ordinary, and the figure splays to absorb the excess — which is why
+reading only this direction has twice sent a run looking for the wrong defect.
+[RIGGING.md](RIGGING.md) §6.2 carries the too-long case with its record and its cheap
+detector, and §6.3 carries the refusal that goes with it: an excess names a
+disagreement between a chain and a shot, and it does not say which of the two is wrong.
+
 **Re-fit the setup pose against frames drawn from every shot, not against one.** Every
 animation is measured from the setup pose, so an error in it is an error in all of
 them — and it is exactly the error one frame cannot show you. Fit an attachment's

package/docs/FACE.md

@@ -33,6 +33,13 @@ hold its results.
   [`gallery/portrait`](https://github.com/firejune/rigc/tree/main/gallery/portrait),
   and its measurement half,
   [`FINDINGS.md`](https://github.com/firejune/rigc/tree/main/gallery/portrait/FINDINGS.md)
+- **The same closed forms on the other axis**, since 2026-09-03:
+  [`gallery/nod`](https://github.com/firejune/rigc/tree/main/gallery/nod) is a
+  worked `pitch`, and this page stays written for a **yaw**. It re-derives §4.2's
+  fold angle on uneven *rows* and brackets it against `A39` at 33°/34°, and it
+  measures §5's foreshortening at **0.863–1.176** against the yaw's 0.892–1.064
+  below — a wider span at the same 12°, because a face is taller than it is deep.
+  Read it after this page, not instead of it
 
 🚨 **Nothing in this toolchain measures what a `deform` key does, and that is the
 one gap you have to author around.** The setup geometry is measured and printed —
@@ -471,6 +478,14 @@ above the 16° §8 calls the instrument's ceiling. ⇒ **Then let the last band
 single wide one** — that is the direction that buys safety, and it is the
 opposite of refining.
 
+📘 **The identity above, used forwards on a `pitch`.**
+[`gallery/nod`](https://github.com/firejune/rigc/tree/main/gallery/nod)
+(repository material) picks its ceiling first and solves the *rows* out of it —
+`|y|outer = R·cos θmax` with θmax chosen at 21° giving 140.037 — and then
+brackets the fold this section predicts against `A39` itself: **33° gates green
+and 34° does not**, with the refusal naming the row pair the closed form names.
+That is this table checked from the other end, on the other axis.
+
 ### 4.3 `hull` is `0`, and the vertex order is why
 
 ⚠️ **A grid's perimeter is 16 of its 25 vertices and they are not a prefix of any
@@ -510,6 +525,15 @@ The far eye narrows to 89%, the near eye widens to 106% (**derived**: 0.8922 and
 track — the nose and mouth did, through a `groups` entry, and it was the only
 place in the worked example's turn where two parts could (§7).
 
+📘 **How much this is worth depends on the axis, and there is a worked case for
+the other one.** The same closed form on the `pitch` of
+[`gallery/nod`](https://github.com/firejune/rigc/tree/main/gallery/nod)
+(repository material) spans **0.863 … 1.176** across its five features, against
+the **0.892 … 1.064** above — a wider span at the *identical* angle, because
+`α = atan2(coordinate, depth)` grows with the coordinate and a face is taller
+than it is deep. ⇒ **The foreshortening buys more on a nod than on a turn**, and
+that is arithmetic rather than a judgement about the art.
+
 📌 **That entry is gone, and the reason is worth a line.** `scalex` is the
 foreshortening projection of the same `derive` kind §3.1 uses (AUTHORING §4.5.1),
 so all six features are one track and the on-axis pair's shared value **falls out
@@ -1078,6 +1102,13 @@ listing it. Its
 is the measurement half: what it cost, the seven-angle sweep, the five tool gaps
 it filed.
 
+📘 **The `pitch` has its own worked case**, and this page deliberately stays a
+yaw: [`gallery/nod`](https://github.com/firejune/rigc/tree/main/gallery/nod) is
+the same two closed forms on the other axis, plus a travelling `wave` (AUTHORING
+§4.11.1). §4.2 and §5 above point at the two places its figures are worth
+reading beside these — the fold angle bracketed against `A39`, and a
+foreshortening span that is wider at the same angle.
+
 ```bash
 bun install                                     # once
 

package/docs/INGEST.md

@@ -668,18 +668,19 @@ be weighted at all is policy.
 
 ⚠️ **`--profile spine-html` on foreign data produces a wall of failures that mean
 nothing about the file.** Same `spineboy-pro.json`, same atlas, one flag changed — the
-run ends `rigc: 53 assertion(s) failed`, and this is the tally with one real message
-per rule:
+run ends `rigc: 13 assertion(s) failed`, and this is the tally with one real message
+per rule (re-measured 2026-09-04; it used to read 53, with 40 `A06` rows, until A06
+learned that a page is one part covering it exactly *or a tiling of regions* — #266
+follow-up 2 — so a packed atlas now passes both profiles and the wall is policy only):
 
 | Count | Rule | One of its messages |
 | --- | --- | --- |
-| **40** | `A06_ATLAS_PAGE_SIZE_MATCHES_PNG` | `region "crosshair" has UVs (0.181640625,0.06640625)-(0.2255859375,0.2421875); one part per page must cover the page exactly` |
 | **10** | `A15_IDLE_NO_MESH_BONE_KEYS` | `idle keys bone "front-shoulder", which drives a mesh — meshes never idle-skip` |
-| **2** | `A20_MESH_WEIGHTS_COHERENT` | `mesh "hoverboard-board" is unweighted; the ring tier drives meshes by bones` |
+| **2** | `A20_MESH_WEIGHTS_COHERENT` | `mesh "front-shin" is unweighted; the ring tier drives meshes by bones` |
 | **1** | `A11_NO_CLIPPING_ATTACHMENTS` | `1 clipping attachment(s); the renderer skips them silently` |
 
-Every one of those is a correct statement about a correct file: the atlas *is* packed,
-a bone *does* key a mesh, a mesh *is* unweighted, a clipping attachment *is* present.
+Every one of those is a correct statement about a correct file: a bone *does* key a
+mesh, a mesh *is* unweighted, a clipping attachment *is* present.
 (The tally was 55 before §3.2's A35 was fixed, and that is the one entry that was *not*
 a correct statement — which is why it belonged in a different section from these.)
 And it is not a big-skeleton problem — `3-timing-and-spacing`, with two regions on one

package/docs/MOTION.md

@@ -161,7 +161,8 @@ open-code neither: `screenToSpineDegrees(rotationDeg)` and
 `cropToSpineY(y, frameHeight)`, both in
 [`src/transform.ts`](../src/transform.ts). The `space` field of every report repeats
 the contract in the file, so a consumer never has to remember which way the flip
-goes.
+goes. (Canonical: AUTHORING §11.2, which states the same contract as a field
+reference; it is restated here because §2 is where you convert one.)
 
 ⚠️ A **bone offset** in a spec is expressed in its parent's local axes, so the y flip
 applies there too and it applies **once**. Converting a world point and then also

package/docs/RIGGING.md

@@ -581,7 +581,10 @@ that takes the chain.
 The same rig keys `headroll` and never `head`: *"a head rotates about the top of the
 neck, not about the middle of its own face."* A renderer policy assertion
 (`A15_IDLE_NO_MESH_BONE_KEYS`, AUTHORING §5) forced that answer independently — two
-arguments, one bone.
+arguments, one bone. ⚠️ **It is a renderer rule, so like §10.3's `A25` it only fires
+under `--profile spine-html`**; under `--profile spine` it reports `PROF` and the
+structural argument is the only one you get. [FACE.md](FACE.md) §3 is the same bone
+from the mesh's side.
 
 📌 **What the extra link buys, for free:** *"a rotation about the neck pivot carries
 its descendants on a circle for free."* A yaw expressed as `translatex` draws a

package/package.json

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

package/src/atlas.ts

@@ -32,19 +32,46 @@
  * the field this deliberately does not use.
  *
  * ⚠️ **The rendered pictures are equal to within one least significant bit, not
- * bit-for-bit, and the difference is arithmetic rather than texels.** A packed
- * region's UVs are `x / pageWidth` rather than `0..1`, so the sampling coordinate
- * carries one more rounding step (`fl(regionX + fl(s * width))` cannot be exact
- * once `regionX > 0`); the interpolation weight can then differ in its last bit
- * and a `Math.round` sitting exactly on a `.5` boundary lands the other way.
- * Measured: 0 to 480 channel samples of 7 to 21 million on the three public
- * fixtures, worst difference **1**, against 22,000 to 60,000 samples and a worst
- * difference of **77** when the gutter is removed — and byte-identical on eleven
- * of the repository's thirteen rigs across 1,101 frames. Making it exact would mean
- * sampling in region-local coordinates and adding the integer page offset to the
- * tap indices, which is a change to `src/render.ts` that would move every
- * committed reference frame by the same one bit; that is a decision for whoever
- * owns those records, not a side effect of adding a packer.
+ * bit-for-bit, and the difference is arithmetic rather than texels.** Measured: 0
+ * to 480 channel samples of 7 to 21 million on the three public fixtures, worst
+ * difference **1**, against 22,000 to 60,000 samples and a worst difference of
+ * **77** when the gutter is removed — and byte-identical on eleven of the
+ * repository's thirteen rigs across 1,101 frames. The two that are not are the
+ * two with meshes.
+ *
+ * 🔬 **Where that last bit is lost, measured (issue #266, follow-up 1).** This
+ * paragraph used to say the cause was rigc's own sampling coordinate — `fl(regionX
+ * + fl(s · width))` failing to be exact once `regionX > 0` — and that the repair
+ * was to sample in region-local coordinates and add the integer page origin to the
+ * tap indices. **Both halves are wrong, and the second is unreachable.** Poses of
+ * the loose and the packed build of one skeleton, compared coordinate by
+ * coordinate as `u · pageWidth − regionX` against the loose `u · pageWidth`:
+ *
+ *   * on every **region** attachment the difference is **exactly 0**. `regionX`,
+ *     `regionWidth` and `pageWidth` are integers and the page is a power of two,
+ *     so `u · pageWidth` recovers `regionX + localTexel` with nothing lost —
+ *     which is why the eleven region-only rigs are already byte-identical, and
+ *     why `PK18` can assert exactness rather than a bound;
+ *   * on a **mesh** it is **not** 0 — 88 of 88 coordinates on `gallery/squash`'s
+ *     ball, worst 3.15e-5 texels — because `spine-core` stores mesh page UVs in a
+ *     **`Float32Array`**. `MeshAttachment.updateRegion` computes `u +
+ *     regionUVs[i] · width` and rounds the whole thing to float32, so the low bits
+ *     of the scaled coordinate are gone **before rigc reads the array**. The
+ *     counterfactual settles which term does it: the same region at page origin
+ *     `x = 0` still lands 9.5e-7 texels off the loose value, so it is the `f32(u ·
+ *     regionWidth / pageWidth)` scaling and not the origin addition.
+ *
+ * ⇒ **No change to [`src/render.ts`](render.ts) can recover it**, because it reads
+ * `piece.uvs` and the information is not in there. The only routes are for rigc to
+ * re-derive mesh page UVs from `MeshAttachment.regionUVs` in double precision —
+ * a second opinion about the runtime's own trim and rotation mapping, which
+ * `src/render.ts` refuses by name (see `artUvsOf`) — or one part per page, which
+ * is the unpacked convention. And the first would be worse than the residual: the
+ * renderer is the yardstick `check` measures a candidate against *because* it
+ * draws what a runtime draws, and a runtime playing this atlas gets the float32
+ * numbers. Making two rigc renders agree by disagreeing with the runtime is the
+ * wrong trade. So the bound stays a bound, `PK18` attributes it, and the follow-up
+ * is closed as measured rather than done.
  *
  * ## Why a second parser for a format `spine-core` already parses
  *
@@ -498,6 +525,38 @@ function floorPowerOfTwo(n: number): number {
   return p;
 }
 
+/**
+ * The smallest power-of-two page that holds these cells, and where they land on
+ * it — or `null` when they do not fit `maxEdge x maxEdge` at all.
+ *
+ * Every power-of-two pair up to the maximum is tried in order of increasing
+ * area, then increasing width, so the answer is a total order and two packs of
+ * the same set choose the same page. Powers of two are not decoration:
+ * `region.x / page.width` is the coordinate every texel is read through, and a
+ * power-of-two denominator makes that division exact in binary floating point.
+ *
+ * ⭐ One search, two callers, and that is the point. It picks the single page a
+ * set that fits gets, and it picks each SPILLED page's own size — so "the page
+ * written is the smallest that holds what is on it" is one rule with one
+ * implementation rather than a rule and an exception.
+ */
+function smallestPageFor(
+  cells: Array<{ w: number; h: number }>,
+  maxEdge: number,
+): { width: number; height: number; rects: Rect[] } | null {
+  const edges: number[] = [];
+  for (let e = 1; e <= maxEdge; e *= 2) edges.push(e);
+  const candidates: Array<{ w: number; h: number }> = [];
+  for (const w of edges) for (const h of edges) candidates.push({ w, h });
+  candidates.sort((a, b) => a.w * a.h - b.w * b.h || a.w - b.w);
+  for (const candidate of candidates) {
+    const attempt = packOnePage(cells, candidate.w, candidate.h);
+    if (attempt.some((r) => r === null)) continue;
+    return { width: candidate.w, height: candidate.h, rects: attempt as Rect[] };
+  }
+  return null;
+}
+
 /**
  * MaxRects with Best Short Side Fit, no rotation.
  *
@@ -664,10 +723,16 @@ function extrudeCell(page: Plate, source: Plate, cellX: number, cellY: number, p
  * the one-bit residual described in this file's header would be two roundings
  * deep instead of one.
  *
- * Only when the whole set will not fit one page at the maximum does it spill,
- * and then every page is `pageSize x pageSize`. A single part whose cell is
- * bigger than that is refused by name — silently splitting one drawing across
- * two pages is not a thing the format can express.
+ * Only when the whole set will not fit one page at the maximum does it spill.
+ * **Which parts share a page is then decided at the maximum size** — that is what
+ * makes the boundary deterministic — **and each page is written at the smallest
+ * power-of-two pair that holds the cells assigned to it** (issue #266). So the
+ * rule is the same one either way: the page written is the smallest that holds
+ * what is on it. A spill used to write `pageSize x pageSize` for every page,
+ * which charged a set that overflowed by one small part a second full page of
+ * transparency — 4 MiB of decoded RAM at the 2048 default. A single part whose
+ * cell is bigger than the maximum is refused by name — silently splitting one
+ * drawing across two pages is not a thing the format can express.
  */
 export function packAtlas(inputs: PackInput[], opts: PackOptions = {}): PackResult {
   const pageSize = opts.pageSize ?? DEFAULT_PAGE_SIZE;
@@ -696,36 +761,22 @@ export function packAtlas(inputs: PackInput[], opts: PackOptions = {}): PackResu
     );
   }
 
-  // The smallest power-of-two page that holds the whole set, by area then width.
-  const edges: number[] = [];
-  for (let e = 1; e <= maxEdge; e *= 2) edges.push(e);
-  const candidates: Array<{ w: number; h: number }> = [];
-  for (const w of edges) for (const h of edges) candidates.push({ w, h });
-  candidates.sort((a, b) => a.w * a.h - b.w * b.h || a.w - b.w);
-
-  let pageW = maxEdge;
-  let pageH = maxEdge;
-  let single: Array<Rect | null> | null = null;
-  for (const candidate of candidates) {
-    const attempt = packOnePage(cells, candidate.w, candidate.h);
-    if (attempt.some((r) => r === null)) continue;
-    pageW = candidate.w;
-    pageH = candidate.h;
-    single = attempt;
-    break;
-  }
+  const single = smallestPageFor(cells, maxEdge);
 
   /** page index -> the placements on it, in packing order. */
   const perPage: Placement[][] = [];
+  /** page index -> the size that page is written at. */
+  const pageSizes: Array<{ width: number; height: number }> = [];
   const placements: Placement[] = [];
   if (single !== null) {
     perPage.push([]);
-    single.forEach((rect, i) => {
+    pageSizes.push({ width: single.width, height: single.height });
+    single.rects.forEach((rect, i) => {
       const place: Placement = {
         region: sorted[i].region,
         page: 0,
-        x: rect!.x + padding,
-        y: rect!.y + padding,
+        x: rect.x + padding,
+        y: rect.y + padding,
         width: sorted[i].width,
         height: sorted[i].height,
       };
@@ -733,42 +784,63 @@ export function packAtlas(inputs: PackInput[], opts: PackOptions = {}): PackResu
       placements.push(place);
     });
   } else {
-    // Spill. Every page is the maximum size; parts are taken in packing order
-    // and whatever will not fit the current page opens the next one.
+    // Spill. Which parts share a page is decided at the MAXIMUM size — that is
+    // what makes the boundary deterministic and independent of the shrink below
+    // — and parts are taken in packing order, whatever will not fit the current
+    // page opening the next one.
     let remaining = sorted.map((input, i) => ({ input, cell: cells[i] }));
     while (remaining.length > 0) {
       const pageIndex = perPage.length;
       const attempt = packOnePage(
         remaining.map((r) => r.cell),
-        pageW,
-        pageH,
+        maxEdge,
+        maxEdge,
       );
-      const onThisPage: Placement[] = [];
+      const onPage: Array<{ input: PackInput; cell: { w: number; h: number } }> = [];
       const leftOver: typeof remaining = [];
       attempt.forEach((rect, i) => {
-        if (rect === null) {
-          leftOver.push(remaining[i]);
-          return;
-        }
+        if (rect === null) leftOver.push(remaining[i]);
+        else onPage.push(remaining[i]);
+      });
+      if (onPage.length === 0) {
+        // Unreachable: every cell was proven to fit an empty page above. Kept as
+        // a named stop rather than an infinite loop if that ever stops holding.
+        throw new CompileError(
+          `packing stalled with ${remaining.length} region(s) left and an empty ${maxEdge}x${maxEdge} page`,
+        );
+      }
+      // ⭐ Then the page is written at the smallest power-of-two pair that holds
+      // the cells assigned to it, not at the maximum (issue #266, follow-up 3).
+      // A spill used to write `pageSize x pageSize` for every page, so a set that
+      // overflowed by one small part paid for a second full page of transparency
+      // — 4 MiB of decoded RAM at the 2048 default for a part that might be
+      // 64x64. Re-packing through the same search the single-page case uses is
+      // what keeps "the page written is the smallest that holds what is on it"
+      // one rule; a page whose own cells need the maximum simply gets it back.
+      const shrunk = smallestPageFor(
+        onPage.map((r) => r.cell),
+        maxEdge,
+      );
+      if (shrunk === null) {
+        // Unreachable for the same reason as the stall above: these cells were
+        // just placed on a maxEdge page.
+        throw new CompileError(`page ${pageIndex + 1} of the spill holds ${onPage.length} region(s) that no page fits`);
+      }
+      const onThisPage: Placement[] = [];
+      shrunk.rects.forEach((rect, i) => {
         const place: Placement = {
-          region: remaining[i].input.region,
+          region: onPage[i].input.region,
           page: pageIndex,
           x: rect.x + padding,
           y: rect.y + padding,
-          width: remaining[i].input.width,
-          height: remaining[i].input.height,
+          width: onPage[i].input.width,
+          height: onPage[i].input.height,
         };
         onThisPage.push(place);
         placements.push(place);
       });
-      if (onThisPage.length === 0) {
-        // Unreachable: every cell was proven to fit an empty page above. Kept as
-        // a named stop rather than an infinite loop if that ever stops holding.
-        throw new CompileError(
-          `packing stalled with ${remaining.length} region(s) left and an empty ${pageW}x${pageH} page`,
-        );
-      }
       perPage.push(onThisPage);
+      pageSizes.push({ width: shrunk.width, height: shrunk.height });
       remaining = leftOver;
     }
   }
@@ -779,6 +851,7 @@ export function packAtlas(inputs: PackInput[], opts: PackOptions = {}): PackResu
   const pages: PackedPage[] = [];
   const emitPages: EmitPage[] = [];
   perPage.forEach((onPage, index) => {
+    const { width: pageW, height: pageH } = pageSizes[index];
     const plate = new Plate(pageW, pageH);
     let covered = 0;
     for (const place of onPage) {

package/src/deformgen.ts

@@ -20,7 +20,7 @@
  * author can sweep a parameter, and a reviewer can check a claim instead of a
  * transcription.
  *
- * ## What this is NOT, and the two rules that keep it that way
+ * ## What this is NOT, and the three rules that keep it that way
  *
  * 1. **It never authors.** Every parameter arrives from the spec — the angle,
  *    the radius, the amplitude, the point a scale is about. Nothing here has a
@@ -31,6 +31,14 @@
  *    that key states, and the blend between two keys is still the deform
  *    timeline's own single 0..1 channel. Sweeping an angle is editing one number
  *    per key, never asking the compiler to interpolate a model.
+ * 3. **A parameter that cannot mean what it says is refused by name**, on the
+ *    principle that a parameter changing nothing is a reader's false lead about
+ *    which model produced the numbers: `wavelength: 0`, a determinant at or
+ *    below 0, a radius that falls inside the part. Since issue #350 that extends
+ *    one step later, to a model whose parameters are each legal and whose
+ *    *evaluation* is an all-zero run — the refusal at the bottom of
+ *    `evaluateDeformTransform`, whose whole difficulty is telling that apart
+ *    from a key that means the identity and says so.
  *
  * ## Determinism
  *
@@ -100,12 +108,24 @@ export interface DeformAffine {
   about?: [number, number];
 }
 
-/** A sinusoid of one coordinate, displacing along another. */
+/**
+ * A sinusoid of one coordinate, displacing along another.
+ *
+ * ⚠️ **A wavelength is only as real as the geometry that samples it.** The mesh
+ * carries the wave at the coordinates it happens to have, so a period short
+ * against the spacing of those coordinates does not make a smaller ripple — it
+ * makes a different model. Against a spacing of `s`: `wavelength ≥ 4s` to read
+ * as a wave at all and `≥ 8s` to read as a curve; at `2s` every sample lands on
+ * the same pair of phases, which is a zigzag, and at that pair's zero crossings
+ * it is nothing at all. The last of those is refused (issue #350) because it
+ * emits an all-zero run while claiming an amplitude; the zigzag is not, because
+ * it is a bad wave rather than an absent one and that is authoring judgement.
+ */
 export interface DeformWave {
   kind: 'wave';
   /** Peak displacement, in the attachment's own units. */
   amplitude: number;
-  /** One period, in the same units as the coordinate `along` reads. */
+  /** One period, in the same units as the coordinate `along` reads. Sampled by the geometry — see the note above. */
   wavelength: number;
   /** Phase at `along = 0`, in degrees. Default 0. */
   phase?: number;
@@ -212,6 +232,25 @@ export function evaluateDeformTransform(
   let derived: string[];
   let stated: string;
   let formula: string;
+  // -- the three values the all-zero refusal at the bottom reads (issue #350) -
+  //
+  // `identity` is whether the transform's own scalars state the identity, and it
+  // is judged on the ROUNDED scalars rather than in float64 — a `degrees: 360`
+  // turn leaves `sin t` at −2.4e−16, which is 0 in every number this compiler
+  // writes, so a spec that states a whole revolution states the identity as
+  // surely as `degrees: 0` does. `band` is the largest magnitude the closed form
+  // reached *before* quantising, which is what separates a model that is
+  // arithmetically zero (a band of float noise, ~1e−15) from one that is real
+  // and smaller than six decimals. `sampledTo` is the per-kind diagnosis.
+  let identity: boolean;
+  let identitySpelling: string;
+  let band = 0;
+  let sampledTo = '';
+  const widen = (d: number): number => {
+    const m = Math.abs(d);
+    if (m > band) band = m;
+    return d;
+  };
 
   switch (kind) {
     case 'yaw':
@@ -247,9 +286,14 @@ export function evaluateDeformTransform(
         }
         const z = Math.sqrt(radius * radius - u * u);
         const d = u * cosMinus1 - z * sin;
-        offsets[2 * v + along] = round(d);
+        offsets[2 * v + along] = round(widen(d));
         offsets[2 * v + (1 - along)] = 0;
       }
+      identity = round(cosMinus1) === 0 && round(sin) === 0;
+      identitySpelling = 'degrees 0';
+      sampledTo =
+        `The turn is ${degrees}°, and a projection of it can only vanish where every vertex shares one ` +
+        `${kind === 'yaw' ? 'x' : 'y'} — check that this attachment's setup geometry is the shape the radius says it is`;
       const c = kind === 'yaw' ? 'x' : 'y';
       stated = `radius=${radius} degrees=${degrees}${t.about === undefined ? '' : ` about=${about}`}`;
       formula = `d${c} = (${c}−about)·(cos t − 1) − z·sin t,   z = √(radius² − (${c}−about)²)`;
@@ -275,9 +319,15 @@ export function evaluateDeformTransform(
         );
       }
       for (let v = 0; v < count; v++) {
-        offsets[2 * v] = round((scale[0] - 1) * (setup[2 * v] - about[0]));
-        offsets[2 * v + 1] = round((scale[1] - 1) * (setup[2 * v + 1] - about[1]));
+        offsets[2 * v] = round(widen((scale[0] - 1) * (setup[2 * v] - about[0])));
+        offsets[2 * v + 1] = round(widen((scale[1] - 1) * (setup[2 * v + 1] - about[1])));
       }
+      identity = round(scale[0] - 1) === 0 && round(scale[1] - 1) === 0;
+      identitySpelling = 'scale [1, 1]';
+      sampledTo =
+        `A scale about a fixed point moves nothing that SITS on it, so every vertex this attachment has lies at ` +
+        `about=[${about[0]}, ${about[1]}] on the axis the scale changes — the geometry has collapsed onto the point ` +
+        'the key holds still';
       stated = `scale=[${scale[0]}, ${scale[1]}]${a.about === undefined ? '' : ` about=[${about[0]}, ${about[1]}]`}`;
       formula = 'dx = (sx − 1)·(x − ax),   dy = (sy − 1)·(y − ay)';
       derived = [`sx − 1 = ${round(scale[0] - 1)}`, `sy − 1 = ${round(scale[1] - 1)}`, `det = sx·sy = ${round(det)} > 0, so no triangle can reverse`];
@@ -296,10 +346,30 @@ export function evaluateDeformTransform(
       const k = (2 * Math.PI) / wavelength;
       for (let v = 0; v < count; v++) {
         const d = amplitude * Math.sin(k * setup[2 * v + along] + phaseRad);
-        offsets[2 * v + axis] = round(d);
+        offsets[2 * v + axis] = round(widen(d));
         offsets[2 * v + (1 - axis)] = 0;
       }
       const an = along === 0 ? 'x' : 'y';
+      identity = round(amplitude) === 0;
+      identitySpelling = 'amplitude 0';
+      // The sampling fact, measured off the array this call was handed rather
+      // than inferred from a topology the compiler does not have: it knows which
+      // coordinates it read, not where anybody's rows are. The smallest gap
+      // between two distinct ones is the finest detail the geometry can carry,
+      // and the ratio to it is the rule `gallery/nod`'s README states.
+      const distinct = [...new Set(Array.from({ length: count }, (_, v) => setup[2 * v + along]))].sort((p, q) => p - q);
+      let gap = Infinity;
+      for (let i = 1; i < distinct.length; i++) gap = Math.min(gap, distinct[i] - distinct[i - 1]);
+      sampledTo =
+        distinct.length < 2
+          ? `Every vertex sits at ${an}=${distinct[0]}, so one value of the sinusoid covers the whole attachment and ` +
+            'this phase is where that one value crosses zero. A wave needs the coordinate it reads to VARY across the ' +
+            'geometry; a part that displaces as a whole is a bone, not a deform'
+          : `The closest two distinct ${an} coordinates in this attachment are ${round(gap)} apart, and a sinusoid has ` +
+            `to be sampled to exist: a wavelength of at least 4x that (${round(4 * gap)}) to read as a wave at all and ` +
+            `8x (${round(8 * gap)}) to read as a curve, where this key states ${round(wavelength / gap)}x. At 2x every ` +
+            'sample lands on the same pair of phases, and at the zero crossings that pair is (0, 0). `gallery/nod`\'s ' +
+            'README carries that rule and the measured table behind it';
       stated = `amplitude=${amplitude} wavelength=${wavelength} phase=${phase} along=${an} axis=${axis === 0 ? 'x' : 'y'}`;
       formula = `d${axis === 0 ? 'x' : 'y'} = amplitude · sin(2π·${an}/wavelength + phase)`;
       derived = [`2π/wavelength = ${round(k)} rad per unit`, `phase = ${round(phaseRad)} rad`];
@@ -323,12 +393,26 @@ export function evaluateDeformTransform(
       }
       const [along, axis] = axes(b.along, b.axis, 'bend', where);
       const span = to - from;
+      let reach = 0;
       for (let v = 0; v < count; v++) {
         const u = (setup[2 * v + along] - from) / span;
-        offsets[2 * v + axis] = round(amount * u ** power);
+        if (Math.abs(u) > reach) reach = Math.abs(u);
+        offsets[2 * v + axis] = round(widen(amount * u ** power));
         offsets[2 * v + (1 - axis)] = 0;
       }
       const an = along === 0 ? 'x' : 'y';
+      identity = round(amount) === 0;
+      identitySpelling = 'amount 0';
+      // `u` is 0 at `from` and 1 at `to`, so the two ways a stated bend vanishes
+      // are both statements about where the geometry sits in that span — and
+      // both are measured here rather than guessed.
+      sampledTo =
+        reach === 0
+          ? `Every vertex sits at ${an}=${from}, which is "from" — the end the bend is anchored at, where the ` +
+            'displacement is 0 by construction. The span the key names does not cross the part it is keyed on'
+          : `The furthest any vertex reaches into the span is u=${round(reach)} of 1, and u^${power} of that is ` +
+            `${(reach ** power).toExponential(3)} — so the part occupies only the flat end of the curve. Move "to" to ` +
+            'where the geometry actually ends, or lower the power';
       stated = `amount=${amount} from=${from} to=${to} power=${power} along=${an} axis=${axis === 0 ? 'x' : 'y'}`;
       formula = `d${axis === 0 ? 'x' : 'y'} = amount · u^${power},   u = (${an} − from) / (to − from)`;
       derived = [
@@ -341,6 +425,38 @@ export function evaluateDeformTransform(
     }
   }
 
+  // -- a model the geometry sampled to nothing (issue #350) ------------------
+  //
+  // The three refusals above catch a parameter that cannot mean what it says —
+  // `wavelength: 0`, a determinant at or below 0, a radius inside the part. This
+  // is the same principle one step later: every parameter is individually legal,
+  // and the model still evaluates to a run of zeros. The key then claims a
+  // deformation, emits nothing, and *gates green* — `A35` is right that the run
+  // fits and `A39` is right that no triangle moved, so neither can see it and
+  // this is the only place it can be said.
+  //
+  // ⭐ **The distinguishing condition is where the identity is stated.** A key
+  // that MEANS the setup pose says so in its own parameters — `degrees: 0` (or
+  // any whole revolution), `amplitude: 0`, `amount: 0`, `scale: [1, 1]` — or
+  // carries no run at all, which is the format's own `{ "t": … }`. Those pass.
+  // What is refused is the pair that cannot both be true: parameters that state
+  // a deformation, and an evaluation that is the identity. The two are not the
+  // same event, and before this they printed the same line.
+  //
+  // `count > 0` is not defensive noise: `every` on an empty array is `true`, so
+  // an attachment with no vertices would otherwise be refused with a message
+  // about arithmetic that never ran.
+  if (count > 0 && !identity && offsets.every((d) => d === 0)) {
+    throw new CompileError(
+      `${where}: transform ${kind} states ${stated}, and every one of this attachment's ${count} vertices evaluates ` +
+        `to an offset of 0 — the largest value the closed form reached at any of them is ${band.toExponential(3)}, ` +
+        'which quantises to 0 at the six decimals every emitted number carries. So the key states a deformation and ' +
+        `emits the identity, and nothing downstream can tell it apart from a key that meant the setup pose. ` +
+        `${sampledTo}. A key that MEANS the identity states it in its own parameters (${identitySpelling}) or carries ` +
+        'no run at all.',
+    );
+  }
+
   let maxOffset = 0;
   let maxOffsetVertex = 0;
   for (let v = 0; v < count; v++) {

package/src/trackgen.ts

@@ -79,9 +79,18 @@ export interface TrackDeriveTurn {
   degrees: number;
   /**
    * Each member's depth: `{ member: z }` on a group track, one number on a bone
-   * track. Deeper is further from the viewer, and a **negative** depth is behind
-   * the axis — which is what makes the back of a head swing the other way
-   * (FACE §2).
+   * track. `z` runs **toward the viewer** (FACE §1), so a **larger** depth is
+   * **nearer** — a nose in front of the skull surface takes a bigger number than
+   * the socket beside it — and a **negative** depth is behind the axis, which is
+   * what makes the back of a head swing the other way (FACE §2).
+   *
+   * ⚠️ That sign is the one thing here no assertion can check, and this comment
+   * had it backwards until issue #350's neighbour
+   * ([#351](https://github.com/firejune/rigc/issues/351)). The closed form is
+   * the arbiter: `d = (x−about)·(cos t − 1) − (depth − carried)·sin t` gives a
+   * part with `depth > carried` a **negative** residual, and FACE §3 makes
+   * exactly that the nose diagnostic — *if the nose's residual is not negative,
+   * the depths are wrong*. That only holds if a larger depth means nearer.
    */
   depth: number | Record<string, number>;
   /**

package/src/validate.ts

@@ -32,7 +32,13 @@ import {
   SkeletonJson,
   SliderData,
   TextureAtlas,
+  type TextureAtlasRegion,
 } from '@esotericsoftware/spine-core';
+// ⚠️ `src/` reaches outside itself for exactly two modules and this is one of
+// them, so it is already on `package.json`'s `files` allowlist — see CLAUDE.md.
+// A19 needs the DECODED page, not its header, to measure one region's own
+// rectangle on a shared page.
+import { readPlate } from '../tools/plate.ts';
 import { surveyDeformKeys } from './deformmeasure.ts';
 import { colourTypeName, readPngInfo } from './png.ts';
 import { CHANNELS_BY_KIND, KEY_TIME_EPSILON, walkTimelines } from './timelines.ts';
@@ -1992,31 +1998,83 @@ export function validate(input: ValidateInput): ValidateReport {
           `page "${page.name}" declares ${page.width}x${page.height} but the PNG is ${info.width}x${info.height}`,
         );
       }
-      // 📐 PROFILE, from here down. `pma: false`, one region per page and no
-      // rotation are rigc's atlas CONVENTION, not the atlas format's rules — a
-      // packed page with `rotate: 90` is what the Spine packer produces and
-      // every official example ships one. The convention is what makes the
-      // attachment -> region -> file chain checkable exactly (A27), so it stays
-      // on for spine-html; under `spine` an atlas is judged only on whether its
-      // declared size matches the file it names.
-      //
-      // ⚠️ Since issue #4 rigc can produce a multi-region page itself
-      // (`build --pack`), so this clause is no longer "nobody can have made
-      // this". It is still the convention `spine-html` asks for, and the CLI
-      // therefore refuses `--pack --profile spine-html` by name rather than
-      // letting a legitimate pack arrive here and read as a defect.
+      // 📐 PROFILE, from here down. `pma: false` and no rotation are rigc's atlas
+      // CONVENTION, not the atlas format's rules — a packed page with
+      // `rotate: 90` is what the Spine packer produces and every official example
+      // ships one. Under `spine` an atlas is judged only on whether its declared
+      // size matches the file it names.
       if (policy && page.pma) {
         fail('A06_ATLAS_PAGE_SIZE_MATCHES_PNG', `page "${page.name}" claims premultiplied alpha; parts are straight alpha`);
       }
     }
     if (!policy) return;
+    // ⭐ **One part per page OR a tiling page** (issue #266, follow-up 2). This
+    // clause used to be the first alternative alone — every region's UVs
+    // `(0,0)-(1,1)` — which is rigc's *unpacked* convention and exactly what
+    // `build --pack` stops being true, so `--pack --profile spine-html` had to be
+    // a named CLI refusal. A pack is not a defect, and refusing it under this
+    // profile meant the one shape that exercises the renderer's shared-page
+    // sampling could never be gated by the renderer's own rulebook.
+    //
+    // What the first alternative bought was the attachment -> region -> file
+    // chain being checkable exactly, and `A27` already owns that half and already
+    // stands down on a multi-region page. What is left to check on a *tiling*
+    // page is what makes shared-page sampling well defined at all: every region
+    // wholly inside the page it names, and no two regions on one page
+    // overlapping. Both are conditions a foreign pack can fail while loading
+    // clean — an off-page rectangle samples texels that are not there, and two
+    // overlapping rectangles put one drawing inside another's.
+    //
+    // ⚠️ Rotation stays refused either way, and that is not the same clause: it
+    // is about rigc's own packer never turning a region, and `extractRegion`
+    // refusing to read one back.
+    const regionsPerPage = new Map<string, TextureAtlasRegion[]>();
     for (const region of atlas.regions) {
-      if (region.u !== 0 || region.v !== 0 || region.u2 !== 1 || region.v2 !== 1) {
-        fail(
-          'A06_ATLAS_PAGE_SIZE_MATCHES_PNG',
-          `region "${region.name}" has UVs (${region.u},${region.v})-(${region.u2},${region.v2}); one part per page must cover the page exactly`,
-        );
+      const on = regionsPerPage.get(region.page.name);
+      if (on) on.push(region);
+      else regionsPerPage.set(region.page.name, [region]);
+    }
+    for (const [pageName, on] of regionsPerPage) {
+      const onePartPerPage =
+        on.length === 1 && on[0].u === 0 && on[0].v === 0 && on[0].u2 === 1 && on[0].v2 === 1;
+      if (onePartPerPage) continue;
+      const rects = on.map((region) => ({
+        name: region.name,
+        x: region.x,
+        y: region.y,
+        // spine-core transposes a region's extent at 90 and not at 270 when it
+        // derives the UVs, so the rectangle ON THE PAGE follows the same rule.
+        width: region.degrees === 90 ? region.height : region.width,
+        height: region.degrees === 90 ? region.width : region.height,
+        page: region.page,
+      }));
+      for (const rect of rects) {
+        if (rect.x < 0 || rect.y < 0 || rect.x + rect.width > rect.page.width || rect.y + rect.height > rect.page.height) {
+          fail(
+            'A06_ATLAS_PAGE_SIZE_MATCHES_PNG',
+            `region "${rect.name}" occupies ${rect.x},${rect.y} ${rect.width}x${rect.height} of page ` +
+              `"${pageName}", which is ${rect.page.width}x${rect.page.height} — a region that runs off its page ` +
+              'samples texels that are not there',
+          );
+        }
+      }
+      for (let i = 0; i < rects.length; i++) {
+        for (let j = i + 1; j < rects.length; j++) {
+          const a = rects[i];
+          const b = rects[j];
+          if (a.x < b.x + b.width && b.x < a.x + a.width && a.y < b.y + b.height && b.y < a.y + a.height) {
+            fail(
+              'A06_ATLAS_PAGE_SIZE_MATCHES_PNG',
+              `regions "${a.name}" (${a.x},${a.y} ${a.width}x${a.height}) and "${b.name}" (${b.x},${b.y} ` +
+                `${b.width}x${b.height}) overlap on page "${pageName}"; a page is one part covering it exactly or ` +
+                'a tiling of regions that do not, and two rectangles over the same texels put one drawing inside ' +
+                "the other's",
+            );
+          }
+        }
       }
+    }
+    for (const region of atlas.regions) {
       if (region.degrees !== 0) {
         fail(
           'A06_ATLAS_PAGE_SIZE_MATCHES_PNG',
@@ -2050,10 +2108,14 @@ export function validate(input: ValidateInput): ValidateReport {
     const stageW = skeletonData?.width ?? 0;
     const stageH = skeletonData?.height ?? 0;
     const basePages = new Set<string>();
+    const baseRegions = new Set<string>();
     for (const att of regionAttachments) {
       if (stageW && stageH && att.width >= stageW && att.height >= stageH) {
         const region = atlas.findRegion(att.path || att.name);
-        if (region) basePages.add(region.page.name);
+        if (region) {
+          basePages.add(region.page.name);
+          baseRegions.add(region.name);
+        }
       }
     }
     // The escape hatch is only worth naming when it is reachable: with no stage
@@ -2064,9 +2126,56 @@ export function validate(input: ValidateInput): ValidateReport {
         ? `Only the one image big enough to cover the whole stage (${stageW}x${stageH}) may be opaque.`
         : 'The one image that covers the whole stage may be opaque, but this skeleton declares no stage size, so ' +
           'nothing here qualifies.';
+    // 🚨 Counted per page for the unpacked convention and per REGION on a shared
+    // page, and the split is not a convenience (issue #266, follow-up 2). A
+    // packed page's own file all but always declares transparency — the gutter
+    // and whatever is left over of the page are transparent — so the file-level
+    // question is answered "yes" by the packing itself, whatever the parts on it
+    // look like. Asking it that way once packs became gateable under this profile
+    // would have turned this assertion into a pass that measures nothing, which
+    // is the failure mode this file exists to prevent. So a shared page is opened
+    // and each region's own rectangle is measured instead.
+    const sharedPages = new Map<string, TextureAtlasRegion[]>();
+    for (const region of atlas.regions) {
+      const on = sharedPages.get(region.page.name);
+      if (on) on.push(region);
+      else sharedPages.set(region.page.name, [region]);
+    }
     for (const page of atlas.pages) {
       const abs = resolve(input.atlasDir, page.name);
       if (!existsSync(abs)) continue;
+      const on = sharedPages.get(page.name) ?? [];
+      if (on.length > 1) {
+        // A rotated region is refused by A06 under this profile, so the
+        // rectangle read here is the region's own extent either way; the
+        // transpose is applied so the reading is right even while A06 is
+        // reporting the rotation.
+        const plate = readPlate(abs);
+        for (const region of on) {
+          if (baseRegions.has(region.name)) continue;
+          const width = region.degrees === 90 ? region.height : region.width;
+          const height = region.degrees === 90 ? region.width : region.height;
+          let transparent = false;
+          for (let y = region.y; y < region.y + height && !transparent; y++) {
+            for (let x = region.x; x < region.x + width; x++) {
+              if (x < 0 || y < 0 || x >= plate.width || y >= plate.height) continue;
+              if (plate.get(x, y)[3] < 255) {
+                transparent = true;
+                break;
+              }
+            }
+          }
+          if (transparent) continue;
+          fail(
+            'A19_OVERLAY_PNGS_HAVE_ALPHA',
+            `part "${region.name}" is opaque in every one of its ${width}x${height} texels on shared page ` +
+              `"${page.name}", so it would paint a solid rectangle over whatever is drawn behind it. Re-export ` +
+              `the part with transparency and pack again. ${exemption} This is renderer policy, and it belongs ` +
+              'to --profile spine-html: the default --profile spine does not run this check.',
+          );
+        }
+        continue;
+      }
       const info = readPngInfo(abs);
       if (info.hasTransparency) continue;
       if (basePages.has(page.name)) continue; // full-stage base plate: opaque is correct