spine-rigc 0.28.0 → 0.30.0

package/docs/AUTHORING.md

@@ -169,7 +169,7 @@ What the flags mean:
 | `--manifest` | a cut manifest. Only for a rig with **measured art** behind it; a foreign skeleton has none |
 | `--cut` | `build`, `explain` and `validate`: look up a named cut in `--cuts <cuts.json>`, **instead of** `--rig`/`--motion`/`--out` — the two spellings are one build stated two ways and are refused together. A `cuts.json` is `{ "<name>": { "rig": …, "motion": …, "out": …, "manifest"?: … } }`, every path in it relative to the table's own file, so the table lives with the project that owns the art |
 | `--cuts` | the `cuts.json` `--cut` names. Required beside it — `--cut` alone is refused, with no guess at where the table lives |
-| `--profile` | `spine` = the 30 validity rules (**the default**) · `spine-html` = all 45, opt-in |
+| `--profile` | `spine` = the 31 validity rules (**the default**) · `spine-html` = all 46, opt-in |
 | `--candidate` | `check`, `bench`, `render`, `preview`, `chainfit` and `vote` only: a **compiled** artifact — the directory `build --out` wrote, or a `skeleton.json` path. `--atlas <path>` names the atlas when it does not sit beside the skeleton. **`vote` is the one command that takes it more than once** — repeat it 2–4 times, one per pane, labelled A, B, C, D in the order given; everywhere else a repeat is a typo and is refused |
 | `--animation` | `render`, `preview` and `vote` only: which animation to show. The default is **every** one for `render`, the **first** for `preview`, and for `vote` the first of candidate A. A name the skeleton does not have is refused, with the ones it does have listed — and for `vote`, so is a name that only *some* candidates have |
 | `--record` | `vote` only: a saved vote to check against its ballot and append to the ledger, instead of writing a ballot. This is the command's second mode; it takes no `--candidate` |
@@ -324,6 +324,72 @@ texel count beside it so both numbers are visible:
 measures the PNG. Reach for `--atlas-in` when the pack is what you were handed, or
 when drawing through the pack's own texels is the point.
 
+🚨 **A page that declares a size it does not have is a different thing, and it is
+refused** ([#715](https://github.com/firejune/rigc/issues/715)). The common shape
+is a pack whose `4096x4096` pages ship as `2048x2048` PNGs with the atlas
+untouched — every region still stated in 4096-space — and that is **not** what a
+`scale:` line says. A runtime draws it anyway: `TextureAtlas` computes every
+region's UVs as a fraction of the **declared** size (`region.u = region.x /
+page.width`) and nothing in the region mapping opens the file, so the same
+fraction of the picture is addressed whatever size the PNG is. What a page grid
+that disagrees with its file breaks is every reader that addresses the page in
+**texels** — `A19`'s alpha scan, the region lift a mesh generator traces, and a
+canvas renderer that cuts each part out by source rectangle. So `A06` refuses it
+under **both** profiles, names the ratio it measured on each axis, and prints the
+header that states the same art truthfully:
+
+```bash
+#   FAIL  A06_ATLAS_PAGE_SIZE_MATCHES_PNG: page "hero.png" declares 4096x4096 and its PNG is 2048x2048 —
+#         0.5000 of the declared width and 0.5000 of the declared height. … The format states coarser texels
+#         with the `scale:` header and rigc builds that: declare `size: 2048, 2048` with `scale: 0.5000` and
+#         multiply every `bounds`/`offsets` on this page by 0.5000, and every part keeps the size it has now.
+```
+
+⇒ **Carry that out and the build is green with the attachment sizes it already
+had**, because the division cancels (`originalWidth / scale`, above) — which is
+the measurement that settles where this clause belongs: the format already has a
+line for coarser texels and rigc already reads it, so the refusal hands over a
+repair rather than a preference. Two limits, and the message names whichever one
+it hits instead of leaving it to be discovered:
+
+- a region whose `bounds`/`offsets` do not land on a whole texel of the file
+  cannot be re-declared at all, and the refusal names the first number that does
+  not divide;
+- a page whose two axes differ — `4096x4096` declared over a `2048x3072` PNG —
+  has no honest header either, because `scale:` carries **one** ratio. The message
+  says so rather than offering one, and the repair is to re-export the page at the
+  size the atlas declares, or repack.
+
+🚨 **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
+and nothing else — the size `A06` judges, the alpha `A19` judges, the renderer and
+the region lift all decode PNG, and rigc links no decoder for any other format —
+and a file's name is not evidence: a production pack shipped WebP pages called
+`*.png`. What a page is comes off its first bytes. The refusal says what it found
+there — a WebP, JPEG, GIF, KTX or KTX2 file by its signature, or no format rigc
+recognises, with the first bytes in hex either way — and a file that begins as a
+PNG and runs out before its `IEND` chunk is called **truncated**, wherever it was
+cut. `build --atlas-in` and `explain --atlas-in` say so where they open the pack,
+every such page in one sentence and before the compile; a loose part that is not a
+PNG is refused as the image it is; and `rigc validate` on a directory holding such
+a page fails `A06` with the same sentence:
+
+```bash
+#   FAIL  A06_ATLAS_PAGE_SIZE_MATCHES_PNG: page "hero.png" declares 2048x2048 and its file cannot be read as PNG, so
+#         the size was not measured: /abs/art/hero.png is a WebP image (a RIFF/WEBP container whose first chunk is
+#         "VP8L"), not a PNG: … rigc reads PNG and nothing else — its page-size and alpha readers, its renderer and
+#         its region lift all decode PNG, and it links no decoder for any other format — so nothing in this file was
+#         measured. Re-export it as PNG
+```
+
+⇒ **Re-export the page as PNG under the name the atlas gives it**, and the next run
+measures it like any other. ⚠️ `A06` deliberately does not read the width and
+height a WebP header carries in a fixed field. Doing so would print a size that no
+reader in this tree can check — the parse would agree only with the forgery it was
+written against — about a page that is refused either way; and the variant that
+let a size-matching WebP page pass was measured building green under the default
+profile and writing a directory whose next `render` refused the page.
+
 **What `--out` holds afterwards:** `skeleton.json` and a `skeleton.atlas` that is
 the pack, page paths pointing back at the pack's own PNGs — so `rigc validate
 <that directory>` reads it green with no flags, exactly as it reads a loose
@@ -342,8 +408,8 @@ because the text passes through by line; regions the rig does not use stay in th
 file, because a real pack is shared between cuts and an importer that quietly
 dropped half of one would make `--out` disagree with the pack it was built from.
 
-Four things are refused rather than warned about, because each of them otherwise
-**loads clean and draws wrong**:
+Five things are refused rather than warned about, because each of them otherwise
+**loads clean and draws wrong** — or, the last, cannot be read back at all:
 
 | What | Why it cannot be a warning |
 | --- | --- |
@@ -351,6 +417,7 @@ Four things are refused rather than warned about, because each of them otherwise
 | a size the spec disagrees with | the same silence `A06` exists for, one link earlier: a quad sized against a region of another size collapses |
 | a page the atlas names and the disk lacks | nothing to sample; caught on the way in, so the message names the atlas rather than the artifact rigc wrote from it |
 | a rectangle that runs off its page | `x + width` past the page width makes `u2 > 1`, which samples whatever the wrap mode does. The gate names the same rectangle, under every profile, for a pack that reaches it without passing through here — `A06`, §5.2 ([#694](https://github.com/firejune/rigc/issues/694)) |
+| a page file that is not a PNG | nothing in rigc can read it — not the gate, not `render`, not a mesh generator — so a green build over it would certify pixels nobody opened. Named by what its first bytes are, every such page of the pack in one sentence; the gate says the same for a directory that reaches it another way — `A06`, §5.2 ([#732](https://github.com/firejune/rigc/issues/732)) |
 
 One limit, stated rather than discovered:
 
@@ -819,8 +886,7 @@ behind it writes literal `x`/`y` instead.
 
 **R10 — The `animations` object is keyed in the editor's order, not in yours, and
 names that have no one order are refused.** Declare animations in whatever order
-reads best; the emit keys them the way the Spine editor does — **natural and
-case-insensitive**. This is the one place rigc
+reads best; the emit keys them the way the Spine editor does. This is the one place rigc
 reorders anything you wrote, and it is not cosmetic: a `slider`'s animation is a
 **name** in JSON and an **ordinal** in the format's binary half, so an editor that
 re-sorts the object repoints every slider whose animation moved index — silently,
@@ -829,61 +895,73 @@ in a file that still parses and still gates green (§3.5.2,
 animation's own body is byte-identical either way, and every other collection is
 emitted in the order you gave it.
 
-⚠️ **What is measured about that comparator, and what is not.** The editor sorts
-natural and case-insensitive — measured, two rigs, one axis each:
-`Turn, sweep, wave` came back `sweep, Turn, wave`, and `turn10, turn2, zoom` came
-back `turn2, turn10, zoom` ([#539](https://github.com/firejune/rigc/issues/539)).
-But "natural and case-insensitive" is a **family** of comparators, not one, and
-**four** of its choices have never been measured. rigc emits the order every
-member of that family agrees on, and **refuses the sets where one of the four
-would decide**, naming the pair. So the rule you have to hold is about *names*,
-and it is four things:
-
-| Do not let two animation names differ | Because | Instead |
+⚠️ **What that comparator is, measured rather than inferred.** Five name lists
+went through a licensed 4.3.26 editor as JSON and came back as JSON, and the ten
+answers are in the repository as
+`fixtures/editor-order/probe{1..5}.{in,out}.json`
+([#728](https://github.com/firejune/rigc/issues/728)). Every row below is a clause
+of the rule with the pair from those files that shows it — nothing here is a
+guess, and the selftest re-derives each row from the files rather than from this
+page:
+
+| The editor | Shown by |
+| --- | --- |
+| folds case **upward**, per character, and leaves a character with no single upper case where it is | `z` before `_x` (`_` is 0x5F, above `Z` and below `a`); `z` before `ß`, which a whole-string upper case would write `SS` and sort among the `S`s |
+| reads a **run of digits as a number** — at any position, after any script | `x2` before `x10`; `中2` before `中10` |
+| **defers** two runs that are one number written twice, and settles them at the end with the leading zeros later | `a01` before `a1b`, so the walk did not stop at the equal runs; `a1` before `a01`, which is how it ends |
+| **skips a space**, and gives that tie to the name with fewer of them — after the leading-zero tie-break, not before it | `bc` before `b c`; `a 1` before `a01` |
+| otherwise orders by **code point after folding**, and does not treat punctuation as ignorable | `a-1` before `a1`; `a1b` before `a_1` |
+| 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` |
+
+⭐ **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
+order** and the editor keeps it. Nothing moves index, so there is nothing to
+refuse: `Turn` beside `turn`, `turn01` beside `turn1`, `1turn` beside `turn`,
+`wave_x` beside `wavea` all build, and each is keyed the way the round trips say.
+
+So what is left refused is short, and each row is a pair two readings of the
+**same** measurement order differently:
+
+| Refused | Because | Instead |
 | --- | --- | --- |
-| by **case alone** (`Turn` against `turn`) | they fold together, so only a tie-break separates them, and nobody has measured which way it breaks | pick one case for all of them, or change a letter |
-| by a **number written two ways** (`turn01` against `turn1`) | `01` and `1` are one number twice; shorter-first, longer-first and lexicographic are all real tie-breaks | write the number one way — with leading zeros or without, but not both |
-| by a **digit run against a word** (`1turn` against `turn`) | comparators differ on whether a number sorts before a word | rename so a run of digits is never compared against a word |
-| by a **separator** — anything that is neither a letter nor a digit (`wave_x` against `wavea`, `wave` against `wave-`) | a collator may treat `-` or a space as ignorable, and `_` sits *between* `Z` and `a`, so folding up and folding down order it oppositely | rename so the first character that differs is a letter or a digit |
-
-⭐ **Capitals and numbered series are not what is refused** — only pairs one of
-those four decides. `Sweep, Turn, Wave, Zoom02, Zoom10` builds, and so does
-`shot1 … shot12`: every member of the family puts each of those sets in one
-order, and that order is what rigc emits. A numbered series that crosses 9 → 10 is
-keyed **1, 2, … 9, 10, 11, 12**, which is what the editor does with it — and is
-not what a codepoint sort does.
-
-✅ **This list had two more rows before
-[#543](https://github.com/firejune/rigc/issues/543), and both were artefacts of
-the emit rather than facts about the editor.** rigc used to key `animations`
-**codepoint-ascending** and refuse every pair codepoint and the editor could order
-differently — which refused a pair that folds the other way (`Turn` against
-`sweep`) and a pair of digit runs of unequal width (`turn10` against `turn2`).
-Those are the only two name sets anybody has ever put through the editor and read
-back, so the tool was refusing precisely the pairs it knew the most about, and its
-only repair was *rename* — the one repair a transcription cannot take. Emitting a
-member of the family instead moves no byte on any set the old rule accepted; it
-just stops refusing the ones it did.
-
-**R11 — The `skins` array is written with `default` first and the rest in the
-editor's order, and skin names that have no one order are refused.** The same rule
-as R10, in the collection that was believed exempt from it. A skin is a **name** in
-the JSON half of the format and an **ordinal** in the binary half —
-`skins[readInt()]` for an attachment timeline, `skins[skinIndex]` for a linked mesh
-— so an editor that writes the array in another order repoints every such
-reference, silently, in a file that still parses. Measured: a rig built
-`default, zulu, mike, alpha` exported `default, alpha, mike, zulu`
+| `number` — two or more digit runs that are each one number written twice, pointing opposite ways (`x01y1` against `x1y01`) | the round trips measured one deferred run; keeping the first such difference and keeping the last are both consistent with that | write each number one way, with leading zeros or without |
+| `separator` — a whitespace character that is not a space (a tab, a no-break space) | the space is measured skipped and nothing else is, so a rule that skips all whitespace and one that skips only the space disagree here | rename so the only whitespace in either name is a space |
+| `folder` — two sibling **folders** the comparator cannot separate (`Fx/a` against `fx/b`) | a tie between two leaves is file order, but the editor holds a folder as an object and keeps its entries together, and no round trip carried two folders one fold apart | rename one of the folders so they differ by more than letter case, spacing or a leading zero |
+
+⭐ **Capitals and numbered series are not what is refused.**
+`Sweep, Turn, Wave, Zoom02, Zoom10` builds, and so does `shot1 … shot12`: a
+numbered series that crosses 9 → 10 is keyed **1, 2, … 9, 10, 11, 12**, which is
+what the editor does with it — and is not what a codepoint sort does.
+
+✅ **This rule was a quantifier over comparators until #728, and that is what
+changed.** rigc keyed `animations` codepoint-ascending until
+[#543](https://github.com/firejune/rigc/issues/543) and then emitted a member of
+the "natural, case-insensitive" family, refusing every pair the family could
+disagree about. Both refusals were sound and both over-refused by construction,
+because a quantifier stands in for a measurement: a name with a capital, an
+accent, a space or a folder in it was refused rather than emitted in the order the
+editor returns. Measuring the comparator moves no byte on any set the old rule
+accepted; it stops refusing the ones it did.
+
+**R11 — The `skins` array is written with `default` first and the rest in exactly
+the order R10 describes.** A skin is a **name** in the JSON half of the format and
+an **ordinal** in the binary half — `skins[readInt()]` for an attachment timeline,
+`skins[skinIndex]` for a linked mesh — so an editor that writes the array in
+another order repoints every such reference, silently, in a file that still
+parses. Measured: a rig built `default, zulu, mike, alpha` exported
+`default, alpha, mike, zulu`
 ([#541](https://github.com/firejune/rigc/issues/541)).
 
-⚠️ **The refusal here is wider than R10's, and deliberately.** R10 can be narrow
-because #539 measured two animation-name pairs and thereby *refuted* a codepoint
-sort. The skins measurement refutes nothing — `alpha, mike, zulu` is the answer
-codepoint, folding and natural order all give — so the editor's skin comparator is
-**not established**, and rigc refuses any pair those candidates could disagree
-about. In practice that is R10's four rows plus two more: a pair a case fold
-reverses (`Zulu` against `mike`) and two digit runs of unequal width (`mike10`
-against `mike2`). Both of those *build* as animation names and are refused as skin
-names, and the two refusals say which is which.
+⚠️ **It is one comparator, and that is measured too.** Two of the five round
+trips carried one name list as **both** collections and both came back in one
+order, which is what retired the wider skin refusal #541 shipped: until #728,
+`Zulu` beside `mike` and `mike10` beside `mike2` built as animation names and were
+refused as skin names. Both build now. `default` is pinned rather than sorted, on
+names the same comparator puts ahead of it — `default` before `2`, `default`
+before `A` — so renaming a skin away from `default` makes it an ordinary name that
+sorts like one.
 
 **R12 — A placeholder that more than one skin fills gets a per-skin attachment
 `name`, and the `default` skin may not be one of those skins.** rigc writes
@@ -1010,7 +1088,7 @@ and the inheritance silently falls back to Normal — assertion `A02` refuses it
 | `bone` | required; must be a bone this rig declares | — |
 | `attachment` | the **setup pose** attachment name, or `null` for "show nothing" | must come from here or from `motion.setup` (R3) — **except** on a slot nothing fills, where it can only be `null` and may be left out |
 | `color` | `rrggbbaa` tint | opaque white |
-| `dark` | two-colour tint, `rrggbb`. The **setup** half; §4.4's `rgba2` track keys it over time and requires it | — (🚫 `A12` under `spine-html`) |
+| `dark` | two-colour tint, `rrggbb`. The **setup** half; §4.4's `rgba2` and `rgb2` tracks key it over time and require it | — (🚫 `A12` under `spine-html`) |
 | `blend` | `normal` · `additive` · `multiply` · `screen` | `normal` |
 
 ✅ **Every slot you declare is emitted, in this order.** A slot nothing fills — no
@@ -2045,8 +2123,24 @@ is dead data in silence:
   runs, under any skin there is.
 
 rigc refuses both halves by name, and `A38_SKIN_MEMBERS_ARE_SKIN_REQUIRED` checks
-the artifact for them. A bone or constraint belongs to **one** skin; two skins
-naming the same one is also refused.
+the artifact for them.
+
+⭐ **A bone or a constraint may be listed by more than one skin**, and each list
+is emitted as written: two mutually exclusive variants of one body region both
+activating the bone they switch on is the ordinary case. At runtime it is active
+while **the skin being worn** lists it — `Skeleton.updateCache` walks that skin's
+`bones` and turns each one on, along with its whole ancestor chain — so a bone two
+skins name poses under either of them and under neither of the rest. A consumer
+that combines the two with `Skin.addSkin` gets it once; the runtime deduplicates
+by object identity.
+
+⚠️ **The worn skin, and only the worn skin — including `default`.** The
+default-skin fallback is about *art*: `getAttachment` looks in the current skin
+and then in `SkeletonData.defaultSkin`, and `updateCache` does no such thing. So a
+`skin: true` bone that only the `default` skin lists is **inactive under every
+other skin** and inactive with no skin set. Listing it there to mean "always on"
+gets the opposite; leave the flag off instead, which is what "active under every
+skin" is spelled as.
 
 ⚠️ **The two spellings are told apart by these seven keys** — `attachments`,
 `bones`, `ik`, `transform`, `path`, `physics`, `slider` — so a skin that uses any of
@@ -2377,9 +2471,11 @@ re-rendered mean absolute error from 10.4655 / 8.4961 / 8.7140 down to
 identically, which is what rigc emitted when that trip was measured.)
 
 ⚠️ The editor's comparator is natural and case-insensitive
-([#539](https://github.com/firejune/rigc/issues/539)), and four of its choices are
-unmeasured — so the emit is that family's order for names none of the four
-decides, and the rest are a compile error. **R10** has the four shapes to avoid.
+([#539](https://github.com/firejune/rigc/issues/539)) and is now measured in full
+off five stored round trips
+([#728](https://github.com/firejune/rigc/issues/728)) — so the emit is the
+editor's own order, and only what those files leave open is a compile error.
+**R10** has the rule and the three shapes to avoid.
 
 ✅ **What that repair does not reach is a compile error now, not a hazard.** This
 paragraph used to say that names a codepoint sort and a friendlier one disagree
@@ -2391,7 +2487,8 @@ that to naming discipline — and since
 [#543](https://github.com/firejune/rigc/issues/543) it does better than refusing
 those two, because they are the two sets the editor's answer is **known** for:
 both are emitted in the order it returned. What is still a compile error is the
-set whose order turns on one of the four unmeasured choices, printed with both
+set whose order turns on one of the three things the round trips of
+[#728](https://github.com/firejune/rigc/issues/728) leave open, printed with both
 names, which of them decides it, and the rename that settles it. What changed is
 the price of forgetting: a build that stops, rather than a slider that silently
 applies the wrong animation.
@@ -3013,7 +3110,10 @@ a deform). Folding them in would make `v` mean four different things depending o
 | `bone` | `translate`, `scale`, `shear` | `[x, y]` |
 | `bone` | `translatex`, `translatey`, `scalex`, `scaley`, `shearx`, `sheary`, `rotate` | `[value]` |
 | `slot` | `rgba` | `[r, g, b, a]` in 0..1 |
+| `slot` | `rgb` | `[r, g, b]` in 0..1 — the light colour **without** its alpha, which stays wherever the setup pose or an `alpha` track puts it. Emitted as `{ time, color: "rrggbb" }` |
+| `slot` | `alpha` | `[a]`, **0 to 1** — the light colour's alpha alone; the rgb is left where it is. Emitted as `{ time, value }`, a number rather than a byte |
 | `slot` | `rgba2` | `[lr, lg, lb, la, dr, dg, db]` in 0..1 — the two-colour tint, light then dark, **seven** channels. The slot must declare a setup `dark` (§3.3) |
+| `slot` | `rgb2` | `[lr, lg, lb, dr, dg, db]` in 0..1 — the two-colour tint **without** the light alpha, six channels. The slot must declare a setup `dark` (§3.3) |
 | `slot` | `attachment` | the attachment name, or `null` for "show nothing" |
 | `physics` | `inertia`, `strength`, `damping`, `mass`, `wind`, `gravity` | `[value]` — the constraint's own tuning, keyed over time |
 | `physics` | `mix` | `[mix]`, **0 or more** — the constraint's authority |
@@ -3057,9 +3157,9 @@ accepts is what it accepts.
   it actually poses, both ways, which is what makes the list checkable at all: it
   was stated there too until the refusal had something to state.
 
-⚠️ **A `slot` track's `property` is one of the three above, and anything else is a
+⚠️ **A `slot` track's `property` is one of the six above, and anything else is a
 compile error** — `animation "A" slot "X" has no timeline "P" (it has:
-attachment, rgba, rgba2)`, §5.1's row. Until
+attachment, rgba, rgb, alpha, rgba2, rgb2)`, §5.1's row. Until
 [#650](https://github.com/firejune/rigc/issues/650) it was not: the emitter had a
 branch for `attachment` and wrote **everything else** as an rgba timeline under
 the name you gave it, so a track spelled `sequence` compiled, emitted
@@ -3068,18 +3168,52 @@ the name you gave it, so a track spelled `sequence` compiled, emitted
 one-channel spelling of the same mistake was refused at compile as `rgba value
 needs 4 channels, got 1`, a message about a key you had not written.
 
-- The three are the emitter's own dispatch table (`SLOT_TRACKS` in
-  `src/compile.ts`): `compileTrack` reads it to pick its branch, and the refusal
-  prints `Object.keys` of the same object, so what you are told a slot accepts
-  is what it accepts.
+- The six are the emitter's own dispatch table (`SLOT_TRACKS` in
+  `src/compile.ts`), in the order `SkeletonJson.readAnimation` switches on
+  them — which makes it the format's whole slot switch: `compileTrack` reads it
+  to pick its branch, and the refusal prints `Object.keys` of the same object,
+  so what you are told a slot accepts is what it accepts.
 - **Nothing derives this page's copy of that list from the table**, and it is
-  three names long: no `DQ*`/`RD*`/`CUR*` control reads §4.4 (the only gated
+  six names long: no `DQ*`/`RD*`/`CUR*` control reads §4.4 (the only gated
   table on this page is §3.5.2.1's, held by `RD01`–`RD06`). What keeps the two
   in step is the control that quotes the message — `RF23` in `selftest.ts` —
   which goes red if the accepted list ever widens without this page moving with
   it. It did, on the day `rgba2` was added
-  ([#690](https://github.com/firejune/rigc/issues/690)), which is the mechanism
-  working rather than a hole in it.
+  ([#690](https://github.com/firejune/rigc/issues/690)) and again when `rgb`,
+  `alpha` and `rgb2` were ([#730](https://github.com/firejune/rigc/issues/730)),
+  which is the mechanism working rather than a hole in it.
+- 🎨 **`rgb`, `alpha` and `rgb2` are the SEPARABLE colour timelines, and they
+  are not spellings of `rgba`.** Each poses part of the slot's colour and leaves
+  the rest exactly where it was: `rgb` writes the light colour's r g b and never
+  its alpha, `alpha` writes the alpha and never the r g b, and `rgb2` writes the
+  light r g b and the dark colour and never the light alpha. So an `rgb` track
+  and an `alpha` track on one slot, each on its own key times, is a fade and a
+  tint that move independently — the shape an editor export carries when the
+  two were keyed apart. Written as one `rgba` instead, every key would have to
+  state the other channel at a time nobody keyed it, and a lone fade has no
+  `rgba` spelling at all: an `rgba` key poses the r g b too, pinning whatever
+  else tints the slot.
+  - An `alpha` key is `[a]` like every other one-channel track, and it is the
+    one colour key stored as a **number** rather than a byte (`{ time, value }`),
+    so it is not rounded onto 1/255 the way the hex shapes are. It has to be
+    **from 0 to 1**: the runtime clamps the posed alpha to that range only after
+    interpolating the stored value, so a key of 1.5 would reach full opacity at a
+    different time from a key of 1 — a curve nobody keyed. The compiler refuses
+    it rather than clamping it (§5.1).
+  - `rgb2`, like `rgba2`, needs the slot to declare a setup `dark` (§3.3) — for
+    the same reason, measured the same way: without one the file loads and the
+    first `state.apply` throws `TypeError: null is not an object` inside
+    `RGB2Timeline.apply1`. The refusal names `rgb` as the way out.
+  - ⚠️ **Two tracks of one slot that pose the same channel are a compile
+    error**, even though they are two properties and the one-track-per-target
+    rule above cannot see them: `rgba` beside `alpha` (both pose the alpha),
+    `rgba` beside `rgb`, `rgba2` beside `rgb2`, and so on. A 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
+    and the first one's keys are read by nothing. `rgb` beside `alpha`, and
+    `rgb2` beside `alpha`, share no channel and are the pairs to write.
+    `A45_SEPARABLE_COLOR_TIMELINES_OWN_THEIR_CHANNELS_AND_POSE_AS_WRITTEN`
+    (§5.2) names the same pair in a file rigc did not write.
 - 🎨 **`rgba2` keys the two-colour tint, and the slot has to own one first.** A
   track `{ "slot": "X", "property": "rgba2" }` on a slot whose rig spec declares
   no `dark` (§3.3) is a compile error with the slot named, and it is not a
@@ -3090,11 +3224,12 @@ needs 4 channels, got 1`, a message about a key you had not written.
   of the two-colour tint are refused under `--profile spine-html`, whose renderer
   ignores them; the default `spine` profile that `build` runs reports `A12` as
   `PROF` and never applies it.
-- The format has three more slot timelines (`rgb`, `alpha`, `rgb2`) and rigc
-  emits none of them, so their names are refused here too; `A12_NO_DARK_COLOR`
-  refuses `rgb2` — and `rgba2`, and the slot field — in a file under that
-  renderer's profile (SPEC_COVERAGE §2.1). `sequence` is a timeline on an
-  **attachment**, not on a slot, and rigc does not emit that either.
+- The six are every slot timeline the format has; anything else is refused
+  here, and would be refused by the runtime's own reader too (`Invalid timeline
+  type for a slot`). `A12_NO_DARK_COLOR` refuses `rgb2` — and `rgba2`, and the
+  slot field — in a file under the `spine-html` profile (SPEC_COVERAGE §2.1).
+  `sequence` is a timeline on an **attachment**, not on a slot, and rigc does
+  not emit that one.
 
 ⚠️ **A `group` track's `property` is one of those two lists or the physics one,
 and anything else is a compile error** — `animation "A" group "G" has no timeline
@@ -3142,8 +3277,8 @@ a delta from the constraint's own setting.
   key states a mass and the pose holds `1 / mass`, so a `mass` key of `0` is an
   infinite inverse mass — the constraint stops moving.
 - **Four of the seven are bounded, and a key outside its bound is a compile
-  error** ([#610](https://github.com/firejune/rigc/issues/610)). `mass` and
-  `strength` must be `> 0`, `damping` must be strictly inside `(0, 1)`, and `mix`
+  error** ([#610](https://github.com/firejune/rigc/issues/610)). `mass` must be
+  `> 0`, `damping` must be strictly inside `(0, 1)`, and `mix` and `strength`
   must be `0` or more. `A23_PHYSICS_CONSTRAINT_EFFECTIVE` applies the same four to
   a file rigc did not write, naming the animation, the constraint, the key time
   and the value — so the compiler is where a spec you wrote is refused, and the
@@ -3153,11 +3288,39 @@ a delta from the constraint's own setting.
   `PhysicsConstraintPose` documents `mix` as "a percentage (0+)" — so a negative
   wind is the other direction and a `mix` of `1.5` is an over-mix. Both are real
   and both compile.
-- ⚠️ **A `mix` key of exactly `0` is legal where a setup `mix` of `0` is not**, and
-  the difference is not an inconsistency. `PhysicsConstraint.update` opens with
-  `if (mix === 0) return;`, so muting a constraint for a stretch of an animation is
-  what a mix timeline is for; a constraint muted *at rest* does nothing at all
-  unless some animation rescues it, which is the silence `A23` was built for.
+- ⚠️ **A `mix` or `strength` key of exactly `0` is legal where a setup value of
+  `0` is not**, and the difference is not an inconsistency: a setup pose says what
+  the constraint IS and a key says what it is doing for a stretch. For `mix`,
+  `PhysicsConstraint.update` opens with `if (mix === 0) return;`, so muting a
+  constraint for part of an animation is what a mix timeline is for. For
+  `strength`, 0 takes the restoring term out of the velocity update and leaves
+  `damping` and `inertia` applied — the offset is not pulled back *while the key
+  holds*, which is "physics released" for that span, and the next key pulls it
+  back ([#727](https://github.com/firejune/rigc/issues/727)). At rest the two
+  part ways: a `strength` of 0 is a constraint nothing pulls back, which `A23`
+  refuses, and a `mix` of 0 is a constraint muted until an animation keys it
+  above 0 — the next bullet.
+- ⚠️ **A setup `mix` of `0` is legal when some animation keys it above 0** ([#743](https://github.com/firejune/rigc/issues/743)).
+  A constraint muted *at rest* is a rig whose physics is off until an animation
+  switches it on, which is a design rather than the silence `A23` was built for.
+  What `A23` refuses is the constraint nothing rescues: muted at setup and keyed
+  **nowhere**, or keyed **to 0 only**. [measured] the three are not a matter of
+  taste — muted-and-keyed-to-1 poses its bone exactly where the same rig resting
+  at 1 does, and keyed-to-0 poses it exactly where one with no timeline at all
+  does. The unnamed global timeline counts as a key for every constraint whose
+  own `mixGlobal` is set (§3.5), and so does an animation only a slider applies.
+- 📏 **What a `strength` key of `0` costs, measured through spine-core** on the
+  generated overlay fixture, stepping at 60 fps from `Physics.reset` (#727). With
+  no wind or gravity the offset coasts to a limit rather than running away — a
+  0.5 s release and a 2.0 s release end **0.95 %** apart — and the restoring key
+  takes it from 5.5063 back under 0.01 in **54 steps**. With `gravity -40` pulling,
+  the offset travels at terminal velocity for as long as the key holds (178 units
+  over 0.5 s, 843 over 2.0 s) and the restoring key still returns it to the
+  never-released run's own equilibrium, **39.999969 against 40.000000**, in 13
+  steps. No NaN in any of it. ⚠️ The neighbour that does NOT come back is the
+  reason `mass` keeps the narrow bound on a key: a keyed `mass` of `0` is NaN from
+  the first sub-step and **still NaN after the restoring key**, and a keyed
+  `damping` of `2` was still 6.9e4 two seconds later.
 
 On a track that names a `group`, one key's `v` may instead be a **map keyed by
 member name**, whose entries are each exactly the `v` above — or a `derive`
@@ -3478,7 +3641,15 @@ mass?, wind?, gravity?, mix?, fps?, limit? }`. These are emitted into the 4.3
 be **keyed over time** as `tracks` entries naming this constraint (§4.4); this
 table is the value at rest, and a timeline overrides it while it plays. `mass: 0` becomes an infinite inverse mass and `damping ≥ 1`
 never settles — both are `A23`, here and on every timeline key that states them
-([#610](https://github.com/firejune/rigc/issues/610)). Every field but `bone` and `note` must be a finite
+([#610](https://github.com/firejune/rigc/issues/610)). ⚠️ `strength: 0` is `A23` **here and not on a key**:
+at rest it is a constraint nothing pulls back, and on a key it is a release somebody
+asked for, which §4.4 states with the measurement behind it
+([#727](https://github.com/firejune/rigc/issues/727)). `mix: 0` is the one value
+here an animation can answer for: it rests the constraint **muted**, which is
+legal, and `A23` names it only when no timeline in any animation keys that `mix`
+above 0 — on a key it is the mute for a span (§4.4, [#743](https://github.com/firejune/rigc/issues/743)). None of the
+three is a compile error — a setup value this table states reaches the gate, where the whole
+file can be read; it is a **key** outside its bound that `build` refuses (§4.4). Every field but `bone` and `note` must be a finite
 number: a non-number is rounded to `NaN` and emitted as `null`, which the runtime
 reads as **zero**, so `"mass": "heavy"` used to ship a constraint that never
 settles with no word from anybody (#307).
@@ -4588,7 +4759,11 @@ so `v` is three numbers and not one.
 ⚠️ **A muted constraint with no timeline is a finding, not an idiom.** Turning a
 constraint on from an animation is the idiom (§4.10), so `A36`/`A37` only object to
 all-zero mixes when **no** animation keys that constraint's `mix`. If you mute one
-at setup, key it somewhere.
+at setup, key it somewhere. `A23` asks the same question of a physics constraint
+([#743](https://github.com/firejune/rigc/issues/743)) and asks it more sharply:
+it reads the key **values**, so a `mix` timeline keying 0 only is not a rescue,
+and it counts the unnamed global timeline for every constraint declaring
+`mixGlobal`. `A36`/`A37` take any non-empty key array.
 
 ---
 
@@ -4737,7 +4912,7 @@ or the key's position in its own track. These are the frequent ones, verbatim:
 | `two bones are called "X"` | bone names are the join key; rename one |
 | `two ik constraints are called "X" — a constraint resolves by name AND type (\`SkeletonData.findConstraint\`), so names are unique PER KIND: an ik and a transform constraint may share one, two of a kind may not` | §3.5 — rename one of the two. The kind in the sentence is the pair's own, so `two transform constraints are called "X"` is the same refusal on another kind; a name shared **across** kinds is not this error and never was one to fix |
 | `physics constraint "X" is declared in both the rig spec and the motion spec's physics table` | §4.6 — the rig spec declares a physics constraint's structure and the motion spec's `physics` table declares one outright; pick the file it belongs in. Per kind, like every other constraint name: an `ik` "X" in the rig spec beside a `physics` "X" here is two constraints and is not this error |
-| `skin "S" activates ik constraint "X", which skin "T" already activates; a constraint belongs to one skin` | §3.4.1 — a constraint runs under one skin or under all of them. The kind is in the sentence because `ik` "X" and `transform` "X" are two constraints, and each may belong to a different skin |
+| `skin "S" lists "X" under "transform", but the rig declares it as a "ik" constraint — a skin looks its constraints up by name AND type, so this one is a miss and the loader throws` | §3.4.1 — move the name to the list named after the constraint's own kind. A name the rig declares under **no** kind is the other miss and says so (`skin "S" activates ik constraint "X", which this rig does not declare`). ⚠️ A name listed by **several skins** is not an error and no longer was one as of [#725](https://github.com/firejune/rigc/issues/725): the lists are per-skin sets and a bone or constraint in two of them is active under either |
 | `slot "X" names bone "Y", which this rig does not declare` | add the bone, or fix the slot's `bone` |
 | `no setup pose for slot "X": give the motion spec a \`setup\` entry or the rig slot an \`attachment\`` | R3 — pick one file and declare it there. A slot **nothing** fills is exempt: its setup pose can only be "show nothing" and is not asked for |
 | `the setup pose shows attachment "A" on slot "X", which no skin and no manifest part fills` | §3.3 — the slot is emitted empty and nothing was ever going to fill it, so `A` resolves to nothing. Give the slot an attachment (a skin entry or a manifest part), or state the setup pose as `null` |
@@ -4760,6 +4935,8 @@ or the key's position in its own track. These are the frequent ones, verbatim:
 | `the triangles do not tile the outline: …` / `the triangles' outline is not one closed loop: …` | §3.4 — a doubled triangle, an unused vertex, a pinch or a hole in `triangles` |
 | `vertex N binds bone "X", which the rig does not declare as a bone` | §3.4 — an authored mesh's `weights` bind by NAME, like everything else in a rig spec. Fix the spelling, or declare the bone. The message names the skin, the slot, the placeholder and the vertex, because an index would name none of them |
 | `image "X.png" is not on disk at …` | fix the name, or point `--images` at the right directory |
+| `image "X.png": /…/X.png is a WebP image (…), not a PNG: its first 12 byte(s) are …` | the file is there and is not a PNG — the name ends in `.png` and the bytes decide. Re-export it as PNG; the same sentence says **truncated** for a PNG that runs out before its `IEND`, and then the repair is a whole copy (§0.2, [#732](https://github.com/firejune/rigc/issues/732)) |
+| `--atlas-in <pack>.atlas: N of its M page(s) cannot be read as PNG, and nothing was compiled against the pack — page "p.png": …` | the same, for every page of the pack at once, before the compile: re-export each named page as PNG under the name the atlas gives it (§0.2) |
 | `parts/iris_open.png is 96x64 but slot "iris" declares 96x60` | R5 — a manifest `states:` entry whose art is not the window the part declares. Re-export the PNG, or fix the part's `size`; a quad sized against art of another size is the silence `A06` exists for, and the window is what the quad is built from |
 | `plates/00_stage.png is 256x256 but the manifest window for "stage" is 250x256` | R5 — the same check on the part's unconditional `image`, against the window the crop gives it |
 | `region "00_stage" of <pack>.atlas (declared 256x256 by its offsets) is 256x256 but the manifest window for "stage" is 250x256` | R5 — the row above under `--atlas-in`, and the prefix is the whole point: it says which of the two rigc **measured**, because the remedy differs. A bare path is a loose PNG it opened and you re-export; a `region … of <pack>` was read out of the pack, and you repack or aim the part at another region. This is the size row of §0.2's four, with the message it actually prints |
@@ -4772,7 +4949,7 @@ or the key's position in its own track. These are the frequent ones, verbatim:
 | `animation "A" slot "X" attachment: attachment "N" is not in slot "X" under any skin (searched: default, alt) — the slot has: plain, trim` | §4.4 — the keyed name is in **no** skin, and the two clauses say where the compiler looked and what it would have taken. Fix the spelling, or give some skin a placeholder called `N`. A name only a NAMED skin fills is not this error and never was one to fix — it compiles, and the slot shows nothing under the skins that lack it. Before [#695](https://github.com/firejune/rigc/issues/695) the message read `attachment "N" is not in slot "X"` and was raised against the **default skin alone**, so it fired on correct rigs: any key into named-skin art, and every key in a rig with no default skin. `the slot has no attachments at all` is the same message where nothing fills the slot |
 | `animation "A" keys unknown bone "X"` | the track's `bone` is not in the rig |
 | `animation "A" bone "X" translatex: key value must be an array of 1 number(s)` | the value shape must match the property (§4.4) |
-| `animation "A" physics constraint "C" mass key at t=… is 0 (massInverse Infinity); must be > 0 — …` | §4.4 — a keyed physics value the runtime cannot use. The message names the bound and the `PhysicsConstraint.js` lines that make it one: `mass` and `strength` are `> 0`, `damping` is inside `(0, 1)`, `mix` is `0` or more, and `inertia`/`wind`/`gravity` are bounded nowhere ([#610](https://github.com/firejune/rigc/issues/610)) |
+| `animation "A" physics constraint "C" mass key at t=… is 0 (massInverse Infinity); must be > 0 — …` | §4.4 — a keyed physics value the runtime cannot use. The message names the bound and the `PhysicsConstraint.js` lines that make it one: `mass` is `> 0`, `damping` is inside `(0, 1)`, `mix` and `strength` are `0` or more, and `inertia`/`wind`/`gravity` are bounded nowhere ([#610](https://github.com/firejune/rigc/issues/610)). ⚠️ Those are the bounds a **key** is held to. A setup `strength` of `0` is refused too, but by `A23` rather than here, and with its own sentence — `physics "C" has strength 0; nothing pulls it back` ([#727](https://github.com/firejune/rigc/issues/727)) |
 | `a key carries both a named easing and a raw curve; pick one` | R6 |
 | `last key carries an easing but has nothing to ease to` | drop `ease`/`curve` from the final key |
 | `key times must strictly increase (at t=…)` | including after `lag` and `stagger` |
@@ -4833,12 +5010,16 @@ or the key's position in its own track. These are the frequent ones, verbatim:
 | `animation "A": "position" is a path constraint timeline, and this track names no constraint` | §4.12 — put the name in `"path"` |
 | `rgba value needs 4 channels, got 3` | §4.4 — an `rgba` key is `[r, g, b, a]`. It names no animation, slot or key time, and the only input that reaches it is a slot `rgba` key: the setup pose's `color` is refused earlier, by its own row, with the slot named |
 | `rgba2 value needs 7 channels, got 6` | §4.4 — an `rgba2` key is `[lr, lg, lb, la, dr, dg, db]`: the light colour with its alpha, then the dark colour **without** one. Six is the commonest way to get it wrong, because the dark half looks like it should take an alpha too — the format has no channel for it, and neither does the runtime's `setFrame`. Like the row above it names no animation or key time; the only input that reaches it is a slot `rgba2` key |
+| `rgb value needs 3 channels, got 4` · `alpha value needs 1 channel, got 2` · `rgb2 value needs 6 channels, got 7` | §4.4 — the separable shapes, refused in the words the two above use: an `rgb` key is `[r, g, b]`, an `alpha` key is `[a]`, an `rgb2` key is `[lr, lg, lb, dr, dg, db]`. Four channels on an `rgb` track is the likeliest way to get it wrong — the `rgba` spelling on the timeline that exists to leave the alpha alone — and seven on `rgb2` is the `rgba2` spelling. [#730](https://github.com/firejune/rigc/issues/730) |
+| `animation "A" slot "X" alpha: alpha key value must be [a]` | §4.4 — an alpha key's `v` is a one-element array like every other one-channel track, even though the file writes it bare (`{ time, value }`). The same row exists for each colour shape with its own spelling (`rgb key value must be [r,g,b]`, …) |
+| `animation "A" slot "X" alpha: key at t=T is V; an alpha is a number from 0 to 1 …` | §4.4 — the one colour key stored as a number, so the one nothing clamps on the way out. The runtime clamps the posed alpha only after interpolating, so a key outside 0..1 bends the curve toward a value no pose holds; state the value you mean. 0 and 1 themselves are taken |
+| `animation "A" slot "X": tracks "P" and "Q" both key the slot's alpha — a colour timeline poses its channels at every time …` | §4.4 — two colour tracks of one slot that pose a shared channel (`rgba` + `alpha`, `rgba` + `rgb`, `rgba2` + `rgb2`, …). Each poses its channels at every time, its setup value before its first key included, so the later in the file overwrites the other everywhere and one of them is read by nothing. Key each channel once: `rgb` and `alpha` for two halves on their own key times, `rgba` for both together. The channel named is whichever the two share — `light rgb`, `alpha`, `dark colour` |
 | `animation "A" bone "B" has no timeline "P" (it has: translate, translatex, translatey, scale, scalex, scaley, shear, shearx, sheary, rotate)` | §4.4 — a bone has exactly ten timelines and `P` is none of them. Fix the spelling — the single-axis ones are lower-case (`translatex`, not `translateX`). A **constraint** property is refused first, by its own row, naming the field its constraint's name goes in. When `P` is a slot timeline the message says so and where to put the name: `. "rgba" is a slot timeline — put the name in "slot"`. Before [#656](https://github.com/firejune/rigc/issues/656) all of them read `bone "B" cannot take slot property "P"`, which named the slot family whatever you had written and listed nothing |
-| `animation "A" group "G" has no timeline "P" (a bone group has: translate, translatex, translatey, scale, scalex, scaley, shear, shearx, sheary, rotate; a slot group has: attachment, rgba, rgba2; a physics constraint group has: inertia, strength, damping, mass, wind, gravity, mix, reset)` | §4.3, §4.4 — a group's family is decided by the property, and `P` is in none of the three tables, so there is no family to resolve the members as. Fix the spelling and the group becomes whichever family the property names. The group is refused before its members are looked up, so a member the rig does not declare is a **later** message; an unknown group NAME is an earlier one. Before [#661](https://github.com/firejune/rigc/issues/661) a group of bones read `animation "A" targets unknown slot "M"` and a group of slots got the slot row below, naming one family out of three |
-| `animation "A" slot "X" has no timeline "P" (it has: attachment, rgba, rgba2)` | §4.4 — a slot has exactly three timelines and `P` is none of them. Fix the spelling; a bone or constraint property written on a slot track is refused by its own row instead. Before [#650](https://github.com/firejune/rigc/issues/650) every other name compiled as an **rgba** timeline called `P`, and what you saw was `A00_ROUNDTRIP_PARSE` on the emitted file — or, for the one-channel spelling, `rgba value needs 4 channels, got 1` |
-| `animation "A" slot "X" rgba2: slot "X" declares no setup "dark", and an "rgba2" timeline poses a slot's dark colour …` | §3.3, §4.4 — the two-colour tint has a setup half and a keyed half, and the keyed half cannot exist without the other. `Slot`'s constructor allocates a dark colour only for a slot whose setup pose declares one, and `RGBA2Timeline` writes it unconditionally — so without the `dark` the file loads, and the first `state.apply` throws `TypeError: null is not an object` in the consumer's process. Give the slot the `dark` it holds at rest, or key `rgba` if only the light colour moves. Raised before the keys are read, with the slot named, for the same reason the row above is |
-| `N pair(s) of animation names have no one order: … "turn" / "Turn" (case) — they are one name in two cases, and which of them the editor puts first is not measured; rename one of them so they differ by more than letter case` | **R10** — rename until no pair is left. The kind in brackets says which of the editor comparator's four UNMEASURED choices decides the pair: `case` (a pure case tie), `number` (one number written two ways, or a run of digits against a word) or `separator` (make the first character that differs a letter or a digit). rigc keys `animations` in the editor's own comparator — natural and case-insensitive ([#539](https://github.com/firejune/rigc/issues/539), [#543](https://github.com/firejune/rigc/issues/543)) — so a pair that comparator settles is emitted rather than refused, and only the four choices nobody has measured are a compile error; on those, the editor's re-key repoints every slider whose animation moves index ([#535](https://github.com/firejune/rigc/issues/535)) |
-| `N pair(s) of skin names have no one order: … "Zulu" / "mike" (case) — folded to one case "Zulu" and "mike" order the other way round, so whether the editor folds SKIN names decides this pair` | **R11** — rename until no pair is left. The same shape as the row above with a **wider** family: #539 measured the editor's comparator for animation names and thereby ruled codepoint out, and nothing has ruled anything out for skin names, so a pair the candidates could disagree about is refused even where the animation rule would emit it. `Zulu`/`mike` and `mike10`/`mike2` build as animation names and are refused as skin names ([#541](https://github.com/firejune/rigc/issues/541)) |
+| `animation "A" group "G" has no timeline "P" (a bone group has: translate, translatex, translatey, scale, scalex, scaley, shear, shearx, sheary, rotate; a slot group has: attachment, rgba, rgb, alpha, rgba2, rgb2; a physics constraint group has: inertia, strength, damping, mass, wind, gravity, mix, reset)` | §4.3, §4.4 — a group's family is decided by the property, and `P` is in none of the three tables, so there is no family to resolve the members as. Fix the spelling and the group becomes whichever family the property names. The group is refused before its members are looked up, so a member the rig does not declare is a **later** message; an unknown group NAME is an earlier one. Before [#661](https://github.com/firejune/rigc/issues/661) a group of bones read `animation "A" targets unknown slot "M"` and a group of slots got the slot row below, naming one family out of three |
+| `animation "A" slot "X" has no timeline "P" (it has: attachment, rgba, rgb, alpha, rgba2, rgb2)` | §4.4 — a slot has exactly six timelines — every one the format has — and `P` is none of them. Fix the spelling; a bone or constraint property written on a slot track is refused by its own row instead. Before [#650](https://github.com/firejune/rigc/issues/650) every other name compiled as an **rgba** timeline called `P`, and what you saw was `A00_ROUNDTRIP_PARSE` on the emitted file — or, for the one-channel spelling, `rgba value needs 4 channels, got 1` |
+| `animation "A" slot "X" rgba2: slot "X" declares no setup "dark", and an "rgba2" timeline poses a slot's dark colour …` — and the same with `rgb2` | §3.3, §4.4 — the two-colour tint has a setup half and a keyed half, and the keyed half cannot exist without the other. `Slot`'s constructor allocates a dark colour only for a slot whose setup pose declares one, and `RGBA2Timeline` writes it unconditionally — so without the `dark` the file loads, and the first `state.apply` throws `TypeError: null is not an object` in the consumer's process. Give the slot the `dark` it holds at rest, or key `rgba` (for `rgb2`, `rgb`) if only the light colour moves. `RGB2Timeline` was measured to throw the same way before `rgb2` joined the refusal ([#730](https://github.com/firejune/rigc/issues/730)). Raised before the keys are read, with the slot named, for the same reason the row above is |
+| `N pair(s) of animation names have no one order: … "Fx/a" / "fx/b" (folder) — "Fx/a" and "fx/b" sit in the sibling folders "Fx" and "fx", which the comparator leaves in one place …; rename one of the two folders so they differ by more than letter case, spacing or a leading zero` | **R10** — rename until no pair is left. The kind in brackets says which of the three things the five stored round trips leave open decides the pair: `number` (two digit runs that are each one number written twice, pointing opposite ways), `separator` (a whitespace character that is not a space) or `folder` (two sibling folders the comparator cannot separate). rigc keys `animations` in the editor's own comparator, read off `fixtures/editor-order/probe{1..5}.{in,out}.json` ([#728](https://github.com/firejune/rigc/issues/728)) — so a pair those files settle is emitted rather than refused, **including a pair that differs only in case**, whose order is then the one your spec declared. On the three that are left, the editor's re-key repoints every slider whose animation moves index ([#535](https://github.com/firejune/rigc/issues/535)) |
+| `N pair(s) of skin names have no one order: … "Fx/a" / "fx/b" (folder) — …` | **R11** — rename until no pair is left. The same shape and the same three kinds as the row above, because it is the same comparator: two of the five round trips carried one name list as both collections and both came back in one order ([#728](https://github.com/firejune/rigc/issues/728)). ⚠️ This row was **wider** than R10's until then — `Zulu`/`mike` and `mike10`/`mike2` built as animation names and were refused as skin names ([#541](https://github.com/firejune/rigc/issues/541)) — and both build now |
 | `slot "patch": placeholder "patch" is filled by the "default" skin AND by skins "zulu", "mike", and the Spine editor has no way to hold that … Move the default skin's entry for this slot into a named skin — call it "base"` | **R12** — do what it says: move that entry out of `default` into a named skin. The editor has no representation for a placeholder the default skin shares with a named one, in either spelling, and §3.4.2 has both measurements. Renaming the placeholder does not help; the shape is what is refused |
 | `N attachment name collision(s): a placeholder that more than one skin fills is emitted with the name "<skin>/<placeholder>" … slot "patch": skin "base" placeholder "zulu/patch" and skin "zulu" placeholder "patch" would both be named "zulu/patch"` | **R12** — rename the placeholder or the skin. rigc composes an attachment name for every placeholder more than one skin fills (§3.4.2), and this fires when a composed name is one another entry in the same slot already answers to — including a plain name in the default skin, which composed nothing. Both sites are named; either rename ends it |
 
@@ -4937,7 +5118,7 @@ Fix A00 and run it again ([#568](https://github.com/firejune/rigc/issues/568)).
 | `A03_REGION_WIDTH_HEIGHT_FINITE` | both | a region loaded `NaN` or a non-positive size — the attachment has no `image` and no `width`/`height`. **SKIP** when the skeleton carries no region attachment ([#580](https://github.com/firejune/rigc/issues/580)) |
 | `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) **SKIP** when the skeleton carries no mesh attachment ([#580](https://github.com/firejune/rigc/issues/580)) |
 | `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**. **SKIP** when no animation carries a timeline at all ([#580](https://github.com/firejune/rigc/issues/580)). Timelines with no `curve` on any key still PASS: every timeline name is checked against the channel table whether or not a curve sits on one |
-| `A06_ATLAS_PAGE_SIZE_MATCHES_PNG` | both ◑ | the atlas `size:` disagrees with the PNG on disk, **or** a region's rectangle is not inside the page it names — rotation honoured, so a region at `rotate: 90` or `270` occupies `height x width` of the page and a region that fits only because it is turned is inside it. The message names the region, the rectangle it occupies, the page and the page's size. That clause is **validity** and runs under both profiles ([#694](https://github.com/firejune/rigc/issues/694)): a rectangle outside its page makes `u2 > 1` and samples whatever the wrap mode returns, and `--atlas-in` already refuses the same rectangle at compile time (§0.2). Under `spine-html` also: `pma`, rotation, and two regions on one page over the same texels — a packed page must be **one part covering it exactly** (the unpacked convention) or a **tiling** ([#266](https://github.com/firejune/rigc/issues/266)), and what that message names is the pair that shares texels. **SKIP** when the atlas declares no page ([#580](https://github.com/firejune/rigc/issues/580)) |
+| `A06_ATLAS_PAGE_SIZE_MATCHES_PNG` | both ◑ | the atlas `size:` disagrees with the PNG on disk — the message names the ratio it measured on **each** axis and the header that states the same art truthfully, and §0.2 has the whole of it ([#715](https://github.com/firejune/rigc/issues/715)): a runtime maps a region as a fraction of the DECLARED size and never reads the texture's own, so such a page draws, and what it breaks is every reader that addresses the page in texels. A uniform ratio is a `size:`/`scale:` pair away from honest and the message prints it; two ratios are not, because `scale:` carries one number, and the message says so rather than offering a header that would not work. **Or** a region's rectangle is not inside the page it names — rotation honoured, so a region at `rotate: 90` or `270` occupies `height x width` of the page and a region that fits only because it is turned is inside it. The message names the region, the rectangle it occupies, the page and the page's size. That clause is **validity** and runs under both profiles ([#694](https://github.com/firejune/rigc/issues/694)): a rectangle outside its page makes `u2 > 1` and samples whatever the wrap mode returns, and `--atlas-in` already refuses the same rectangle at compile time (§0.2). Under `spine-html` also: `pma`, rotation, and two regions on one page over the same texels — a packed page must be **one part covering it exactly** (the unpacked convention) or a **tiling** ([#266](https://github.com/firejune/rigc/issues/266)), and what that message names is the pair that shares texels. **Or** the page file is not a PNG at all, and then nothing about its size is measured: the message carries the page's path and the size the atlas declares, and names what the file is by its first bytes — one of WebP, JPEG, GIF, KTX, KTX2 by its signature, or no image format rigc recognises, the bytes in hex either way — or calls it **truncated** when it begins as a PNG and runs out before its `IEND` (§0.2, [#732](https://github.com/firejune/rigc/issues/732)). That clause is validity too: nothing in rigc can read such a page back. **SKIP** when the atlas declares no page ([#580](https://github.com/firejune/rigc/issues/580)) |
 | `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. ⚠️ An atlas with **no page block at all** — no non-blank line — is not one of those: its subject is absent, so this reports **SKIP** naming the byte count it read, and so do the four rules below whose subject is a page ([#608](https://github.com/firejune/rigc/issues/608)). A rig whose skins need no art writes exactly that file (§3.4), and before #608 this row refused it with two findings naming a page block that was not there. What an empty atlas does **not** excuse is an attachment that wants a region out of it — that is `A08` |
 | `A08_REGION_NAMES_MATCH_ATTACHMENTS` | both | three things, and the message says which: an attachment whose `path` names **no region** of this atlas; a `path` carrying **stray whitespace**, printed quoted so you can see it; an **atlas region name** carrying stray whitespace (`A07` names that same line with its line number). The first two are read off the raw file **before** the loader is asked, so the miss is named here with the skin, the slot, the placeholder and the attachment's own name — the four things `AtlasAttachmentLoader`'s own `Region not found in atlas: <path> (attachment: <name>)` does not carry. Until [#589](https://github.com/firejune/rigc/issues/589) they were unreachable: the loader threw first and the miss arrived as `A00_ROUNDTRIP_PARSE`. There is no `spine-html` clause here any more — a placeholder is free to differ from the region its `path` names ([#574](https://github.com/firejune/rigc/issues/574)) **SKIP** when no attachment names a region *and* the atlas declares none — both of its subjects at once ([#580](https://github.com/firejune/rigc/issues/580)) |
 | `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 |
@@ -4950,11 +5131,11 @@ Fix A00 and run it again ([#568](https://github.com/firejune/rigc/issues/568)).
 | `A16_SKELETON_VERSION_4_3` | both | the `skeleton.spine` label is not on the 4.3 line (`4.3`, `4.3.N`, `4.3.N-suffix`) |
 | `A17_ATLAS_PAGE_FILES_EXIST` | both | a page the atlas declares is not a file. Check `--images` and `--out`. **SKIP** when the atlas declares no page ([#580](https://github.com/firejune/rigc/issues/580)) — as it is for `A06`, `A19` and `A27`; see `A07` ([#608](https://github.com/firejune/rigc/issues/608)) |
 | `A18_DETERMINISTIC_EMIT` | both | a second compile of the same inputs differed. That is a compiler bug, not a spec bug — report it |
-| `A19_OVERLAY_PNGS_HAVE_ALPHA` | renderer | an overlay part image can never be transparent: no alpha channel (colour type 4 or 6) and no `tRNS` chunk either, so it would paint a solid rectangle over what is behind it. Re-export it as RGBA, or as an indexed / greyscale PNG that keeps its `tRNS`. Only the full-stage base plate may be opaque. Indexed-with-`tRNS` — the usual output of ImageMagick, "Export as PNG-8", GIMP's indexed mode, aseprite and pngquant — **passes**: it is transparent art. On a **shared** page the question is asked per REGION over the decoded page rather than per file, because a packed page's own file all but always declares transparency — its gutter is transparent — and the file-level question would then be answered by the packing rather than by the art ([#266](https://github.com/firejune/rigc/issues/266)). ⚠️ **That scan states its verdict over the texels it READ, and never over texels that are not on the page** ([#705](https://github.com/firejune/rigc/issues/705)): a rectangle partly on its page is judged over the part that is on it, and the message carries both counts — `opaque in every one of the 77 texels of its 12x8 rectangle at -1,-1 … the other 19 of the 96 it declares are not on the page and are not measured here`. A rectangle with **no** texel on the page is reported **not measured** by name — the region, its rectangle, the page image's size, and the pointer to `A06`, which is the rule that judges a region's rectangle — and no verdict about opacity is printed at all. 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 **SKIP** when the atlas declares no page ([#580](https://github.com/firejune/rigc/issues/580)) |
+| `A19_OVERLAY_PNGS_HAVE_ALPHA` | renderer | an overlay part image can never be transparent: no alpha channel (colour type 4 or 6) and no `tRNS` chunk either, so it would paint a solid rectangle over what is behind it. Re-export it as RGBA, or as an indexed / greyscale PNG that keeps its `tRNS`. Only the full-stage base plate may be opaque. Indexed-with-`tRNS` — the usual output of ImageMagick, "Export as PNG-8", GIMP's indexed mode, aseprite and pngquant — **passes**: it is transparent art. On a **shared** page the question is asked per REGION over the decoded page rather than per file, because a packed page's own file all but always declares transparency — its gutter is transparent — and the file-level question would then be answered by the packing rather than by the art ([#266](https://github.com/firejune/rigc/issues/266)). ⚠️ **That scan states its verdict over the texels it READ, and never over texels that are not on the page** ([#705](https://github.com/firejune/rigc/issues/705)): a rectangle partly on its page is judged over the part that is on it, and the message carries both counts — `opaque in every one of the 77 texels of its 12x8 rectangle at -1,-1 … the other 19 of the 96 it declares are not on the page and are not measured here`. A rectangle with **no** texel on the page is reported **not measured** by name — the region, its rectangle, the page image's size, and the pointer to `A06`, which is the rule that judges a region's rectangle — and no verdict about opacity is printed at all. ⚠️ **A page whose IMAGE is not the size the atlas declares for it is the same non-measurement for every region on it** ([#715](https://github.com/firejune/rigc/issues/715)), and #705's clause does not cover that case: a page rescaled after packing leaves most rectangles partly on it, at coordinates that address a different part of the picture, so the scan came back with a confident verdict over texels nobody had located — on a two-region pack at a uniform 0.5 an opaque part's failure **disappeared**, the scan having found a transparent texel 32 texels away from it. The row names the page's two sizes and points at `A06`, which judges the page grid and prints the header that repairs it (§0.2). It stays a failure rather than becoming a SKIP because a SKIP is per ASSERTION: it would delete the verdicts on every other part of the same page, and an assertion cannot be skipped and failed at once without the report counting it twice. Before #705 the walk was silent about its own reach, so a part nobody could read printed *opaque in every one of its 12x8 texels* over zero of them, which is a refusal pointing at the wrong file: the art it names may be transparent, and the repair is the rectangle in `A06`'s row above. ⚠️ **A page file that cannot be read as PNG at all is the same non-measurement for every part on it** ([#732](https://github.com/firejune/rigc/issues/732)): one row per page naming its parts and pointing at `A06`, which names what the file is — where it used to print `threw: cannot decode PNG …: unexpected end of file`, an inflate error about a file that was never a PNG. **SKIP** when the atlas declares no page ([#580](https://github.com/firejune/rigc/issues/580)) |
 | `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)) |
-| `A23_PHYSICS_CONSTRAINT_EFFECTIVE` | both | a physics constraint that drives no component, is muted by `mix: 0`, has `mass: 0`, has `strength: 0`, or has `damping` outside `(0, 1)` so it never settles — **at rest, and on every physics timeline key** ([#610](https://github.com/firejune/rigc/issues/610)). The timeline arm reads each key through the runtime's own `PhysicsConstraint*Timeline.set`, so a keyed `mass` is judged as the `massInverse` it becomes, and the detail names the animation, the constraint, the key time, the value and the bound. One difference between the two arms, and the runtime is the reason for it: a **key** of `mix: 0` is accepted, because `update` opens with `if (mix === 0) return;` and muting a constraint for a stretch is what a mix timeline is for — the editor's own `sack-pro` example keys it there on 24 of its 36 mix keys. `inertia`, `wind`, `gravity` and the top of `mix` are bounded nowhere, at rest or keyed. **SKIP** when the skeleton declares no physics constraint ([#580](https://github.com/firejune/rigc/issues/580)) — the same sentence `A36` and `A37` have always printed for their own constraint types |
+| `A23_PHYSICS_CONSTRAINT_EFFECTIVE` | both | a physics constraint that drives no component, rests at `mix: 0` with **no timeline in any animation keying that `mix` above 0**, has `mass: 0`, has `strength: 0`, or has `damping` outside `(0, 1)` so it never settles — **at rest, and on every physics timeline key** ([#610](https://github.com/firejune/rigc/issues/610), [#743](https://github.com/firejune/rigc/issues/743)). The timeline arm reads each key through the runtime's own `PhysicsConstraint*Timeline.set`, so a keyed `mass` is judged as the `massInverse` it becomes, and the detail names the animation, the constraint, the key time, the value and the bound. Two differences between the two arms, and the runtime is the reason for both: a **key** of `mix: 0` is accepted, because `update` opens with `if (mix === 0) return;` and muting a constraint for a stretch is what a mix timeline is for — the editor's own `sack-pro` example keys it there on 24 of its 36 mix keys — and a **key** of `strength: 0` is accepted, because it releases the constraint for the span with `damping` and `inertia` still applied and the next key pulls the offset back, measured through spine-core at no NaN, a coast to a limit and a return in 54 steps ([#727](https://github.com/firejune/rigc/issues/727)). As a **setup** value `strength: 0` is still refused by the arm above, and `mix: 0` is refused only when nothing keys it above 0. The `mix` branch above is why `mix` is the one setup value a key can answer for: at rest the constraint is **inert** rather than broken, so a rig that rests muted and is keyed above 0 is refused by nothing, while a rig resting at `mass: 0` is `massInverse` Infinity before anything plays and no key reaches back into that. The detail of the refusal says both halves and how many animations were searched: `physics "C" has mix 0 and none of the 3 animations keys its mix above 0; it is muted — rest it above 0, or key its mix above 0 in an animation`. The search counts the unnamed global timeline for every constraint whose own `mixGlobal` is set, reads each key through the runtime's accessor, and takes an animation a slider applies like any other. `inertia`, `wind`, `gravity` and the top of `mix` are bounded nowhere, at rest or keyed. `ingest` does not carry a constraint that drives no component into the spec it writes: it omits it with its timelines and reports `PHYSICS_DRIVES_NOTHING` ([INGEST §2.0](INGEST.md), [#731](https://github.com/firejune/rigc/issues/731)), so this sentence is met on a file, never on a decompiled rebuild. **SKIP** when the skeleton declares no physics constraint ([#580](https://github.com/firejune/rigc/issues/580)) — the same sentence `A36` and `A37` have always printed for their own constraint types |
 | `A24_AXIS_SPACE_STROKE` | archetype | a bone under the rig's `axisBone` was keyed with a screen-space Y component, or the axis bone itself was keyed. **SKIP** when the rig declares no axis bone, and also when no animation keys that bone or anything under it ([#580](https://github.com/firejune/rigc/issues/580)) |
 | `A25_DETACHED_BONE_PARENTAGE` | archetype | a bone the rig declares `detached` is a descendant of the bone it must never hang under |
 | `A26_SLOT_DRAW_ORDER` | archetype | the emitted slots are not the rig's slot table — a slot is out of order, is not in the table at all, or is in the table and missing from the skeleton (§3.3). **SKIP** when the rig declares no canonical slot order. ⚠️ A skeleton with **no** slot beside a rig that declares some is **not** a skip, and it is the one rule in this family where an empty loop is not a vacuous pass ([#580](https://github.com/firejune/rigc/issues/580)): the completeness clause reads it as every declared slot lost and names them, which is the maximal case of what [#575](https://github.com/firejune/rigc/issues/575) filed |
@@ -4974,8 +5155,9 @@ Fix A00 and run it again ([#568](https://github.com/firejune/rigc/issues/568)).
 | `A40_SLIDERS_COMPOSE_ON_A_SHARED_TARGET` | both | two or more sliders whose animations key the same timeline, where a later one is not `additive` — it writes that property outright at `mix: 1` and every earlier slider on it is dead (§3.5.2). Also fires when the shared timeline **cannot** be applied additively (a slot colour, an attachment swap, a draw order, an ik mix, a path's `spacing`, most physics properties), where `"additive": true` is not the fix and one of the two has to go. ⭐ Which of the two it is, is **posed rather than read off `Timeline.additive`**: the shared timeline is applied twice with `add` set and the detail says what it did ([#655](https://github.com/firejune/rigc/issues/655) — two classes declare that flag falsely about themselves, so a path constraint's `mix` and a slider's `time` were refused although they compose). The detail names the bone or slot and the property, every slider keying it in `constraints` order with its flag, which one wins today, and the class that was posed. Four shapes are deliberately not findings: a slider below `mix: 1` or with its `mix` keyed (the apply is then a lerp from the current pose, not an overwrite), two `skinRequired` sliders no skin activates together, two sliders on different properties, and a shared timeline that writes **nothing a pose holds** — an `events` timeline fires no event under a slider (`firedEvents` is null), so neither slider has anything there for the other to erase. **SKIP** when fewer than two sliders are at full authority; a PASS means two were compared |
 | `A41_PHYSICS_SURVIVES_EDITOR_ROUND_TRIP` | both | a physics constraint driving a component the **Spine editor** cannot hold, on a rig that declared `invariants.editorRoundTrip` (§3.7). The editor's physics model holds `x` and `y` only, with no cap on how many at once, so a constraint driving `rotate`, `scaleX` or `shearX` is imported, exported and handed back driving **nothing** — measured over three rigs and twelve constraints with the predictions written first ([#540](https://github.com/firejune/rigc/issues/540)). The detail names the constraint and each component. ⚠️ rigc's own output is correct — every runtime plays a rotation jiggle — so this is opt-in and the default is *not* silence: on a rig that declares nothing it **SKIPs**, and the SKIP names the constraint and the component anyway, so an author learns without having asked. Fix by driving the constraint in `x`/`y`, or by dropping the declaration if the rig never goes near the editor. Disjoint from `A23_PHYSICS_CONSTRAINT_EFFECTIVE` by construction: A23 refuses an **empty** driven set, which is what comes back from the editor, and this refuses a non-empty one that will not survive going in. **SKIP** also when the rig declares the editor and carries no physics constraint at all |
 | `A42_DRIVEN_CONSTRAINTS_UPDATE_AFTER_THEIR_DRIVER` | both | a slider whose animation keys a property of a constraint **at or before it** in `constraints` (§3.5.2) — a slider's `mix` or `time`, an ik or transform mix, a path `position`, `spacing` or `mix`, any physics value. That array is the update order for every kind, and each constraint reads its own applied pose when its turn comes — `Slider.update` takes `mix` as the alpha it applies with and `time` as the time it applies at, `PhysicsConstraint.update` returns on `mix` 0 before reading the rest — so the key lands after the only read of it and `Posed.resetConstrained` discards it before the next frame: what the driven constraint drives is dead at every position of the driving dial, although its pose still holds the number ([#658](https://github.com/firejune/rigc/issues/658), [#665](https://github.com/firejune/rigc/issues/665)). The detail names the slider, the driven constraint with its kind, both array indices, the property, the runtime class whose `update` reads it, and the animation the key sits in. Fix by moving the driver earlier, or by keying that property from a slider that already is. **The two indices equal is the same failure**: a slider cannot key its own `mix` or `time`, and one muted at setup that keys its own `mix` up never applies anything at all — `A37` is silent there, because it asks whether *an* animation keys the mix and not which one. **Two shapes it deliberately leaves out**, both measured: a `physics` `reset` key, which fires on a crossed frame time and so never fires from a slider at all, in either order — the reorder would repair nothing; and a physics timeline naming no constraint, which is every physics constraint declaring that property global and IS refused for the ones already run. Disjoint from `A40` by construction: `A40` asks who writes a shared property last and excludes every slider whose `mix` is keyed, this asks whether anything reads what was written. **SKIP** when the skeleton declares no slider, and when no slider's animation keys a constraint property — that SKIP names any `reset` keys it found — a pass means a driver and a driven were compared |
-| `A43_TWO_COLOR_TINT_LOADS_AND_POSES_AS_WRITTEN` | both | a slot's `dark` (§3.3) or an `rgba2` timeline (§4.4) that the runtime does not hold as the file states it. Three shapes, all of which parse in silence: a `dark` the slot reader **drops** — it takes the field through a truthiness test, so `""` is discarded without a word and the slot renders with one colour; a `dark` that is **not six hex digits** — `Color.setFromString` slices fixed offsets and stores whatever `parseInt` gives back, so `"4020"` loads a channel of `NaN`; and an `rgba2` timeline on a slot with **no `dark` at all**, where the runtime allocates no dark colour and the first `state.apply` throws in the consumer's process. The keyed half is read by posing: the animation is stepped to each key's own time and the posed `color` and `darkColor` are compared against the hex the key states, to half a quantisation step (`1/510`). The detail names the slot, the value found and the value required. ⚠️ The required value is parsed **here** and not through `Color.fromString`, because a check that read it out of the parser it is checking would agree with that parser whatever it did. `compile.ts` refuses the third shape outright in a rig rigc builds; this is the same fact held against a skeleton it did not write. **SKIP** when no slot declares a `dark` and no animation keys an `rgba2` — there is then no two-colour tint to read back |
+| `A43_TWO_COLOR_TINT_LOADS_AND_POSES_AS_WRITTEN` | both | a slot's `dark` (§3.3) or an `rgba2` / `rgb2` timeline (§4.4) that the runtime does not hold as the file states it. Three shapes, all of which parse in silence: a `dark` the slot reader **drops** — it takes the field through a truthiness test, so `""` is discarded without a word and the slot renders with one colour; a `dark` that is **not six hex digits** — `Color.setFromString` slices fixed offsets and stores whatever `parseInt` gives back, so `"4020"` loads a channel of `NaN`; and an `rgba2` or `rgb2` timeline on a slot with **no `dark` at all**, where the runtime allocates no dark colour and the first `state.apply` throws in the consumer's process. The keyed half is read by posing: the animation is stepped to each key's own time and the posed `color` and `darkColor` are compared against the hex the key states, to half a quantisation step (`1/510`). The detail names the slot, the value found and the value required. ⚠️ The required value is parsed **here** and not through `Color.fromString`, because a check that read it out of the parser it is checking would agree with that parser whatever it did. `compile.ts` refuses the third shape outright in a rig rigc builds; this is the same fact held against a skeleton it did not write. An `rgb2` key's light colour is compared over its three channels only: the light alpha is not its to state, and that it is left where it was is measured in the selftest (`S85`). **SKIP** when no slot declares a `dark` and no animation keys an `rgba2` or `rgb2` — there is then no two-colour tint to read back |
 | `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 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 |
 
 `both ◑` marks a mixed assertion: its validity half always runs and its policy
 clauses are gated by profile.
@@ -6722,9 +6904,9 @@ one key, deform blocks counted at each of their three levels;
 ⇒ in rigc: only `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** and refuses the name
-sets on which its leading-zero, case-tie, digit-against-word or separator
-behaviour — the four choices still unmeasured — would decide a pair. Sorting the
+they are re-keyed. 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
 included, and refuses none of them; the codepoint rule that stood until
 [#543](https://github.com/firejune/rigc/issues/543) reproduced 102 and refused
@@ -6747,10 +6929,13 @@ does — `skins` carries ordinals in the binary half, `skins[readInt()]` for an
 attachment timeline and `skins[skinIndex]` for a linked mesh — so this is the
 `animations` defect (#535) in the collection nobody had checked. ⇒ in rigc: R11.
 
-⚠️ **What that measurement does *not* settle is which comparator.** `alpha, mike,
-zulu` is the order codepoint, case-folding and natural order all produce, so unlike
-the animations case nothing here refutes anything, and rigc refuses any skin-name
-pair the candidates could disagree about (R11).
+✅ **Which comparator it is was the open half of that, and #728 closed it.**
+`alpha, mike, zulu` is the order codepoint, case-folding and natural order all
+produce, so #541's rig refuted nothing and rigc refused any skin-name pair the
+candidates could disagree about. Two of the five round trips carried one name list
+as **both** collections and both came back in one order, so `skins` and
+`animations` share one comparator — measured, not inferred — and the wider skin
+refusal is gone (R11).
 
 ✅ **The two readings this replaces.** A pull request once called `skins` *measured
 preserved*, on the strength of a one-skin rig where a one-element array comes back