spine-rigc 0.34.0 → 0.35.1

package/docs/AUTHORING.md

@@ -328,9 +328,12 @@ when drawing through the pack's own texels is the point.
 ([#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).
+printed in them, with the texel it was measured on named beside it. So are a
+`contour`'s `margin` and `tolerance`
+([#779](https://github.com/firejune/rigc/issues/779)): the trace runs on the
+texels there are, and the two distances are applied on them as `value × scale`
+texels — the scale the header states, never a measured one (below). What stays
+in texels is only what is counted off them: a contour's hole count.
 
 🚨 **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
@@ -396,10 +399,8 @@ compile error carrying `A06`'s whole sentence — ratio and repair — on `expla
 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 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.
+grid need not equal the one the pack the page was halved from reads — and a
+contour's outline is one of them, below.
 
 📐 **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
@@ -417,12 +418,44 @@ the drawing, so that is the step the figure moves in:
 ```
 
 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.
+each. A figure that does not is exact only to that step — a contour at
+`tolerance: 3`, `margin: 4` reads 6.00px on the `scale: 0.5` page (3.00 texels)
+against the full page's 5.39px, 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 `contour`'s `margin` and `tolerance` are the drawing's pixels on every
+page** ([#779](https://github.com/firejune/rigc/issues/779)). They are your
+statement, in the unit every other size in the spec is in, so on a `scale:` page
+the trace applies them as `margin × scale` and `tolerance × scale` texels, and
+`maxVertices` is judged on the outline that asks for. They used to be applied in
+texels unconverted, which asked each page a different question. Measured on
+`halvedMeshPacks`, one spec — `tolerance: 1.5`, `margin: 2`, `maxVertices: 48`:
+
+| page | applied in texels (before) | applied as the drawing's pixels (now) |
+| --- | --- | --- |
+| declared size | 15 vertices | **15** vertices, the same mesh |
+| `scale: 2` | refused: `simplified to 66 vertices at tolerance 1.5, past the 48` | **15** vertices, the declared outline to 0.00px |
+| `scale: 0.5` | 11 vertices, 4.20px from the declared outline | refused: the outline crosses itself after a margin of 2px, applied as 1 texel |
+
+A **finer** page resolves everything the declared one does, so it traces the
+declared outline, vertex for vertex. A **coarser** one holds less: its silhouette
+is a staircase of texels 2px of the drawing apart, and a tolerance under one texel
+keeps the steps — which is what the declared page does too at a tolerance under
+one of *its* pixels (at `tolerance: 0.75` it keeps 66 vertices, and given the
+budget for them it is refused by the same crossing). So
+on a coarser page, ask for a tolerance of at least a texel, or supply the loose
+art; the spec above at twice its figures traces 11 vertices there against the
+declared page's 10, 3.69px apart. Every refusal a trace raises on a `scale:` page
+names the figure the spec states, the texels it was applied as and the scale:
+
+```bash
+# rigc compile error: skin "default" slot "blob" attachment "blob": the outline crosses itself: edge 8 meets edge 10
+#   after a margin of 2px (the drawing's pixels — applied as 1 texel(s) of this page, whose scale: 0.5 makes a texel
+#   2.00px of the drawing) was pushed out of a silhouette narrower than that — lower the margin, or the art has a
+#   neck too thin to mesh
+```
 
 🚨 **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
@@ -904,11 +937,27 @@ one A09 does compare.
 
 ## 2. The rules that decide what lands in the file
 
-**R1 — A field is emitted exactly when you declare it.** Not "when it differs from
-the default". Spine's own exporter omits anything equal to a default; rigc cannot,
-because a rig may need to say `x: 0` out loud and because deciding emission from
-the *value* would make the file depend on arithmetic rather than on what you wrote.
-Omit a field and Spine's default stands; write it and it is in the file.
+**R1 — A field is emitted when you declare it, and left out where the parser would
+read the same value without it.** Omit a field and Spine's default stands; write it
+and it reaches the file — unless what you wrote **is** that default, in which case
+the emitter leaves it out, the way the editor's own exporter does (issue
+[#716](https://github.com/firejune/rigc/issues/716)). Writing `x: 0` is still
+legitimate, and your spec still says it: the spec is the record of what you wrote,
+and the file is what the runtime reads. The two cannot disagree about a value,
+because a key is left out only where the 4.3 parser loads the same `SkeletonData`
+without it — exact equality with the float the file would hold, so `x: 1e-45` is
+written — and the selftest loads every build both ways to hold that (§10.6c).
+
+⚠️ This rule said *"not 'when it differs from the default'"* until #716, on two
+grounds: that a rig may need to say `x: 0` out loud, and that deciding emission from
+the value would make the file depend on arithmetic. Neither survived being measured.
+What reads the file is the 4.3 parser, which reads the absent key as the same number,
+and the editor, whose own export leaves the same key out — so there is nobody to say
+it out loud *to*; and the decision is an exact comparison with the parser's fallback,
+which is not arithmetic in any sense a reader has to redo. What the
+old rule cost was concrete: a rebuild of an editor export restated **2,338** keys the
+export leaves to the parser, so `ingest → build` could never give an editor's file
+back.
 
 **R2 — The compiler never invents a value.** No defaults guessed from the art, no
 re-measured plates, no reasonable fallbacks. A missing number is a `CompileError`
@@ -996,6 +1045,15 @@ page:
 | leaves a remaining **tie in the order your file declares it** | `turn` before `Turn`; `Mango` before `mango` — each given in that order and returned in it |
 | writes **leaves then folders at the root**, and **sub-folders then leaves inside a folder** | `h` before `f/sub1/deep/q`; `f/sub1/x` before `f/leafA` |
 
+🔸 **One clause of the rule is not from those files.** Before comparing, the
+comparator reads U+3000 IDEOGRAPHIC SPACE as a space and the full-width digits
+U+FF10–U+FF19 as `0`–`9`. No probe carried either; the fold was measured on a
+production skin's slot keys ([#791](https://github.com/firejune/rigc/issues/791),
+§10.6b says what was measured and why it is those two classes and not NFKC), and
+it applies here because R10, R11 and a skin's slot keys are one comparator. So
+`shot２` sorts before `shot10`, and a pair an ideographic space decides is
+ordered rather than refused as `separator`.
+
 ⭐ **A tie is not an ambiguity, and that is what retired most of this rule's
 refusals.** Two names the comparator cannot separate come back in the order the
 file gave them, so the order rigc emits for such a pair is **your own declaration
@@ -1082,6 +1140,7 @@ is recorded in `bench/runs/README.md`, *What a run may read*.)
 | `fps` | nonessential editor hint | `SkeletonData.fps` stays 30 |
 | `referenceScale` | 4.2+ physics/scale reference | parser default 100 |
 | `images` | where the editor's import looks for the part PNGs, as a path from the skeleton file | **written for you**: under `--copy-images` the `--out` directory itself, spelled `../<its basename>/` (a literal `./` is dropped by the editor on import; a named directory is kept and every part is found — measured on 4.3.23); otherwise the relative path from `--out` to the one directory the spec names every part PNG in (the rig's images directory, or the manifest's plates). A declared value is carried through verbatim — and overridden by `--copy-images`, which moved the parts. Parts spread over several directories have no single true path, so nothing is written (issue #370) |
+| `audio` | nonessential: where the editor looks for the skeleton's audio files, as a path from the skeleton file — a string, or `null` for none | **not written unless you state it.** rigc has no audio to point at, so this is a value a spec states or does not; stated, it is carried verbatim, `null` included, because `null` is what an editor export writes when no audio folder is set (all twelve under `examples/` do) and `ingest` carries it from there ([#716](https://github.com/firejune/rigc/issues/716)). Anything but a string or `null` is a compile error naming the value |
 
 `spine` and `hash` are not yours to write: rigc emits its own version label
 (`A16` re-checks it is on the 4.3 line) and inventing a hash would claim an export
@@ -1769,9 +1828,9 @@ included, because without it the generator is refused (issue #274). The
 
 | Field | Meaning |
 | --- | --- |
-| `tolerance` | **required.** Douglas-Peucker tolerance, in part pixels. Bigger spends fewer vertices and cuts more corners |
-| `margin` | how far the outline is pushed out past the traced silhouette, in pixels. Default `1` |
-| `maxVertices` | refuse rather than emit more outline vertices than this. Default `64` |
+| `tolerance` | **required.** Douglas-Peucker tolerance, in the drawing's pixels — on a packed page that declares a `scale:`, applied as `tolerance × scale` of its texels (§0.2, [#779](https://github.com/firejune/rigc/issues/779)). Bigger spends fewer vertices and cuts more corners |
+| `margin` | how far the outline is pushed out past the traced silhouette, in the drawing's pixels (`margin × scale` texels on a `scale:` page). Default `1` |
+| `maxVertices` | refuse rather than emit more outline vertices than this — judged on the outline the two distances above ask for, so a finer `scale:` page of the same art needs no bigger budget. Default `64` |
 | `alpha` | the alpha at or above which a pixel counts as art, `1`..`255`. Default `1` — any pixel that is not fully transparent |
 
 The numbers above are invented, and the pair that matters is `tolerance` and
@@ -1821,6 +1880,7 @@ mesh rather than a rim prefix, and `A28_RIBBON_ROWS_SHARE_WEIGHTS` **SKIPs** wit
 | a neck narrower than `margin` | `the outline crosses itself: edge 0 meets edge 3 after a margin of 3px was pushed out of a silhouette narrower than that` |
 | more outline than `maxVertices` | `the silhouette simplified to 15 vertices at tolerance 1.5, past the 4 this mesh allows` — refused, never silently decimated |
 | a `margin` too small for the `tolerance` | `the mesh covers 91.81% of the art (2936 of 3198 px), under the 99.5% a contour mesh guarantees` |
+| any of the three above, on a packed page that declares a `scale:` | `…after a margin of 2px (the drawing's pixels — applied as 1 texel(s) of this page, whose scale: 0.5 makes a texel 2.00px of the drawing) was pushed out…` — the spec's figure, the texels the trace ran it at, and the scale that converted it; a count of the part's cells says `texels` there. A tolerance under one texel of a coarser page keeps its stair steps, as one under a pixel does on the declared page (§0.2) |
 
 That last one is the guarantee: **the emitted triangles cover at least 99.5% of
 the art**, measured by rasterising them back over the mask, and a build that would
@@ -2526,6 +2586,13 @@ carrying here:
 Every constraint may also carry `skin: true`, which makes it run only under the skin
 that lists it — see §3.4.1, and note that the flag alone does nothing.
 
+🎛️ **An ik or transform whose mix a game sets from code has no field here**, and
+that is deliberate. Every key on a constraint object is a Spine field the emitter
+writes; a statement to the gate about who turns the dial is what the artifact cannot
+say about itself, so it lives in `invariants.consumerDrivenMix` (§3.7), beside
+`deformMayFold` — the one other exemption from a named rule, which names its subject
+the same way ([#784](https://github.com/firejune/rigc/issues/784)).
+
 #### 3.5.1 `path` — bones that travel along a curve
 
 **When you need one:** anything that moves *along* something rather than around a
@@ -3075,7 +3142,8 @@ is not an array. Every field is optional and each is the payload a firing
 
 Optional with one exception, and only meaningful for rigc's own formations:
 `meshSlots` and `meshTriangles` (the two halves of the mesh budget `A13` measures
-against), `axisBone`, `massBone`, `detached`, `deformMayFold`, `editorRoundTrip`.
+against), `axisBone`, `massBone`, `detached`, `deformMayFold`, `editorRoundTrip`,
+`consumerDrivenMix`.
 Nothing in skeleton
 JSON records that a
 bone carries a cut's axis or that a parentage is forbidden, so the rig spec says it
@@ -3083,7 +3151,10 @@ and the validator's archetype assertions read it. **An assertion whose field is
 absent reports SKIP, never a pass.** If you are reproducing a foreign skeleton,
 leave this out entirely and run `--profile spine` — and expect `PROF` rather than
 that SKIP, because the profile excludes an archetype assertion before its body
-could notice the missing field (§5.2).
+could notice the missing field (§5.2). The one field `ingest` writes is
+`consumerDrivenMix`, and only for a constraint the file rests muted and never keys
+up, each with a `CONSUMER_DRIVEN_MIX` finding ([INGEST.md](INGEST.md) §2.0) — see
+the last block of this section.
 
 🚨 **The exception: `meshSlots` is required by a rig that invokes a mesh
 generator** (`ring`, `ribbon`, `contour`, `grid` — §3.4), and it is a **compile-time**
@@ -3108,8 +3179,9 @@ loads and still animates and merely lies — something released into the world t
 must not ride the part that released it. [RIGGING.md](RIGGING.md) §10.3 has a
 worked one.
 
-🚨 **`deformMayFold` is the one field here that turns a check OFF**, so it is the
-one field whose own shape is refused rather than skipped. It is
+🚨 **`deformMayFold` is one of the two fields here that turn a check OFF**
+(`consumerDrivenMix`, below, is the other), so it is held to a shape that is
+refused rather than skipped. It is
 `[{ "slot": …, "why": … }]`, it exempts that slot from
 `A39_DEFORM_KEEPS_TRIANGLE_WINDING`, and three shapes are compile errors: a slot
 the rig does not declare, a slot that carries no mesh, and a missing or blank
@@ -3166,6 +3238,29 @@ drawn and are gated (§4.11.3); this used to be a rule you had to follow and is
 now one the gate keeps
 ([#403](https://github.com/firejune/rigc/issues/403)).
 
+🎛️ **`consumerDrivenMix` names the ik and transform constraints whose mix the
+CONSUMER sets** — from code, at runtime — rather than any animation in this file
+([#784](https://github.com/firejune/rigc/issues/784)). It is
+`[{ "constraint": …, "type": "ik" | "transform", "why": … }]`, and it exempts that
+constraint from `A47_IK_CONSTRAINT_NOT_MUTED_THROUGHOUT` or
+`A48_TRANSFORM_CONSTRAINT_NOT_MUTED_THROUGHOUT` (§4.12). A constraint resting muted
+that nothing keys up is either a leftover or a dial a game turns, the two export as
+the same bytes, and the gate refuses the shape because nothing *in the file* ever
+moves it — this is the statement that something outside it does, the rig-side
+spelling of `gallery/look`'s rule that a face angle is a value rather than a time.
+
+- `type` is required because a constraint's name is unique **per kind** — an ik and
+  a transform may share one — so a name alone could exempt two constraints.
+- Five shapes are compile errors, each by name: a constraint the rig does not
+  declare under that `type`, a `type` other than `ik` or `transform` (a physics,
+  path or slider constraint has its own muted-at-rest rule — `A23`, `A36`, `A37` —
+  and none of them reads this declaration, so the entry would exempt nothing), the
+  same constraint twice, a missing or blank `why`, and a key the entry does not have.
+- ⛔ A declared constraint the file **also** switches on — resting live, or keyed
+  above 0 — is refused at the gate: the declaration exempts nothing there.
+- What it buys is a **SKIP by name, never a pass** (§4.12 has the line). The
+  declaration is a statement to the gate and changes no emitted byte.
+
 ---
 
 ## 4. The motion spec, field by field
@@ -4059,8 +4154,11 @@ here was measured off a real rig. Copy the shape, not the values.
   rebuilds with `bendPositive: false` on every key if the flag is left silent,
   and with `true` — what the source plays — when `ingest` writes it out. So
   `ingest` restates every field any key of a track names, at the parser's default
-  where the source omits one, and records a `CONSTRAINT_KEY_RESTATED` finding. On
-  rigc's own output the two agree and the round trip is byte-identical.
+  where the source omits one — in the **spec**. The emitter then leaves each such
+  value out of the file again wherever it is the one the parser reads without it
+  (§10.6c), so the rebuild is the source's own text, and `CONSTRAINT_KEY_RESTATED`
+  is printed only for a value the file would still carry. On rigc's own output the
+  two agree and the round trip is byte-identical.
 - `mix` outside `0..1` is a compile error: `IkConstraintPose.mix` is documented as
   a percentage. A **transform** mix is documented *unbounded*, which is why §4.10
   has no such rule — the asymmetry is the runtime's, not ours.
@@ -4082,6 +4180,13 @@ rigc refuses four things here:
 | `softness` on the first key only | `key 0 names "softness" and key 1 (t=…) does not … it would snap to 0` |
 | `mix: 1.5` | `mix is 1.5, outside 0..1 — the runtime documents it as a percentage 0-1` |
 
+🎛️ **A constraint this section never keys** — resting at `mix` 0 with no `ik` track
+in any animation lifting it — is refused by `A47` with three doors: rest it above 0,
+key it here, or declare that the consumer drives its mix in the rig spec's
+`invariants.consumerDrivenMix` (§3.7), for an ik a game turns on from code. The
+third is a statement about the object, not a way past the gate: what it buys is a
+SKIP by name (§4.12).
+
 The type check matters because the parser resolves a timeline's target by name
 **and** type: `findConstraint(name, IkConstraintData)` misses a transform
 constraint of the same name, returns null, and `readAnimation` throws — in the
@@ -4141,7 +4246,10 @@ exactly what a mix that was 0 at setup needs said.
   omitted mix as 1, so a key of `mixRotate: 0` alone on a rotate-only constraint
   carries five mixes of 1 that nothing reads. `A48` judges only the mixes of the
   properties the constraint drives (§4.12).
-- The refusals are §4.9's, with `transform` in place of `ik`.
+- The refusals are §4.9's, with `transform` in place of `ik` — and so is the third
+  door: a transform resting muted on every mix it reads that no key here lifts is
+  refused by `A48` with *rest it above 0, key it, or declare that the consumer drives
+  its mix* in `invariants.consumerDrivenMix` (§3.7, §4.12).
 
 ### 4.11 `deform` — moving an attachment's vertices
 
@@ -5049,8 +5157,36 @@ rescue and a 0-only timeline is not, with two differences that are the runtime's
 
 `ik constraint "reach" has mix 0 at setup and none of the 1 animation keys its mix
 above 0; update() returns on mix 0, so "upper" never reaches for "goal" — rest it
-above 0, or key its mix above 0 in an animation`. A rig resting at 0 and keyed up by
-the animation that needs it — spineboy's aim — is refused by neither.
+above 0, or key its mix above 0 in an animation, or declare that the consumer drives
+its mix, in the rig spec as invariants.consumerDrivenMix: [{ "constraint": "reach",
+"type": "ik", "why": … }]`. A rig resting at 0 and keyed up by the animation that
+needs it — spineboy's aim — is refused by neither.
+
+🎛️ **The third door is for a dial the file cannot show turning**
+([#784](https://github.com/firejune/rigc/issues/784)). A constraint resting muted
+that nothing keys up is either a leftover or a mix a game sets from code, and the two
+export as the same bytes — a production skeleton's rebuild was refused for exactly
+that, over an ik its game switches on at runtime. `invariants.consumerDrivenMix`
+(§3.7) is the statement the file cannot make, and what it buys is a **SKIP by name,
+never a pass**: the file still shows nothing moving the constraint.
+
+```
+  SKIP  A47_IK_CONSTRAINT_NOT_MUTED_THROUGHOUT: every ik constraint here is declared in the rig spec as invariants.consumerDrivenMix, so its mix is the consumer's to set and nothing in this file shows it moving — "reach" (why: a game turns it on from code): it rests muted and none of the 1 animation keys its mix above 0
+```
+
+- **Beside a live constraint of the same kind** the live one is still measured, so
+  the rule PASSes and the build's stats line names the declared one
+  (`ikConsumerDriven=reach`, `transformConsumerDriven=…`) — `A39`'s shape for
+  `deformMayFold`. A SKIP there would print "nothing measured" over a rule that
+  measured one.
+- ⛔ **A declared constraint the file also switches on is refused** — resting live,
+  or keyed above 0 by any animation — because the declaration exempts nothing
+  there: the gate passes it without one. [measured] an ik keyed at mix 0.5 with code
+  writing 1: written before `state.apply` it is overwritten (applied 0.5), written
+  after it wins (1.0). Which of the two authors holds a frame is the order of the
+  consumer's own loop, which is the scene's, not the object's.
+- `validate <dir>` has no rig spec and so no declaration: a muted constraint there
+  is refused with all three doors.
 
 ### 4.13 `sequence` — which frame of a numbered series shows
 
@@ -5499,7 +5635,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 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)) |
+| `A19_OVERLAY_PNGS_HAVE_ALPHA` | renderer | an overlay part cannot draw a transparent pixel, so it would paint a solid rectangle over what is behind it. **The texels decide, on both routes** ([#777](https://github.com/firejune/rigc/issues/777)); the file header is only the fast negative. A file with no alpha channel (colour type 4 or 6) and no `tRNS` chunk has nowhere to keep a clear texel and is refused without being opened, by a sentence that names its colour type — so re-export it as RGBA, or as an indexed / greyscale PNG that keeps its `tRNS`. A file whose header says it **could** be transparent is opened and read until its first texel below full alpha; one clear texel passes, and none is refused in the words the packed route uses for a region, naming the file and what it can hold — `is opaque in every one of its 200x80 texels` … `its file can hold transparency — colour type 6 (truecolour + alpha) carries an alpha channel — and no texel uses it`. Saving as RGBA is not the repair: the runtime draws the texels, not the declaration. Until #777 the loose route stopped at the header, so the same fully opaque RGBA part passed a loose build and was refused by `--pack` of the same rig. On a loose page the file is the part, so the whole decoded image is the rectangle and no atlas coordinate is read. 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)) |
@@ -5527,8 +5663,8 @@ Fix A00 and run it again ([#568](https://github.com/firejune/rigc/issues/568)).
 | `A44_LINKED_MESH_STATES_NO_GEOMETRY_OF_ITS_OWN` | both | a **linked mesh** (§3.4) — `type: "linkedmesh"`, or a `type: "mesh"` carrying `source` — that also states `uvs`, `triangles`, `vertices`, `hull` or `edges`. The parser returns from the `source` branch before `readVertices` (`SkeletonJson.ts:582-586`), so those keys are read by **nothing at all** and `setSourceMesh` fills the attachment with the source's arrays instead: the file says one mesh and every runtime draws another, in silence. The detail names the attachment by skin, slot and placeholder, every key it states, the `source` and where the parser looks for it — the two defaults spelled out, because an omitted `skin` is the **default** skin rather than the one the link is written in — and the shape the keys describe beside the shape the attachment loaded. ⚠️ **`width`/`height` are not part of this.** `setSourceMesh` overwrites both with the source's, so they are as dead at runtime — but the parser reads them (`:569-570`), the format carries them on a link and rigc emits them, so refusing them would refuse every link rigc writes (§3.4). `compile.ts` refuses the same shape outright in a rig rigc builds (§5.1); this is that fact held against a skeleton it did not write, and `ingest` reports it as `ATTACHMENT_LINK_GEOMETRY` ([INGEST §2.0](INGEST.md)). **SKIP** when no attachment in the skeleton takes its geometry from another — which is almost every skeleton, so a pass here means a link was read ([#710](https://github.com/firejune/rigc/issues/710)) |
 | `A45_SEPARABLE_COLOR_TIMELINES_OWN_THEIR_CHANNELS_AND_POSE_AS_WRITTEN` | both | an `rgb` or `alpha` timeline (§4.4) the runtime does not hold as the file states it, in one of two shapes that both parse in silence. **A channel keyed twice**: another colour timeline of the same slot in the same animation poses a channel this one poses — `rgba` beside `alpha` is the shape a converter leaves when it writes a separable `rgb` back as `rgba` next to the `alpha` it kept. Every colour timeline poses its channels at every time, the setup value before its first key included, so the one the file states later overwrites the other everywhere; the detail names both timelines, the channel, and which one survives. **A key not posed as written**: the animation is stepped to each key's own time — at the key **as the runtime stores it**: spine-core keeps key times as 32-bit floats, so a key at `0.2` is posed at `0.20000000298…`, the later of the two, and not one float step before it, where a first key still shows the setup value and a stepped key the one before (a correct file was refused that way until [#771](https://github.com/firejune/rigc/issues/771)), and the posed r g b (for `rgb`, against the hex, to half a quantisation step) or alpha (for `alpha`, against `value`, whose absence the parser reads as 0) is compared — a colour that is not six hex digits loads as NaN, and a key whose time another key repeats is read by nothing. ⚠️ An `rgb` alone written as an `rgba` holding the setup alpha is **not** caught and cannot be from the file: it is a correct `rgba`, and the difference shows only under another track that moves the alpha. The loaded timeline class and the channels a separable timeline leaves alone are measured in the selftest (`S83`–`S85`) rather than here, because against the linked parser neither can come out wrong. The channel table is `SLOT_COLOR_CHANNELS` in `src/timelines.ts`, shared with the compiler's refusal and held to the runtime's own property ids (`S89`). **SKIP** when no animation keys an `rgb` or `alpha` — there is then no separable slot colour to read back |
 | `A46_SEQUENCE_ATTACHMENTS_SHOW_THE_FRAME_THE_FILE_STATES` | both | a **numbered series** (§3.4.3, §4.13) that the runtime does not show as the file states it. Every shape below loads without a word, measured on spine-core 4.3.13 ([#729](https://github.com/firejune/rigc/issues/729)). **The block**: a `sequence` with no `count` (`readSequence` reads 0, and the attachment holds no region) or a `setup` at or past `count` (`Sequence.resolveIndex` clamps it to the last frame). **The keys**: a `mode` outside the seven — `hold`, `once`, `loop`, `pingpong`, `onceReverse`, `loopReverse`, `pingpongReverse` — loads as `hold`; an `index` that is fractional (`index << 4` truncates it) or past the end (clamped); an advancing mode at an effective delay of 0 (the parser carries a key's `delay` from the key before; `(time - keyTime) / 0` is Infinity and `Infinity \| 0` is 0, so it never advances); a timeline on an attachment that carries no block (the parser gives every region a one-region series, so every mode shows it). **The pose**: every key is stepped to mid-frame sample times — enough to wrap every mode, and a `hold` key to its own time as the runtime stores it, a 32-bit float ([#771](https://github.com/firejune/rigc/issues/771)) — and the region the slot shows is held to the frame the file's own statement gives, the arithmetic of `SequenceTimeline.applyToSlot` and the names of `Sequence.getPath` transcribed rather than read off the loaded timeline, so the check is not the runtime agreeing with itself. Before the first key the frame is `setup`. ⚠️ A sample where the slot shows another attachment is not compared, because the runtime writes nothing there; a timeline with no comparable sample is counted in `stats.sequenceSamplesUnshown`. `compile.ts` refuses every one of these shapes in a spec (§5.1); this is them held against a skeleton it did not write. **SKIP** when no attachment carries a `sequence` block and no animation keys a `sequence` timeline |
-| `A47_IK_CONSTRAINT_NOT_MUTED_THROUGHOUT` | both | an ik constraint resting at `mix` 0 that no animation keys **away from 0** (§4.9, §4.12). `IkConstraint.update` returns on `mix === 0`, so it sits in the update cache and moves nothing. The keys are read the way `A23`/`A36`/`A37` read theirs — every value the loaded timeline poses on its `mix` channel, Bezier samples included — so a timeline keying 0 only is no rescue: [measured] it poses every bone exactly where the same rig with no constraint does, and before [#765](https://github.com/firejune/rigc/issues/765) it passed. Live is the runtime's `!== 0`, so a negative mix is not refused. `ik constraint "C" has mix 0 at setup and none of the 1 animation keys its mix above 0; update() returns on mix 0, so "upper" never reaches for "goal" — rest it above 0, or key its mix above 0 in an animation`. **SKIP** when the skeleton declares no ik constraint |
-| `A48_TRANSFORM_CONSTRAINT_NOT_MUTED_THROUGHOUT` | both | a transform constraint none of whose mixes **for a property it drives** is away from 0 at setup or on any value an animation poses (§4.10, §4.12), or one whose `properties` name no `to` at all. A property is applied only when its own mix `!== 0`, and a key that omits a mix reads it as 1, so the six-mix early return of `TransformConstraint.update` would take a key of `mixRotate: 0` alone as a rescue — [measured] that key, and one keying `mixX` 1 on a rotate-only constraint, pose every bone exactly where no constraint does ([#765](https://github.com/firejune/rigc/issues/765)). A negative mix runs, and five transforms in the editor's example exports rest at −1. `transform constraint "C" drives rotate and has mixRotate 0 at setup, and none of the 1 animation keys its mix above 0; a mix is read only for a property the constraint drives, and update() skips each one at 0, so nothing ever moves "follower" — rest mixRotate above 0, or key its mix above 0 in an animation`. **SKIP** when the skeleton declares no transform constraint |
+| `A47_IK_CONSTRAINT_NOT_MUTED_THROUGHOUT` | both | an ik constraint resting at `mix` 0 that no animation keys **away from 0** (§4.9, §4.12). `IkConstraint.update` returns on `mix === 0`, so it sits in the update cache and moves nothing. The keys are read the way `A23`/`A36`/`A37` read theirs — every value the loaded timeline poses on its `mix` channel, Bezier samples included — so a timeline keying 0 only is no rescue: [measured] it poses every bone exactly where the same rig with no constraint does, and before [#765](https://github.com/firejune/rigc/issues/765) it passed. Live is the runtime's `!== 0`, so a negative mix is not refused. `ik constraint "C" has mix 0 at setup and none of the 1 animation keys its mix above 0; update() returns on mix 0, so "upper" never reaches for "goal" — rest it above 0, or key its mix above 0 in an animation, or declare that the consumer drives its mix, in the rig spec as invariants.consumerDrivenMix: [{ "constraint": "C", "type": "ik", "why": … }]`. A constraint the rig spec declares in `invariants.consumerDrivenMix` (§3.7) is not measured, and one the file also switches on is refused: `ik constraint "C" is declared in the rig spec as invariants.consumerDrivenMix, and the file already switches it on — … — so the declaration exempts nothing; drop the entry` ([#784](https://github.com/firejune/rigc/issues/784)). **SKIP** when the skeleton declares no ik constraint, and **SKIP by name** when every ik constraint it declares is declared consumer-driven: `every ik constraint here is declared in the rig spec as invariants.consumerDrivenMix, so its mix is the consumer's to set and nothing in this file shows it moving — "C" (why: …): it rests muted and none of the 1 animation keys its mix above 0`. With a live one beside it the rule measures that one and the stats line names the declared (`ikConsumerDriven`) |
+| `A48_TRANSFORM_CONSTRAINT_NOT_MUTED_THROUGHOUT` | both | a transform constraint none of whose mixes **for a property it drives** is away from 0 at setup or on any value an animation poses (§4.10, §4.12), or one whose `properties` name no `to` at all. A property is applied only when its own mix `!== 0`, and a key that omits a mix reads it as 1, so the six-mix early return of `TransformConstraint.update` would take a key of `mixRotate: 0` alone as a rescue — [measured] that key, and one keying `mixX` 1 on a rotate-only constraint, pose every bone exactly where no constraint does ([#765](https://github.com/firejune/rigc/issues/765)). A negative mix runs, and five transforms in the editor's example exports rest at −1. `transform constraint "C" drives rotate and has mixRotate 0 at setup, and none of the 1 animation keys its mix above 0; a mix is read only for a property the constraint drives, and update() skips each one at 0, so nothing ever moves "follower" — rest mixRotate above 0, or key its mix above 0 in an animation, or declare that the consumer drives its mix, in the rig spec as invariants.consumerDrivenMix: [{ "constraint": "C", "type": "transform", "why": … }]`. A constraint the rig spec declares in `invariants.consumerDrivenMix` (§3.7) is not measured, and one the file also switches on is refused as `A47`'s is; one that drives no property is refused with its own sentence declared or not, since no mix it carries is read by anybody ([#784](https://github.com/firejune/rigc/issues/784)). **SKIP** when the skeleton declares no transform constraint, and **SKIP by name** when every transform constraint it declares is declared consumer-driven: `every transform constraint here is declared in the rig spec as invariants.consumerDrivenMix, so its mix is the consumer's to set and nothing in this file shows it moving — "C" (why: …): it rests muted and none of the 1 animation keys its mix above 0`. With a live one beside it the stats line names the declared (`transformConsumerDriven`) |
 
 `both ◑` marks a mixed assertion: its validity half always runs and its policy
 clauses are gated by profile.
@@ -7167,8 +7303,9 @@ about your bone tree rather than about a hole in your figure.
 
 Every reference in this repository was made in the Spine editor by a person, and a
 rig authored here is measured against one. rigc's own defaults are deliberately
-*absent* rather than opinionated (R1: a field is emitted exactly when you declare
-it), so nothing in the compiler will push you toward the shape an editor rig has.
+*absent* rather than opinionated (R1: a field reaches the file when you declare it,
+and nothing you did not declare is supplied), so nothing in the compiler will push you
+toward the shape an editor rig has.
 This section is that push, and it comes from **Spine's public documentation only** —
 what the editor does when nobody tells it otherwise, and what its user guide
 recommends.
@@ -7274,10 +7411,16 @@ population is every object the format keys by a name and that carries more than
 one key, deform blocks counted at each of their three levels;
 [`src/compile.ts`](../src/compile.ts) states it in full beside
 `editorAnimationOrder`, so the count can be re-taken rather than trusted.)
-⇒ in rigc: only `animations` is emitted sorted (R10), because it is the one
+⇒ in rigc: `animations` is emitted sorted (R10), because it is the one
 object measured here whose ORDER is also an index space — every reference into
 the re-sorted *other* objects is by name on both sides, so nothing moves when
-they are re-keyed. rigc emits **that comparator's own order**, which
+they are re-keyed. ⚠️ Since [#716](https://github.com/firejune/rigc/issues/716)
+a skin's `attachments` slot keys are emitted sorted too, for the **text** and
+for no reference: a rebuild of an editor export is the export only if it is the
+same text (§10.6b), and 11 of the twelve under `examples/` keyed a skin in draw
+order where the export sorts it. Nothing is refused on that map — a pair the
+comparator leaves open, or a slot name with a `/` in it, keeps the whole map in
+rigc's order instead. rigc emits **that comparator's own order**, which
 [#728](https://github.com/firejune/rigc/issues/728) then measured in full off five
 stored round trips (R10) rather than quantifying over a family. Sorting the
 105 collections that way reproduces **105 of 105**, the three codepoint cannot
@@ -7808,11 +7951,20 @@ either.
 *"assume … if omitted"* default — the same fact R5 states from the parser's side:
 omit them in raw JSON and every UV collapses, in silence. Name an `image`.
 
-⚠️ **Do not imitate the exporter's omissions.** Spine's exporter drops fields equal
-to their default, which is why the format page is a long list of *"assume 0 if
-omitted"* — and **rigc deliberately does the opposite** (R1, §2). Writing `x: 0` is
-legitimate here. The habit worth carrying over is not *omit defaults*, it is
-*declare only what the shot needs*.
+✅ **You need not imitate the exporter's omissions — the emitter does it for you.**
+Spine's exporter drops fields equal to their default, which is why the format page is
+a long list of *"assume 0 if omitted"*, and since
+[#716](https://github.com/firejune/rigc/issues/716) rigc's emitter drops the same
+ones (R1, §2; the table is §10.6c). So an author may still state a default — `x: 0`
+in a rig spec is legitimate and stays in the spec — and the file leaves it out.
+⚠️ This paragraph said *"do not imitate the exporter's omissions … rigc deliberately
+does the opposite"* until then. The advice was re-derived rather than kept: **the
+round trip is the reason.** A rebuild of an editor export that writes back every
+default the export left out is a different file from the export in 2,338 places over
+the twelve under `examples/`, and one that leaves them out is the export's own text
+apart from the header's `hash` and `spine` (`IG83`, and [INGEST §2.3](INGEST.md)).
+The habit worth carrying over is still not *omit defaults* — it is *declare only what
+the shot needs*; what changed is that stating a default costs nothing in the file.
 
 ### 10.6 What a round trip gives back
 
@@ -7834,7 +7986,12 @@ comes back `48.0`) and **omitted defaults** — the export drops any field equal
 its parser default, so the header loses `x: 0` and `y: 0`, a bone loses `x: 0`, and
 a key at t=0 loses its `"time": 0`. Every name-keyed object is also re-sorted, per
 §10.1. None of those is a loss of information, and each is worth knowing before
-you read a `diff`.
+you read a `diff`. 🔁 Since [#716](https://github.com/firejune/rigc/issues/716) the
+bone's `x: 0` and the key's `"time": 0` are left out by rigc as well (§10.6c); the
+header's origin is not, because the 4.3 JSON reader has no default for it
+(`skeletonData.x = skeletonMap.x`, `SkeletonJson.js:70`), so an absent origin loads
+as `undefined` where a written one loads as `0` — writing it is exact for both
+readers, and leaving it out would move a loaded value.
 
 ⚠️ Read every line below as *this construct survived*, never as *this construct is
 recommended*. §10.1–§10.5 are the recommendations; this subsection is only the
@@ -7946,6 +8103,223 @@ identical** on an emitted array all three of whose numbers moved. ⇒ Read a
 `lengths` disagreement as *certainly wrong data, and visible only under
 `positionMode: fixed`*.
 
+### 10.6b The order it writes keys in
+
+🔬 **The editor writes every object's keys in one fixed order per kind of
+object**, and since [#716](https://github.com/firejune/rigc/issues/716) rigc
+writes the same. Read off the twelve exports under `examples/`: for each kind,
+every object's key sequence is a subsequence of one order, no two exports
+contradict each other on any kind, and the table below is that order. It lives
+in one place, [`src/keyorder.ts`](../src/keyorder.ts)'s `EDITOR_KEY_ORDER`, and
+the compiler applies it once to the finished skeleton — `CUR83` holds this table
+to that one, and `IG77` holds that one to the exports on every run with a
+corpus.
+
+| Kind | Keys, in the order the editor writes them |
+| --- | --- |
+| `top level` | `skeleton`, `bones`, `slots`, `constraints`, `skins`, `events`, `animations` |
+| `header` | `hash`, `spine`, `x`, `y`, `width`, `height`, `images`, `audio` |
+| `bone` | `name`, `parent`, `length`, `rotation`, `x`, `y`, `scaleX`, `scaleY`, `inherit`, `color`, `icon` |
+| `slot` | `name`, `bone`, `color`, `attachment`, `blend` |
+| `ik constraint` | `type`, `name`, `target`, `bones`, `mix`, `bendPositive` |
+| `transform constraint` | `type`, `name`, `source`, `bones`, `rotation`, `x`, `y`, `properties`, `localSource`, `localTarget`, `mixRotate`, `mixX`, `mixY`, `mixScaleX`, `mixShearY` |
+| `physics constraint` | `type`, `name`, `bone`, `x`, `y`, `rotate`, `damping` |
+| `skin` | `name`, `attachments` |
+| `region attachment` | `x`, `y`, `scaleX`, `scaleY`, `rotation`, `width`, `height` |
+| `mesh attachment` | `type`, `uvs`, `triangles`, `vertices`, `hull`, `edges`, `width`, `height` |
+| `boundingbox attachment` | `type`, `vertexCount`, `vertices` |
+| `clipping attachment` | `type`, `end`, `vertexCount`, `vertices`, `color` |
+| `animation` | `slots`, `bones`, `ik`, `transform`, `physics`, `attachments`, `drawOrder`, `events` |
+| `bone rotate key` | `time`, `value`, `curve` |
+| `bone translate key` | `time`, `x`, `y`, `curve` |
+| `bone translatex key` | `time`, `value`, `curve` |
+| `bone translatey key` | `time`, `value`, `curve` |
+| `bone scale key` | `time`, `x`, `y`, `curve` |
+| `bone shear key` | `time`, `x`, `y`, `curve` |
+| `slot attachment key` | `time`, `name` |
+| `slot rgba key` | `time`, `color`, `curve` |
+| `ik key` | `time`, `mix`, `softness`, `bendPositive`, `curve` |
+| `transform key` | `time`, `mixRotate`, `mixX`, `mixY`, `curve` |
+| `physics damping key` | `time`, `value` |
+| `physics inertia key` | `time`, `value` |
+| `physics mass key` | `time`, `value` |
+| `physics mix key` | `time`, `value`, `curve` |
+| `physics wind key` | `time`, `value` |
+| `attachment deform key` | `time`, `offset`, `vertices`, `curve` |
+| `drawOrder key` | `time`, `offsets` |
+| `drawOrder offset` | `slot`, `offset` |
+| `event key` | `time`, `name` |
+
+⚠️ **Three things about that table are rigc's rather than the editor's, and it
+says which.**
+
+- **A pair no export carries together has no measured order**, and the row
+  places it the way rigc already emitted it — a transform constraint's
+  `rotation` before `x`, an ik key's `time` before `mix`, a physics
+  constraint's `x`/`y` before `rotate`. `src/keyorder.ts` lists every such pair.
+  Such a pair did not move, and nothing here says the editor agrees.
+- **A kind with no row keeps rigc's order whole**: a linked mesh, a path or
+  point attachment, a sequence, the path and slider constraints, an event
+  definition, and the keys of every timeline the twelve do not key with two
+  fields (`scalex`, `rgb`, `alpha`, `rgba2`, `sequence`, the path and slider
+  timelines, …). Unmeasured is not certified.
+- **A key a row does not list stays where its constructor put it** — a bone's
+  `shearX`, a region's `name` and `path`, a header's `fps`. The row's keys are
+  permuted among the places they hold. Sending such a key to the end instead was
+  rejected on a measured case: the corpus's physics `strength` keys are all at
+  t=0, so the editor wrote them `value` alone, and that rule would have moved
+  `time` — first in every other key kind the editor writes — behind `value`.
+
+🔬 **Two positions and one fold are measured on a production set, not on
+`examples/`** ([#791](https://github.com/firejune/rigc/issues/791)). The twelve
+exports carry no mesh `path` or `color` and no slot name outside ASCII — `IG84`
+and `IG85` count both on every run with a corpus — so the table cannot learn
+either, and what rigc writes for them was read off 42 production exports
+instead:
+
+- **A mesh attachment writes `path` and `color` right after `type`, `path` before `color` — measured on a production set (#791), not on `examples/`.**
+  18 meshes whose `path` differs from their name wrote it second, and 1 with a
+  `color` wrote that second; no mesh carried both. The row does not list them,
+  so the position is the constructor's — `meshTextureKeys` in
+  [`src/compile.ts`](../src/compile.ts), which every mesh route spreads right
+  after `type` (`S104`). A region's `path` and a linked mesh's keys stay where
+  they were: neither was in the set, and an analogy is not a measurement.
+- **A skin's slot keys are compared after `foldBeforeComparing`, which reads U+3000 as U+0020 and U+FF10–U+FF19 as U+0030–U+0039** —
+  the ideographic space as a space, the full-width digits as `0`–`9`
+  (`EDITOR_NAME_FOLD`). One map of 95 slot keys, 7 of them carrying those
+  characters, came back in an order this reproduces 95 of 95 and neither a
+  codepoint sort nor the comparator without the fold does (`S105`). It is **not**
+  `normalize('NFKC')`, though NFKC folds both the same way: NFKC, a classifier
+  that reads every Unicode digit as a digit and every space separator as a space,
+  and a width fold alone all reproduce that map and disagree past it (on `fi`,
+  `²`, `٣`, `Ａ`, a no-break space), and what all three agree on is exactly
+  these two classes. The comparator is R10's, so animation and skin names are
+  compared after the fold too. A pair the fold does not close — a tab, a
+  no-break space — still keeps the map in rigc's order, whole (`S106`).
+
+🔸 **An object keyed by NAMES is not a field order**, and the table does not
+touch one. A bone's or a slot's timelines, and a transform constraint's
+`properties` and each `to` inside them, are read into the runtime's arrays in the
+order they are keyed — for timelines, the order they are applied in — so their
+order is more than a key's position, and rigc already emits the export's own on
+all twelve. A skin's `attachments` slot keys are the one name-keyed map this
+changed: sorted by the editor's comparator (§10.1). The per-slot maps inside are
+the rig's own order.
+
+⇒ **What this means for you: nothing to write.** No input format changed and no
+key order is yours to state — a rig spec is read by name, and its field order
+still means nothing. What changed is that a canonical-form comparison of an
+export's rebuild against the export no longer finds an object whose keys sit
+elsewhere (`IG76`). What it found next was the defaults the export leaves out
+and rigc wrote, `"name": null`, and the three header keys (`IG78`) — and since
+§10.6c it finds the header's `hash` and `spine` and nothing else (`IG83`).
+
+### 10.6c The keys it leaves out
+
+The editor writes a key only where its value is not the one the parser reads in its
+absence, and since [#716](https://github.com/firejune/rigc/issues/716) rigc's emitter
+does the same, in one pass over the finished skeleton (`withoutParserDefaults` in
+`src/keyorder.ts`, run just before §10.6b's). A key is left out when its value is
+**exactly** the one below — the float the file would hold, not a value near it — so a
+rotation of `1e-45` is written and a rotation of `0` is not. The table is
+`PARSER_DEFAULTS`, and every row is the linked `spine-core` parser's own fallback
+(`getValue(map, key, default)` in `SkeletonJson.js`); the selftest loads an object of
+each kind with the key at that value and without it, and requires the two to be the
+same `SkeletonData` (`S103` on the in-tree builds, `IG82` on the corpus), and deletes
+every key of every in-tree build in turn to find one the table is missing (`S101`):
+
+| Kind | Left out when it is |
+| --- | --- |
+| `header` | `referenceScale` 100 |
+| `bone` | `length` 0 · `rotation` 0 · `x` 0 · `y` 0 · `scaleX` 1 · `scaleY` 1 · `shearX` 0 · `shearY` 0 · `inherit` "normal" · `skin` false · `iconSize` 1 · `iconRotation` 0 |
+| `slot` | `color` "ffffffff" · `attachment` null · `blend` "normal" · `visible` true |
+| `ik constraint` | `skin` false · `mix` 1 · `softness` 0 · `bendPositive` true · `compress` false · `stretch` false |
+| `transform constraint` | `skin` false · `localSource` false · `localTarget` false · `additive` false · `clamp` false · `rotation` 0 · `x` 0 · `y` 0 · `scaleX` 0 · `scaleY` 0 · `shearY` 0 · `mixRotate` 1 · `mixX` 1 · `mixScaleX` 1 · `mixShearY` 1 |
+| `path constraint` | `skin` false · `positionMode` "percent" · `spacingMode` "length" · `rotateMode` "tangent" · `rotation` 0 · `position` 0 · `spacing` 0 · `mixRotate` 1 · `mixX` 1 · `mixY` `mixX`'s, only at 1 |
+| `physics constraint` | `skin` false · `x` 0 · `y` 0 · `rotate` 0 · `scaleX` 0 · `shearX` 0 · `limit` 5000 · `fps` 60 · `inertia` 0.5 · `strength` 100 · `damping` 0.85 · `mass` 1 · `wind` 0 · `gravity` 0 · `mix` 1 · `inertiaGlobal` false · `strengthGlobal` false · `dampingGlobal` false · `massGlobal` false · `windGlobal` false · `gravityGlobal` false · `mixGlobal` false |
+| `slider constraint` | `skin` false · `additive` false · `loop` false · `mix` 1 · `from` 0 · `to` 0 · `scale` 1 · `max` 0 · `local` false |
+| `region attachment` | `x` 0 · `y` 0 · `scaleX` 1 · `scaleY` 1 · `rotation` 0 · `color` "ffffffff" |
+| `mesh attachment` | `color` "ffffffff" · `hull` 0 · `width` 0 · `height` 0 |
+| `path attachment` | `closed` false · `constantSpeed` true |
+| `clipping attachment` | `convex` false · `inverse` false |
+| `sequence` | `start` 1 · `setup` 0 |
+| `event` | `int` 0 · `float` 0 · `string` "" · `audio` null |
+| `bone rotate key` | `time` 0 · `value` 0 |
+| `bone translate key` | `time` 0 · `x` 0 · `y` 0 |
+| `bone translatex key` | `time` 0 · `value` 0 |
+| `bone translatey key` | `time` 0 · `value` 0 |
+| `bone scale key` | `time` 0 · `x` 1 · `y` 1 |
+| `bone scalex key` | `time` 0 · `value` 1 |
+| `bone scaley key` | `time` 0 · `value` 1 |
+| `bone shear key` | `time` 0 · `x` 0 · `y` 0 |
+| `slot attachment key` | `time` 0 · `name` null |
+| `slot rgba key` | `time` 0 |
+| `ik key` | `time` 0 · `mix` 1 · `softness` 0 · `bendPositive` true · `compress` false · `stretch` false |
+| `transform key` | `time` 0 · `mixRotate` 1 · `mixX` 1 · `mixY` `mixX`'s, only at 1 · `mixScaleX` 1 · `mixScaleY` 1 · `mixShearY` 1 |
+| `path position key` | `time` 0 · `value` 0 |
+| `physics damping key` | `time` 0 · `value` 0 |
+| `physics inertia key` | `time` 0 · `value` 0 |
+| `physics mass key` | `time` 0 · `value` 0 |
+| `physics strength key` | `time` 0 · `value` 0 |
+| `physics wind key` | `time` 0 · `value` 0 |
+| `physics mix key` | `time` 0 · `value` 1 |
+| `attachment deform key` | `time` 0 · `offset` 0 |
+| `attachment sequence key` | `time` 0 · `index` 0 · `mode` "hold" · `delay` the key before's, 0 on key 0 |
+| `drawOrder key` | `time` 0 |
+| `event key` | `time` 0 |
+
+Read a row as *"left out when it is"*: `x` 0 is a key left out at `0`; `mixY` `mixX`'s
+is a key left out where it equals the same object's `mixX` as the parser reads it,
+and *only at 1* narrows that to the one value the editor leaves it out at — measured:
+`sack-pro` writes `"mixX": 0, "mixY": 0` on six transform keys, where the parser would
+read an absent `mixY` as that same `0`. *The key before's* is a sequence key's
+`delay`, which the parser carries from the previous key (`lastDelay`).
+
+⚠️ **What is not a row, and why.**
+
+- **The header's `x`, `y` and `fps`.** The 4.3 JSON reader assigns them raw
+  (`skeletonData.x = skeletonMap.x`, `SkeletonJson.js:70`), so an absent origin loads
+  as `undefined` and a written `0` as `0`: there is no fallback for them to equal, and
+  rigc keeps writing the origin of a declared stage. The editor leaves it out
+  (§10.6's round trip 6), so a rebuild of an export whose stage sits at `0,0` spells
+  two fields the export does not — `LOSS HEADER_ORIGIN` says so on `ingest`.
+- **A transform constraint's `mixY` and `mixScaleY`.** Their fallback is the
+  constraint's `mixX` / `mixScaleX` — but the parser reads those only for a property
+  the constraint drives, so on one that drives `y` alone the fallback is the pose's
+  initial `0`, not `1`. A row there was tried and measured wrong: it left out
+  `8-follow-through-pro-ball`'s `"mixY": 1` on two such constraints, they loaded at
+  `0`, and `A48_TRANSFORM_CONSTRAINT_NOT_MUTED_THROUGHOUT` refused the rebuild.
+- **A region's `path`, an attachment's `name`, an event key's payload.** Their
+  fallbacks are another value — the attachment's own name, its placeholder, the event
+  definition's — which rigc writes only where it differs.
+- **A slider's `time` and a sequence's `digits`.** The parser has a fallback for
+  both, and nothing here can load it: `time` is read only on a slider with no `bone`,
+  which no build or export carries, and `digits` renames every frame of the series,
+  so no atlas a build resolves against loads it either way. Both are written as
+  stated.
+- **Every kind with no row** — the keys of a `shearx`, `sheary`, `inherit`, `alpha`,
+  `rgb`, `rgb2`, `rgba2`, path `spacing`/`mix`, physics `gravity`/`reset` or slider
+  timeline, a linked mesh, a point attachment. No build the selftest loads and no
+  export carries an object of those kinds, and a row nothing loads is a claim about
+  the parser nobody has checked — where a missing row only costs a key the parser
+  reads the same either way. `S101` names such a key the day a build emits one.
+
+⚠️ **Why 4.3's defaults, when #706 row 4 says they are not every generation's.**
+An omitted physics `inertia` is 0.5 to the 4.3 parser and 1 to the 4.2 one, and that
+is exactly why a key is left out only against the parser rigc links: the file states
+`"spine": "4.3.13"`, and the parser it is gated against is that one. Writing the
+default out would not make the file safe for a 4.2 reader: that reader applies its
+own defaults to every *other* key the file leaves out as well — every one the editor's
+own 4.3 export leaves out, too — and #706 rows 1, 2 and 6 measure what reading one
+generation's data on another generation's runtime does, none of it repaired by one
+key written out. That misread is refused where it can be seen, on the reading side
+(`GENERATION_UNSUPPORTED` in `ingest`), rather than written for on the emitting one.
+
+⇒ **What this means for you: nothing to write, and nothing to stop writing.** A
+default you state stays in your spec and leaves the file; `explain` prints a bone
+key's channels as the parser reads them, so a key that left the file still shows its
+value there.
+
 ### 10.7 What this section does not claim
 
 Conventions that are visible in reference exports but that **no public Spine page