spine-rigc 1.9.2 → 1.9.3

package/docs/AUTHORING.md

@@ -210,7 +210,7 @@ What the flags mean:
 | `--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. On `render` and `check` a rigc build whose `skeleton.model.json` is `rigc-compiled/3` or `/2` needs no atlas at all: with no `--atlas` and no atlas beside it, it is drawn from the document's `pages`, the same frames, geometry and figures as with it, and the `atlas` line says `— not there`. An atlas that is there is still read, and held to `pages`: one that differs (edited after the build) is drawn through spine-core, and the `poser` line names the first difference. A build drawn through an atlas that is not there — a `rigc-compiled/1` document, or a build the core refuses — is refused `nothing at <the atlas>: … is drawn through its atlas (<why>)`, exit 2, nothing written; a Spine export without its atlas is refused `nothing at <the atlas>` as it always was. A directory whose files are not one build — a `skeleton.json` or a `skeleton.atlas` from another build beside this one's `skeleton.model.json` — is drawn through spine-core where the runtime can load the pair, the `poser` line naming the two digests or the atlas's first difference; where it cannot, it is refused `<skeleton> does not load against <the atlas>: spine-core draws this pair (<the poser line's why>) and could not resolve it — "<the runtime's own words>". <dir> is not one build: …`, exit 2, nothing written (`RC18`) — another build's skeleton beside this build's atlas typically ends `"Region not found in atlas: <region> (attachment: <name>)"`. Rebuild, or put the build's own three files back beside each other. A Spine export beside an atlas it was not exported with is refused in the same words, ending `The skeleton and the atlas are not one pair`. An atlas copied from another build's directory usually stops earlier, at its pages — their paths are relative to the directory it was written in — and is refused naming the first one: `nothing at <the page>: <the atlas> names it as a page, and spine-core draws this pair through that atlas (<why>). … <dir> is not one build: …`, exit 2, nothing written (`RC18`); an export whose atlas names a page that is not there is refused the same way, ending `and the page has to be there`. A build moved or copied whole away from the directory it was built in stops at the same place, on either poser, and is refused naming the page and the file that names it: `nothing at <the page>: <the skeleton.model.json> names it as a page, and the core draws this build from it. A page path is relative to the build's directory, so a build moved or copied away from the directory it was built in names pages that are not here — build it again where it is, or build it with --copy-images, which writes its pages beside it` (under `--poser spine`, `<the atlas> names it as a page, and spine-core draws this pair through that atlas (--poser spine)` with the same ending), exit 2, nothing written (`RC21`); only where the core refused the files does a page refusal say the directory is not one build. `bench --bones` and `rigc bonedist` — on its `--candidate` and on its `--reference` — refuse a pair the runtime cannot load in the words above with `spine-core poses this pair (bonedist's candidate: …)` or `(bonedist's reference: …)`, exit 2, nothing written (`RC20`); they read no page image, so a build whose pages are elsewhere is measured as it is in place. A `skeleton.json` that is not JSON is refused `rigc: cannot read <the file>: <the parser's words> (line N, column N)`, exit 2, by `render`, `check`, `bench` and `bonedist` as by every other command that reads one (`RC22`). With the atlas gone, `check` on a `rigc-compiled/3` build reads its pages' `scale:` lines off the document, so its texture note and `check.json`'s `textureFrom.candidateScales` are what they are with the atlas; on a `/2` build its texture note says whether the atlas declares a `scale:` line is not read (that document does not state one), and `candidateScales` is `null` (`RC13`). **`vote` and `preview` take it more than once**: `vote` 2–4 times, one per pane, labelled A, B, C, D in the order given; `preview` any number of times, one pane per candidate in the order given, each headed by its path and its gate line, and the same skeleton twice (a directory and its `skeleton.json` are one) is refused by name. `--atlas` goes with one candidate only. 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` (each candidate's own first, with several), 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` and a several-candidate `preview`, so is a name that only *some* candidates have, naming the one that lacks it |
 | `--geometry` | `render` only: also write a `geometry.json` into each frame directory — per frame, every bone's world transform and every slot's region or mesh vertices in world units after skinning, plus each attachment's rest geometry and topology, on the frames' own grid and viewport. Every other file is byte for byte what the render writes without it. Refused with `--slot`/`--hide`, because the geometry is the whole pose whatever is drawn — **§8.2** |
-| `--poser` | `render`, `check` and `explain`: `core` or `spine` — on `render` and `check`, which implementation poses the frames (on `check`, the candidate's; the reference side is pixels either way). By default a **rigc build** (the `skeleton.model.json` `build` writes; its atlas, when one is named or present, the one beside it) is posed by rigc's own core and a **Spine export** by spine-core; the render prints a `poser` line saying which and why, and so does the check report (`check.json`'s `poser`, and the pictures' `frames.json` under `--out`; `bench --frames` prints the same line). A concave or an inverse clip is posed by the core. Where the input cannot carry the core, or the core refuses it, the render poses it through spine-core and the `poser` line says why, in one of these words: `no skeleton.model.json beside` (a Spine export) · `is not beside` (`--atlas` names an atlas outside the build's directory) · `does not describe` (a model document whose bones, slots or animations are not the skeleton's) · `is not the skeleton.json` (a `skeleton.json` whose SHA-256 is not the `spine.sha256` its model document records — edited or replaced after the build — both digests named) · `the polygon is not simple` (a clip polygon two of whose edges cross or touch, the slot named) · `the "default" skin names` (no `--skin`, and the default skin names a skin-required bone or constraint, each named) · `and no "default" one` (no `--skin`, and skins with none named `default` — spine-core draws nothing there either, so the render stops at `there is nothing to draw`, exit 2, and only `--poser core` prints this refusal) · `depends on the runtime's previous pass` (a constraint moves a posed bone from a bone that a constraint writes into while that bone is inactive, all four named) · `--poser spine` (asked for). Any other refusal of the core's — an unreadable model document among them — reads `the core refused` and then the core's own words. `--poser core` on an input that cannot carry it is refused in the same words (exit 2, nothing written); `--poser spine` forces the runtime. A fallback whose pair the runtime cannot load — another build's `skeleton.json` or atlas beside this build's document, or an export beside an atlas it was not exported with — is not drawn: it is refused `… does not load against <the atlas>: spine-core draws this pair (<why>) and could not resolve it — "<the runtime's own words>"` — or, where the atlas names a page that is not there, `nothing at <the page>: …` — exit 2, nothing written, on `render`, `render --geometry`, `check` and `bench --frames` alike; under `--poser core` the same pair is that flag's refusal, in the words above (`RC18`; the `--candidate` row says what to change). The repository's selftest renders one probe per reason above and holds this list to the lines they print (`RC09`). Both posers draw the same frames, geometry and framing box to the bit on every corpus (issue #968), and `check` through either writes the same report, `check.json` and pictures but for the poser it names on every tree row. A rigc build the core poses reads nothing through spine-core on `render`, `render --geometry` and `check`, `--texture-from` included (and the check `bench --frames` folds in; `bench`'s own `validate`, like `build`'s, is the runtime's round trip by design): its bone tree, slot list and slot roster come off its model document; so do the order its animations and skins are listed in, its stage and its pages' `scale:` lines, on a `rigc-compiled/3` document (`editorOrder`, `stage`, `pages`) — a `/2` or `/1` document states none of those, so they come off its own `skeleton.json` and atlas, and the `poser` line then says `a rigc-compiled/2 document, which does not state the order its skins and animations are listed in or its stage, read from` and names both files; where each region sits and the page images it draws off the document's `pages` (a `rigc-compiled/1` document's off the atlas beside it, and the `poser` line then says `a rigc-compiled/1 document, which does not state where each region sits on its page: that is read from` and names the atlas); and a `--texture-from` atlas off rigc's own atlas reader. The runtime is loaded for a Spine export, `--poser spine` and a fallback the `poser` line names; a run that cannot load it there is refused naming the input and why it needs the runtime (exit 1; `RC11`, `RC13`). On `explain` the flag chooses the `DEFORM` block's survey (§4.11.2): `core`, the default, reads the skeleton's structure — its deform timelines and their keys, curves and slots, the skin each is keyed under, the sliders — off the model document the compile writes and poses it through the core, and spine-core is not touched (`RC15`); `spine` parses and poses the Spine skeleton through spine-core. The two are the same survey to the byte on every corpus row (`DM12`). Where the core refuses the document, the survey falls back to spine-core and the block says so on a line of its own (`read and posed through spine-core: …`); `--poser core` there is refused instead (exit 2), and a run that cannot load the runtime where it needs it is refused naming the survey and why (exit 1) |
+| `--poser` | `render`, `check` and `explain`: `core` or `spine` — on `render` and `check`, which implementation poses the frames (on `check`, the candidate's; the reference side is pixels either way). By default a **rigc build** (the `skeleton.model.json` `build` writes; its atlas, when one is named or present, the one beside it) is posed by rigc's own core and a **Spine export** by spine-core; the render prints a `poser` line saying which and why, and so does the check report (`check.json`'s `poser`, and the pictures' `frames.json` under `--out`; `bench --frames` prints the same line). A concave or an inverse clip is posed by the core, and so is a build rendered with no `--skin` whose default skin names a skin-required bone or constraint, or whose skins name no `default` one — posed as a fresh skeleton is, no skin's bones or constraints applied (the default skin's included) and every slot resolved through the default skin alone, so the second draws nothing and stops at `there is nothing to draw` (exit 2) under either poser (issue #1051). Where the input cannot carry the core, or the core refuses it, the render poses it through spine-core and the `poser` line says why, in one of these words: `no skeleton.model.json beside` (a Spine export) · `is not beside` (`--atlas` names an atlas outside the build's directory) · `does not describe` (a model document whose bones, slots or animations are not the skeleton's) · `is not the skeleton.json` (a `skeleton.json` whose SHA-256 is not the `spine.sha256` its model document records — edited or replaced after the build — both digests named) · `the polygon is not simple` (a clip polygon two of whose edges cross or touch, the slot named) · `depends on the runtime's previous pass` (a constraint moves a posed bone from a bone that a constraint writes into while that bone is inactive, all four named) · `--poser spine` (asked for). Any other refusal of the core's — an unreadable model document among them — reads `the core refused` and then the core's own words. `--poser core` on an input that cannot carry it is refused in the same words (exit 2, nothing written); `--poser spine` forces the runtime. A fallback whose pair the runtime cannot load — another build's `skeleton.json` or atlas beside this build's document, or an export beside an atlas it was not exported with — is not drawn: it is refused `… does not load against <the atlas>: spine-core draws this pair (<why>) and could not resolve it — "<the runtime's own words>"` — or, where the atlas names a page that is not there, `nothing at <the page>: …` — exit 2, nothing written, on `render`, `render --geometry`, `check` and `bench --frames` alike; under `--poser core` the same pair is that flag's refusal, in the words above (`RC18`; the `--candidate` row says what to change). The repository's selftest renders one probe per reason above and holds this list to the lines they print (`RC09`). Both posers draw the same frames, geometry and framing box to the bit on every corpus (issue #968), and `check` through either writes the same report, `check.json` and pictures but for the poser it names on every tree row. A rigc build the core poses reads nothing through spine-core on `render`, `render --geometry` and `check`, `--texture-from` included (and the check `bench --frames` folds in; `bench`'s own `validate`, like `build`'s, is the runtime's round trip by design): its bone tree, slot list and slot roster come off its model document; so do the order its animations and skins are listed in, its stage and its pages' `scale:` lines, on a `rigc-compiled/3` document (`editorOrder`, `stage`, `pages`) — a `/2` or `/1` document states none of those, so they come off its own `skeleton.json` and atlas, and the `poser` line then says `a rigc-compiled/2 document, which does not state the order its skins and animations are listed in or its stage, read from` and names both files; where each region sits and the page images it draws off the document's `pages` (a `rigc-compiled/1` document's off the atlas beside it, and the `poser` line then says `a rigc-compiled/1 document, which does not state where each region sits on its page: that is read from` and names the atlas); and a `--texture-from` atlas off rigc's own atlas reader. The runtime is loaded for a Spine export, `--poser spine` and a fallback the `poser` line names; a run that cannot load it there is refused naming the input and why it needs the runtime (exit 1; `RC11`, `RC13`). On `explain` the flag chooses the `DEFORM` block's survey (§4.11.2): `core`, the default, reads the skeleton's structure — its deform timelines and their keys, curves and slots, the skin each is keyed under, the sliders — off the model document the compile writes and poses it through the core, and spine-core is not touched (`RC15`); `spine` parses and poses the Spine skeleton through spine-core. The two are the same survey to the byte on every corpus row (`DM12`). Where the core refuses the document, the survey falls back to spine-core and the block says so on a line of its own (`read and posed through spine-core: …`); `--poser core` there is refused instead (exit 2), and a run that cannot load the runtime where it needs it is refused naming the survey and why (exit 1) |
 | `--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` |
 | `--ballot` | `vote --record` only: the ballot the vote answers (default `ballot.html`). Its embedded manifest is what the vote is checked against, so the ballot file is the record of the question |
 | `--ledger` | `vote --record` only: the append-only JSONL the vote lands in (default `votes.jsonl`), one vote per line |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spine-rigc",
-  "version": "1.9.2",
+  "version": "1.9.3",
   "description": "AI-authored Spine 2D rigging and animation, verified before it is written. rigc compiles a rig spec into Spine 4.3 skeleton data, round-trips it through spine-core and named assertions, and emits nothing that fails. Output imports into the Spine editor. Ships as an agent skill.",
   "type": "module",
   "bin": {

package/src/assertions/bodies/a13.ts

@@ -3,17 +3,17 @@
  * triangles stay within the budget the rig declares.
  *
  * Moved out of `src/validate.ts` unchanged but for what it reads: the meshes
- * are a fact (`../facts/skin_meshes.ts`) rather than the lists `validate()`'s
+ * are a fact (`../facts/mesh_attachments.ts`) rather than the lists `validate()`'s
  * prelude filled from spine-core's loaded skins, and the rig info is the
  * caller's. Why the two budgets come from the rig and never from here stays
  * above the `check` call in `validate()`.
  */
 import type { Verdicts } from '../harness.ts';
-import type { SkinMeshFacts } from '../facts/skin_meshes.ts';
+import type { MeshFacts } from '../facts/mesh_attachments.ts';
 import { SKIP_NO_MESH_ATTACHMENT } from '../reasons.ts';
 import type { RigInfo } from '../../types.ts';
 
-export function a13MeshBudget({ fail, skip }: Verdicts, { meshes }: SkinMeshFacts, input: { rig?: RigInfo }): void {
+export function a13MeshBudget({ fail, skip }: Verdicts, { meshes }: Pick<MeshFacts, 'meshes'>, input: { rig?: RigInfo }): void {
   const meshAttachments = meshes;
   const meshSlots = new Set(meshes.map((mesh) => mesh.slot));
   const slotBudget = input.rig?.meshSlotBudget ?? null;

package/src/assertions/bodies/a14.ts

@@ -3,15 +3,15 @@
  * stage.
  *
  * Moved out of `src/validate.ts` unchanged but for what it reads: the meshes
- * and the stage are facts (`../facts/skin_meshes.ts`, `../facts/stage.ts`)
+ * and the stage are facts (`../facts/mesh_attachments.ts`, `../facts/stage.ts`)
  * rather than spine-core's loaded skins and skeleton header. The `check` call
  * stays in `validate()`.
  */
 import type { Verdicts } from '../harness.ts';
-import type { SkinMeshFacts } from '../facts/skin_meshes.ts';
+import type { MeshFacts } from '../facts/mesh_attachments.ts';
 import type { StageFacts } from '../facts/stage.ts';
 
-export function a14NoFullFrameMesh({ fail, skip }: Verdicts, { meshes }: SkinMeshFacts, stage: StageFacts): void {
+export function a14NoFullFrameMesh({ fail, skip }: Verdicts, { meshes }: Pick<MeshFacts, 'meshes'>, stage: StageFacts): void {
   const meshAttachments = meshes;
   const stageW = stage.width || 0;
   const stageH = stage.height || 0;

package/src/assertions/bodies/a15.ts

@@ -3,7 +3,7 @@
  * drives a mesh, unless the rig declares that its idle deforms them.
  *
  * Moved out of `src/validate.ts` unchanged but for what it reads: the meshes
- * and the bones that drive them are a fact (`../facts/skin_meshes.ts`) rather
+ * and the bones that drive them are a fact (`../facts/mesh_attachments.ts`, the bones derived from the weights by `weightBonesOf`) rather
  * than spine-core's loaded skins and the weight run decoded here, the bones
  * `idle` keys are a fact (`../facts/animated_bones.ts`) rather than the raw
  * JSON, and the rig info is the caller's. Why the rule assumes meshes are
@@ -11,11 +11,11 @@
  * `check` call in `validate()`.
  */
 import type { Verdicts } from '../harness.ts';
-import type { MeshEntry, SkinMeshFacts } from '../facts/skin_meshes.ts';
+import { weightBonesOf, type MeshEntry, type MeshFacts } from '../facts/mesh_attachments.ts';
 import type { AnimatedBoneFacts } from '../facts/animated_bones.ts';
 import type { RigInfo } from '../../types.ts';
 
-export function a15IdleNoMeshBoneKeys({ fail, skip }: Verdicts, { meshes }: SkinMeshFacts, animated: AnimatedBoneFacts, input: { rig?: RigInfo }): void {
+export function a15IdleNoMeshBoneKeys({ fail, skip }: Verdicts, facts: MeshFacts, animated: AnimatedBoneFacts, input: { rig?: RigInfo }): void {
   const A15 = 'A15_IDLE_NO_MESH_BONE_KEYS';
   /**
    * Every mesh attachment, loaded, with the bones that drive it — its slot's
@@ -25,9 +25,9 @@ export function a15IdleNoMeshBoneKeys({ fail, skip }: Verdicts, { meshes }: Skin
    * actually dirties the canvas every frame.
    */
   const meshDrivers: Array<{ mesh: MeshEntry; bones: Set<string> }> = [];
-  for (const mesh of meshes) {
+  for (const mesh of facts.meshes) {
     const bones = new Set<string>([mesh.slotBone]);
-    for (const bone of mesh.weightBones) bones.add(bone);
+    for (const bone of weightBonesOf(facts, mesh)) bones.add(bone);
     meshDrivers.push({ mesh, bones });
   }
   const meshBoneNames = new Set<string>();

package/src/assertions/bodies/a22.ts

@@ -3,14 +3,14 @@
  * in the unit square, one pair per vertex.
  *
  * Moved out of `src/validate.ts` unchanged but for what it reads: the meshes
- * are a fact (`../facts/skin_meshes.ts`). The `check` call stays in
+ * are a fact (`../facts/mesh_attachments.ts`). The `check` call stays in
  * `validate()`.
  */
 import type { Verdicts } from '../harness.ts';
-import type { SkinMeshFacts } from '../facts/skin_meshes.ts';
+import type { MeshFacts } from '../facts/mesh_attachments.ts';
 import { SKIP_NO_MESH_ATTACHMENT } from '../reasons.ts';
 
-export function a22MeshUvsInUnitRange({ fail, skip }: Verdicts, { meshes }: SkinMeshFacts): void {
+export function a22MeshUvsInUnitRange({ fail, skip }: Verdicts, { meshes }: Pick<MeshFacts, 'meshes'>): void {
   const meshAttachments = meshes;
   if (meshAttachments.length === 0) return skip('A22_MESH_UVS_IN_UNIT_RANGE', SKIP_NO_MESH_ATTACHMENT);
   for (const mesh of meshAttachments) {

package/src/assertions/facts/animated_bones.ts

@@ -11,8 +11,10 @@
  * rather than folding the first two into an empty list.
  *
  * The order is the file's: A15 prints one line per keyed bone in it. The file
- * keys an animation's bones in the order the emitter writes the model's
- * (`emitAnimation`), which is the document's own list.
+ * keys an animation's bones in an object filled in the order the emitter
+ * writes the model's (`emitAnimation`), which is the document's own list — so
+ * an array-index bone name (`5`, `10`) is listed first whatever its place in
+ * that list (issue #1039), and the model side reads it through `keyedOrder`.
  *
  * Links nothing from the runtime: `validate()` reads it off the skeleton JSON
  * as A15 always did, and the model side off the document

package/src/assertions/facts/mesh_attachments.ts

@@ -1,8 +1,16 @@
 /**
- * The mesh attachments, as the bodies that read their geometry and their
- * weights see them (issue #1025, step 4c of #380) — the census's F07 (vertex
- * data), F08 (mesh geometry) and F10 (the linked-mesh join), for A04, A20,
- * A21, A28 and the mesh half of A23.
+ * The mesh attachments, as every body that reads a mesh sees them (issue
+ * #1025, step 4c of #380) — the census's F03, F05, F07 (vertex data), F08
+ * (mesh geometry) and F10 (the linked-mesh join), for A04, A13, A14, A15, A20,
+ * A21, A22, A28 and the mesh half of A23.
+ *
+ * ⭐ **One family** (issue #1054). Cut 4c-1 stated the meshes for A13, A14,
+ * A15 and A22 as a family of their own (`SkinMeshFacts`) and cut 4c-2 stated
+ * them again here; the two walked the same entries in the same order and
+ * agreed on every field they shared, and two families of one fact are two
+ * places for a supplier to disagree with itself. The size the budget and
+ * canvas rules read joined this one, and the bones a mesh's weights name are
+ * derived from `weights` (`weightBonesOf`) rather than stated beside them.
  *
  * ⭐ **The order is the file's**, as `./skin_entries.ts` states it: every
  * skin in the file's order, and within a skin the entries slot by slot in the
@@ -56,6 +64,9 @@ export interface MeshEntry {
   readonly regionUVs: readonly number[];
   /** `hullLength`: two numbers per hull vertex. */
   readonly hullLength: number;
+  /** Its `width` and `height` — a link's are its source's, which the runtime's `setSourceMesh` writes over the link's own. */
+  readonly width: number;
+  readonly height: number;
   /** Per vertex its influences, in order — or `null` for an unweighted mesh. */
   readonly weights: ReadonlyArray<readonly MeshBinding[]> | null;
   /** The kept clauses' findings about this mesh's vertex run (`A04`'s encoding rules), in order; never on the model side. */
@@ -69,3 +80,21 @@ export interface MeshFacts {
   /** Every mesh attachment of every skin, in the file's walk order. */
   readonly meshes: readonly MeshEntry[];
 }
+
+/**
+ * Every bone a mesh's weights name, in the weight run's order (repeats kept),
+ * by name — empty for an unweighted mesh. A binding whose index the roster
+ * does not hold names nothing here: that index is the encoding's fault, which
+ * `A20`'s kept clause names (`MeshBinding.encoding`), and no bone drives the
+ * mesh through it.
+ */
+export function weightBonesOf(facts: Pick<MeshFacts, 'bones'>, mesh: Pick<MeshEntry, 'weights'>): string[] {
+  const names: string[] = [];
+  for (const vertex of mesh.weights ?? []) {
+    for (const binding of vertex) {
+      const name = facts.bones[binding.bone];
+      if (name !== undefined) names.push(name);
+    }
+  }
+  return names;
+}

package/src/assertions/model/animated_bones.ts

@@ -5,13 +5,21 @@
  * The document writes each animation's `bones` as a list in the model's map
  * order, and the emitter writes the Spine file's `bones` group from that same
  * map, entry for entry, leaving the group out when it is empty
- * (`emitAnimation`'s `if (animation.bones.size)`) — so the list's order is the
- * file's, an empty list is a file with no `bones` group, and an animation the
- * document does not hold is one the file does not key. The first animation of
- * a name answers, as the file's object would hold only one.
+ * (`emitAnimation`'s `if (animation.bones.size)`) — so an empty list is a file
+ * with no `bones` group, and an animation the document does not hold is one the
+ * file does not key. The first animation of a name answers, as the file's
+ * object would hold only one.
+ *
+ * 🔢 **The order is `keyedOrder` over the list's, not the list's** (issue
+ * #1039). The group is an object keyed by bone name, so the file lists an
+ * array-index name (`5`, `10`) first whatever order the emitter filled it in —
+ * measured on a walk whose tracks key `-a, 5, 2b, 10, …`: the document lists
+ * that, the file and spine-core `5, 10, -a, 2b, …`, and A15 prints one line per
+ * keyed bone in the file's order.
  *
  * Links nothing from the runtime.
  */
+import { keyedOrder } from '../../compile.ts';
 import type { AnimatedBoneFacts } from '../facts/animated_bones.ts';
 import { isObj } from '../values.ts';
 import type { ReadDocument } from './parse.ts';
@@ -24,7 +32,7 @@ export function modelAnimatedBones(read: ReadDocument): AnimatedBoneFacts {
       if (animation === undefined) return undefined;
       const bones = Array.isArray(animation.bones) ? animation.bones.filter(isObj) : [];
       if (bones.length === 0) return null;
-      return bones.map((bone) => String(bone.name));
+      return keyedOrder(bones.map((bone) => String(bone.name)));
     },
   };
 }

package/src/assertions/model/bone_timelines.ts

@@ -6,9 +6,11 @@
  * `./slot_colour.ts`), over the `bones` group: the animations put in the
  * file's order by `editorAnimationOrder` (`src/compile.ts`, the function the
  * emitter is handed), each animation's bones and their timelines laid out as
- * the file lays them (`animations.<name>.bones.<bone>.<timeline> = keys`, in
- * the document's order, which is the order `emitAnimation` writes the model's
- * map in), and the whole handed to the emitter's own `withoutParserDefaults`
+ * the file lays them (`animations.<name>.bones.<bone>.<timeline> = keys`,
+ * filled in the document's order, which is the order `emitAnimation` writes
+ * the model's map in — and read back out of that object, so an array-index
+ * bone name comes first as it does in the file: issue #1039 measured this
+ * reader already walking the file's order), and the whole handed to the emitter's own `withoutParserDefaults`
  * and `inEditorKeyOrder` (`src/keyorder.ts`) — so a key field the emitter
  * leaves out at the parser's default (`time: 0`, a translate key's `y: 0`) is
  * left out here too, and a body printing a key's `time` prints what it prints

package/src/assertions/model/declared.ts

@@ -0,0 +1,127 @@
+/**
+ * What the build declared, read off the document (issue #1054): the rig info
+ * the archetype and declaration rules read, and each animation's declared
+ * duration, which A09 holds the keys against.
+ *
+ * ⭐ **The document is the one source, on every spec it is read at.** A
+ * `rigc-compiled/3`, `/2` and `/1` document all carry the `rig` section
+ * (`CompileResult.rig` as `modelDocument` writes it) and every animation's
+ * `duration` (the motion spec's, which `readModel` reads as
+ * `CoreAnimationTimelines.declared` and refuses when it is not a finite
+ * number). Until this module the model side took both from its caller, as
+ * `validate()` does, and its verdict moved with what the caller handed it:
+ * measured over the 19 recipes with the document's own values left out, A09
+ * read SKIP on 38 of 38 cells, ten rules read their bare-directory SKIP, and
+ * A20 read FAIL on 7 cells where it reads PASS — without the rig every mesh is
+ * judged a generated ring (`meshKindOf`), so an authored mesh fails the
+ * generator policy. A value the document states is read from the document,
+ * and the same value given beside it is refused by name
+ * (`refuseDeclaredBeside`), as issue #1026 made the stage and `pma`
+ * (`./given.ts`).
+ *
+ * 🔒 **The rig section is read field by field, never cast.** A body reads a
+ * declaration only through `modelRigInfo`, which refuses by its path a field
+ * that is missing, of the wrong type or not one the writer writes — the
+ * model side's parse runs it (`./parse.ts`, `A00_MODEL_READ`), so a document
+ * whose declarations are malformed is refused where the reader refuses, and
+ * never judged against a guess.
+ *
+ * Links nothing from the runtime.
+ */
+import type { MeshKind } from '../../mesh.ts';
+import type { RigInfo } from '../../types.ts';
+import { isObj } from '../values.ts';
+import type { ReadDocument } from './parse.ts';
+
+/** A rig section the model side cannot read as rig info: every problem, each by its path, in one sentence. */
+export class DeclaredInputError extends Error {}
+
+/** The mesh kinds a rig's `meshKinds` may name: the generators' and `authored`. */
+const MESH_KINDS = ['ring', 'ribbon', 'contour', 'grid', 'segments', 'authored'] as const satisfies ReadonlyArray<MeshKind | 'authored'>;
+// Every kind the type names is in the list, or this line does not type-check.
+const MESH_KINDS_COMPLETE: Exclude<MeshKind | 'authored', (typeof MESH_KINDS)[number]> extends never ? true : false = true;
+void MESH_KINDS_COMPLETE;
+
+type Check = (value: unknown, at: string, problems: string[]) => void;
+const say = (problems: string[], at: string, value: unknown, what: string): void => void problems.push(`${at} is ${JSON.stringify(value) ?? 'absent'}, not ${what}`);
+const str: Check = (v, at, p) => (typeof v === 'string' ? undefined : say(p, at, v, 'a string'));
+const bool: Check = (v, at, p) => (typeof v === 'boolean' ? undefined : say(p, at, v, 'true or false'));
+const num: Check = (v, at, p) => (typeof v === 'number' && Number.isFinite(v) ? undefined : say(p, at, v, 'a finite number'));
+const nullable = (inner: Check): Check => (v, at, p) => (v === null ? undefined : inner(v, at, p));
+const list = (inner: Check, length?: number): Check => (v, at, p) => {
+  if (!Array.isArray(v) || (length !== undefined && v.length !== length)) return say(p, at, v, length === undefined ? 'a list' : `a list of ${length}`);
+  v.forEach((x, i) => inner(x, `${at}[${i}]`, p));
+};
+const record = (inner: Check): Check => (v, at, p) => {
+  if (!isObj(v)) return say(p, at, v, 'an object');
+  for (const [k, x] of Object.entries(v)) inner(x, `${at}.${k}`, p);
+};
+const oneOf = (words: readonly string[]): Check => (v, at, p) => (typeof v === 'string' && words.includes(v) ? undefined : say(p, at, v, `one of ${words.join(', ')}`));
+const shape = (fields: Readonly<Record<string, Check>>): Check => (v, at, p) => {
+  if (!isObj(v)) return say(p, at, v, 'an object');
+  for (const [k, check] of Object.entries(fields)) check(v[k], `${at}.${k}`, p);
+  for (const k of Object.keys(v)) if (!(k in fields)) p.push(`${at}.${k} is not a field the rig section has`);
+};
+
+/** The rig section's fields, as `RigInfo` declares them and the writer writes every one — each required, none defaulted. */
+const RIG_FIELDS: Readonly<Record<keyof RigInfo, Check>> = {
+  archetype: str,
+  axisBone: nullable(str),
+  axisSubtree: list(str),
+  detached: list(list(str, 2)),
+  slotOrder: nullable(list(str)),
+  meshKinds: record(oneOf(MESH_KINDS)),
+  meshDeclaredBones: record(list(str)),
+  meshSoftBones: record(str),
+  deformMayFold: list(str),
+  editorRoundTrip: bool,
+  consumerDrivenMix: list(shape({ type: oneOf(['ik', 'transform']), constraint: str, why: str })),
+  idleDrivesMeshes: nullable(str),
+  basePlates: list(str),
+  meshSlotBudget: nullable(num),
+  meshTriangleBudget: nullable(num),
+  contactDepth: nullable(num),
+  capContainmentCeiling: nullable(num),
+  massBone: nullable(str),
+  inwardUnit: nullable(list(num, 2)),
+};
+
+/** Every problem with the document's `rig` section, each by its path — empty when it reads as rig info. */
+export function rigSectionProblems(json: Readonly<Record<string, unknown>>): string[] {
+  const problems: string[] = [];
+  shape(RIG_FIELDS)(json.rig, 'rig', problems);
+  return problems;
+}
+
+/** The rig info the document declares — its `rig` section, read field by field; a section that does not read is refused by its paths. */
+export function modelRigInfo(read: ReadDocument): RigInfo {
+  const problems = rigSectionProblems(read.json);
+  if (problems.length > 0) throw new DeclaredInputError(`the document's rig section does not read as rig info: ${problems.length} problem(s): ${problems.join('; ')}`);
+  return read.json.rig as RigInfo;
+}
+
+/**
+ * Each animation's declared duration, as the document states it and the core
+ * reads it (`CoreAnimationTimelines.declared`), keyed in the document's order —
+ * the motion spec's, the order `CompileResult.declaredDurations` is filled in.
+ */
+export function modelDeclaredDurations(read: ReadDocument): Record<string, number> {
+  const out: Record<string, number> = {};
+  for (const anim of read.doc.animations) out[anim.name] = anim.timelines.declared;
+  return out;
+}
+
+/** What a caller may not give beside a document, because every document states it. */
+export type DeclaredValue = 'rig' | 'declaredDurations';
+
+/** The sentence a value given beside the document is refused with. */
+export function declaredBesideRefusal(spec: string, what: DeclaredValue): string {
+  const given = what === 'rig' ? 'the rig info' : 'the declared durations';
+  const stated = what === 'rig' ? 'states it itself in its rig section' : "states each animation's duration itself";
+  return `the caller gave ${given} beside a ${spec} document, which ${stated} (issue #1054); a second source for one fact is refused rather than one of them silently read`;
+}
+
+/** A caller's value beside a document that states it, refused by name. */
+export function refuseDeclaredBeside(read: ReadDocument, input: { rig?: unknown; declaredDurations?: unknown }, what: DeclaredValue): void {
+  if (input[what] !== undefined) throw new Error(declaredBesideRefusal(read.doc.spec, what));
+}

package/src/assertions/model/index.ts

@@ -21,11 +21,14 @@
  * 🔸 **What the entry is given.** The document's text, the directory its
  * pages resolve against, and the profile — and nothing read off a Spine file:
  * a model-side verdict that read `skeleton.json` would be a second reading of
- * the encoding, which is the round trip's subject and not the rig's. Since cut
- * 4c-1 it is also given the rig info (as `validate()` is) and, in `given`, the
- * two values a `rigc-compiled/2` or `/1` document does not hold — the stage and
- * each page's `pma` (`./given.ts`). A `/3` document states both (issue #1026)
- * and is read for them; `given` beside one is refused by name.
+ * the encoding, which is the round trip's subject and not the rig's. In
+ * `given`, the two values a `rigc-compiled/2` or `/1` document does not hold —
+ * the stage and each page's `pma` (`./given.ts`); a `/3` document states both
+ * (issue #1026) and is read for them, and `given` beside one is refused by
+ * name. The rig info and the declared durations are the document's on every
+ * spec (issue #1054, `./declared.ts`): cuts 4c-1 to 4c-3 took them from the
+ * caller, as `validate()` does, and the verdict moved with what the caller
+ * handed over — now either one given beside the document is refused by name.
  *
  * ⛔ **Not wired into any command.** `build` keeps the round trip and its
  * forty-nine lines; this entry is what the selftest and the instrument call
@@ -50,6 +53,7 @@ import type { AtlasPageFacts } from '../facts/atlas_pages.ts';
 import type { SlotColourFacts } from '../facts/slot_colour.ts';
 import type { RigInfo } from '../../types.ts';
 import type { ModelGiven } from './given.ts';
+import { modelDeclaredDurations, modelRigInfo, refuseDeclaredBeside } from './declared.ts';
 import { a08RegionNamesMatchAttachments } from '../bodies/a08.ts';
 import { a13MeshBudget } from '../bodies/a13.ts';
 import { a14NoFullFrameMesh } from '../bodies/a14.ts';
@@ -59,13 +63,11 @@ import { a38SkinMembersAreSkinRequired } from '../bodies/a38.ts';
 import { a06AtlasPageSizeMatchesPng } from '../bodies/a06.ts';
 import { a19OverlayPngsHaveAlpha } from '../bodies/a19.ts';
 import { a27RegionNameMatchesPageFilename } from '../bodies/a27.ts';
-import { modelSkinMeshes } from './skin_meshes.ts';
 import { modelAnimatedBones } from './animated_bones.ts';
 import { modelSkinMembers } from './skin_members.ts';
 import { modelRegionJoins } from './region_joins.ts';
 import { modelAtlasRegions } from './atlas_regions.ts';
 import { modelStage } from './stage.ts';
-import type { SkinMeshFacts } from '../facts/skin_meshes.ts';
 import type { AnimatedBoneFacts } from '../facts/animated_bones.ts';
 import type { SkinMemberFacts } from '../facts/skin_members.ts';
 import type { RegionJoinFacts } from '../facts/region_joins.ts';
@@ -134,7 +136,14 @@ export interface ModelValidateInput {
   /** The directory the document's page names resolve against — the build's `--out`. */
   atlasDir: string;
   profile: AssertionProfile;
-  /** The rig info the build carries, as `validate()` is handed it — A13, A15, A19 (cut 4c-1) and A20, A21, A28, A41, A47, A48 (cut 4c-2) and A24, A25, A26, A29, A30 (cut 4c-4) read it; optional because `ValidateInput.rig` is: absent for a bare directory, on both sides. */
+  /**
+   * Refused (issue #1054): every document states the rig info in its `rig`
+   * section, and the model side reads it there (`./declared.ts`). A caller
+   * that gives it anyway is a second source for one fact, and each rule that
+   * reads the declarations refuses the call by name rather than reading
+   * either. Kept on the type so a caller still handing it over is named, not
+   * silently ignored.
+   */
   rig?: RigInfo;
   /**
    * The stage and the pages' `pma`, for a `rigc-compiled/2` or `/1` document,
@@ -144,7 +153,7 @@ export interface ModelValidateInput {
    * `given` beside it is refused by name.
    */
   given?: ModelGiven;
-  /** The motion spec's declared durations, as `validate()` is handed them — A09 reads them (cut 4c-3); absent where the caller has no motion spec, on both sides. */
+  /** Refused, as `rig` is (issue #1054): every document states each animation's declared duration, and A09 reads them there. */
   declaredDurations?: Record<string, number>;
 }
 
@@ -164,7 +173,6 @@ export interface ModelSupply {
   skinEntries: (read: ReadDocument) => SkinEntryFacts;
   atlasPages: (read: ReadDocument) => AtlasPageFacts;
   slotColour: (read: ReadDocument) => SlotColourFacts;
-  skinMeshes: (read: ReadDocument) => SkinMeshFacts;
   animatedBones: (read: ReadDocument) => AnimatedBoneFacts;
   skinMembers: (read: ReadDocument) => SkinMemberFacts;
   regionJoins: (read: ReadDocument) => RegionJoinFacts;
@@ -184,6 +192,10 @@ export interface ModelSupply {
   sliderComposition: (read: ReadDocument) => SliderCompositionFacts;
   constraintTargets: (read: ReadDocument) => ConstraintTargetFacts;
   steppedPoses: (read: ReadDocument) => SteppedPoseFacts;
+  /** The rig info the document declares (issue #1054, `./declared.ts`); a caller's `rig` beside it is refused by name. */
+  rigInfo: (read: ReadDocument, input: ModelValidateInput) => RigInfo;
+  /** Each animation's declared duration as the document states it (issue #1054); a caller's `declaredDurations` beside it is refused by name. */
+  declaredDurations: (read: ReadDocument, input: ModelValidateInput) => Record<string, number>;
 }
 
 /** The suppliers the model side runs on. */
@@ -191,7 +203,6 @@ export const MODEL_SUPPLY: ModelSupply = {
   skinEntries: modelSkinEntries,
   atlasPages: modelAtlasPages,
   slotColour: modelSlotColour,
-  skinMeshes: modelSkinMeshes,
   animatedBones: modelAnimatedBones,
   skinMembers: modelSkinMembers,
   regionJoins: modelRegionJoins,
@@ -211,12 +222,21 @@ export const MODEL_SUPPLY: ModelSupply = {
   sliderComposition: modelSliderComposition,
   constraintTargets: modelConstraintTargets,
   steppedPoses: modelSteppedPoses,
+  rigInfo: (read, input) => {
+    refuseDeclaredBeside(read, input, 'rig');
+    return modelRigInfo(read);
+  },
+  declaredDurations: (read, input) => {
+    refuseDeclaredBeside(read, input, 'declaredDurations');
+    return modelDeclaredDurations(read);
+  },
 };
 
 /**
  * One moved assertion: its code, and how the model side runs its body once the
- * document is read. The list is the registry of what has moved — each later
- * cut appends its rows — and the selftest reads it for the codes it compares.
+ * document is read. The list is the registry of what has moved — a later cut
+ * puts its rows where `validate()` runs those rules, not at the end — and the
+ * selftest reads it for the codes it compares.
  */
 export interface MovedAssertion {
   code: string;
@@ -241,53 +261,56 @@ export interface MovedAssertion {
 }
 
 /**
- * The moved assertions, in `validate()`'s report order (the order its `check`
- * calls stand in; the selftest and the instrument compare per code). `SKIP_NO_ATLAS` for
+ * The moved assertions, in `validate()`'s report order — the order its `check`
+ * calls stand in, so a model-side report lists its PASS, SKIP and FAIL lines in
+ * the order the round trip's does. The seven cuts of issue #1025 appended their
+ * rows in landing order; issue #1054 put them back, and the selftest's `VF16`
+ * names a row that stands out of that order. `SKIP_NO_ATLAS` for
  * A17 rather than `SKIP_NO_MODEL` because that is what A17 says over a missing
  * atlas on either side: its body reads only the pages, and on this side no
  * document means no pages.
  */
 export const MOVED_ASSERTIONS: readonly MovedAssertion[] = [
   { code: 'A08_REGION_NAMES_MATCH_ATTACHMENTS', run: (v, read, _input, supply) => (read.doc.pages === null ? v.skip('A08_REGION_NAMES_MATCH_ATTACHMENTS', SKIP_NO_MODEL_PAGES) : a08RegionNamesMatchAttachments(v, supply.regionJoins(read), new Set<string>())), unread: SKIP_NO_MODEL, beforeTheParse: true },
+  { code: 'A32_EVENT_KEYS_RESOLVE', run: (v, read, _input, supply) => a32EventKeysResolve(v, supply.eventKeys(read)), unread: SKIP_NO_MODEL, beforeTheParse: true },
+  { code: 'A34_CONSTRAINT_TIMELINE_TARGETS', run: (v, read, _input, supply) => a34ConstraintTimelineTargets(v, supply.constraintTargets(read)), unread: SKIP_NO_MODEL, beforeTheParse: true },
+  { code: 'A12_NO_DARK_COLOR', run: (v, read, _input, supply) => a12NoDarkColor(v, supply.skeletonRoster(read), supply.slotColour(read).slotTimelines), unread: SKIP_NO_MODEL, beforeTheParse: true },
   { code: 'A03_REGION_WIDTH_HEIGHT_FINITE', run: (v, read, _input, supply) => a03RegionWidthHeightFinite(v, supply.skinEntries(read)), unread: SKIP_NO_MODEL },
   { code: 'A04_MESH_TRIANGLES_AND_ENCODING', run: (v, read, _input, supply) => a04MeshTrianglesAndEncoding(v, supply.meshes(read)), unread: SKIP_NO_MODEL },
   { code: 'A33_VERTEX_ATTACHMENT_GEOMETRY', run: (v, read, _input, supply) => a33VertexAttachmentGeometry(v, supply.polygons(read)), unread: SKIP_NO_MODEL },
   { code: 'A11_NO_CLIPPING_ATTACHMENTS', run: (v, read, _input, supply) => a11NoClippingAttachments(v, supply.skinEntries(read)), unread: SKIP_NO_MODEL },
-  { code: 'A13_MESH_BUDGET', run: (v, read, input, supply) => a13MeshBudget(v, supply.skinMeshes(read), input), unread: SKIP_NO_MODEL },
-  { code: 'A14_NO_FULL_FRAME_MESH', run: (v, read, input, supply) => a14NoFullFrameMesh(v, supply.skinMeshes(read), supply.stage(read, input)), unread: SKIP_NO_MODEL },
-  { code: 'A15_IDLE_NO_MESH_BONE_KEYS', run: (v, read, input, supply) => a15IdleNoMeshBoneKeys(v, supply.skinMeshes(read), supply.animatedBones(read), input), unread: SKIP_NO_MODEL },
-  { code: 'A20_MESH_WEIGHTS_COHERENT', run: (v, read, input, supply) => a20MeshWeightsCoherent(v, supply.meshes(read), input.profile === 'spine-html', input.rig), unread: SKIP_NO_MODEL },
-  { code: 'A21_MESH_RIM_PINNED', run: (v, read, input, supply) => a21MeshRimPinned(v, supply.meshes(read), input.rig), unread: SKIP_NO_MODEL },
-  { code: 'A22_MESH_UVS_IN_UNIT_RANGE', run: (v, read, _input, supply) => a22MeshUvsInUnitRange(v, supply.skinMeshes(read)), unread: SKIP_NO_MODEL },
+  { code: 'A13_MESH_BUDGET', run: (v, read, input, supply) => a13MeshBudget(v, supply.meshes(read), { rig: supply.rigInfo(read, input) }), unread: SKIP_NO_MODEL },
+  { code: 'A14_NO_FULL_FRAME_MESH', run: (v, read, input, supply) => a14NoFullFrameMesh(v, supply.meshes(read), supply.stage(read, input)), unread: SKIP_NO_MODEL },
+  { code: 'A15_IDLE_NO_MESH_BONE_KEYS', run: (v, read, input, supply) => a15IdleNoMeshBoneKeys(v, supply.meshes(read), supply.animatedBones(read), { rig: supply.rigInfo(read, input) }), unread: SKIP_NO_MODEL },
+  { code: 'A20_MESH_WEIGHTS_COHERENT', run: (v, read, input, supply) => a20MeshWeightsCoherent(v, supply.meshes(read), input.profile === 'spine-html', supply.rigInfo(read, input)), unread: SKIP_NO_MODEL },
+  { code: 'A21_MESH_RIM_PINNED', run: (v, read, input, supply) => a21MeshRimPinned(v, supply.meshes(read), supply.rigInfo(read, input)), unread: SKIP_NO_MODEL },
+  { code: 'A22_MESH_UVS_IN_UNIT_RANGE', run: (v, read, _input, supply) => a22MeshUvsInUnitRange(v, supply.meshes(read)), unread: SKIP_NO_MODEL },
+  { code: 'A39_DEFORM_KEEPS_TRIANGLE_WINDING', run: (v, read, input, supply) => a39DeformKeepsTriangleWinding(v, supply.deformSurvey(read), supply.rigInfo(read, input)), unread: SKIP_NO_MODEL },
   { code: 'A23_PHYSICS_CONSTRAINT_EFFECTIVE', run: (v, read, _input, supply) => a23PhysicsConstraintEffective(v, supply.constraints(read), supply.meshes(read)), unread: SKIP_NO_MODEL },
-  { code: 'A41_PHYSICS_SURVIVES_EDITOR_ROUND_TRIP', run: (v, read, input, supply) => a41PhysicsSurvivesEditorRoundTrip(v, supply.constraints(read), input.rig), unread: SKIP_NO_MODEL },
+  { code: 'A41_PHYSICS_SURVIVES_EDITOR_ROUND_TRIP', run: (v, read, input, supply) => a41PhysicsSurvivesEditorRoundTrip(v, supply.constraints(read), supply.rigInfo(read, input)), unread: SKIP_NO_MODEL },
   { code: 'A36_PATH_CONSTRAINT_EFFECTIVE', run: (v, read, _input, supply) => a36PathConstraintEffective(v, supply.constraints(read)), unread: SKIP_NO_MODEL },
   { code: 'A37_SLIDER_CONSTRAINT_EFFECTIVE', run: (v, read, _input, supply) => a37SliderConstraintEffective(v, supply.constraints(read)), unread: SKIP_NO_MODEL },
-  { code: 'A47_IK_CONSTRAINT_NOT_MUTED_THROUGHOUT', run: (v, read, input, supply) => a47IkConstraintNotMutedThroughout(v, supply.constraints(read), input.rig), unread: SKIP_NO_MODEL },
-  { code: 'A48_TRANSFORM_CONSTRAINT_NOT_MUTED_THROUGHOUT', run: (v, read, input, supply) => a48TransformConstraintNotMutedThroughout(v, supply.constraints(read), input.rig), unread: SKIP_NO_MODEL },
+  { code: 'A47_IK_CONSTRAINT_NOT_MUTED_THROUGHOUT', run: (v, read, input, supply) => a47IkConstraintNotMutedThroughout(v, supply.constraints(read), supply.rigInfo(read, input)), unread: SKIP_NO_MODEL },
+  { code: 'A48_TRANSFORM_CONSTRAINT_NOT_MUTED_THROUGHOUT', run: (v, read, input, supply) => a48TransformConstraintNotMutedThroughout(v, supply.constraints(read), supply.rigInfo(read, input)), unread: SKIP_NO_MODEL },
+  { code: 'A40_SLIDERS_COMPOSE_ON_A_SHARED_TARGET', run: (v, read, _input, supply) => a40SlidersComposeOnASharedTarget(v, supply.sliderComposition(read), supply.constraints(read)), unread: SKIP_NO_MODEL },
   { code: 'A42_DRIVEN_CONSTRAINTS_UPDATE_AFTER_THEIR_DRIVER', run: (v, read, _input, supply) => a42DrivenConstraintsUpdateAfterTheirDriver(v, supply.constraints(read)), unread: SKIP_NO_MODEL },
   { code: 'A38_SKIN_MEMBERS_ARE_SKIN_REQUIRED', run: (v, read, _input, supply) => a38SkinMembersAreSkinRequired(v, supply.skinMembers(read)), unread: SKIP_NO_MODEL },
+  { code: 'A09_ANIMATION_DURATION_MATCHES_SPEC', run: (v, read, input, supply) => a09AnimationDurationMatchesSpec(v, supply.animationDurations(read), supply.declaredDurations(read, input)), unread: SKIP_NO_MODEL },
+  { code: 'A10_NO_NAN_AFTER_STEPPING', run: (v, read, _input, supply) => a10NoNanAfterStepping(v, supply.boneTimelines(read), supply.steppedPoses(read)), unread: SKIP_NO_MODEL },
+  { code: 'A43_TWO_COLOR_TINT_LOADS_AND_POSES_AS_WRITTEN', run: (v, read, _input, supply) => a43TwoColorTintLoadsAndPosesAsWritten(v, supply.twoColour(read)), unread: SKIP_NO_MODEL },
   { code: 'A45_SEPARABLE_COLOR_TIMELINES_OWN_THEIR_CHANNELS_AND_POSE_AS_WRITTEN', run: (v, read, _input, supply) => a45SeparableColorTimelinesOwnTheirChannelsAndPoseAsWritten(v, supply.slotColour(read)), unread: SKIP_NO_MODEL },
   { code: 'A44_LINKED_MESH_STATES_NO_GEOMETRY_OF_ITS_OWN', run: (v, read, _input, supply) => a44LinkedMeshStatesNoGeometryOfItsOwn(v, supply.links(read)), unread: SKIP_NO_MODEL },
+  { code: 'A46_SEQUENCE_ATTACHMENTS_SHOW_THE_FRAME_THE_FILE_STATES', run: (v, read, _input, supply) => a46SequenceAttachmentsShowTheFrameTheFileStates(v, supply.sequences(read)), unread: SKIP_NO_MODEL },
   { code: 'A17_ATLAS_PAGE_FILES_EXIST', run: (v, read, input, supply) => a17AtlasPageFilesExist(v, supply.atlasPages(read), input), unread: SKIP_NO_ATLAS },
   { code: 'A06_ATLAS_PAGE_SIZE_MATCHES_PNG', run: (v, read, input, supply) => a06AtlasPageSizeMatchesPng(v, supply.atlasRegions(read, input), input, input.profile === 'spine-html'), unread: SKIP_NO_ATLAS },
-  { code: 'A19_OVERLAY_PNGS_HAVE_ALPHA', run: (v, read, input, supply) => a19OverlayPngsHaveAlpha(v, supply.atlasRegions(read, input), supply.stage(read, input), supply.skinEntries(read), input), unread: SKIP_NO_ATLAS },
+  { code: 'A19_OVERLAY_PNGS_HAVE_ALPHA', run: (v, read, input, supply) => a19OverlayPngsHaveAlpha(v, supply.atlasRegions(read, input), supply.stage(read, input), supply.skinEntries(read), { atlasDir: input.atlasDir, rig: supply.rigInfo(read, input) }), unread: SKIP_NO_ATLAS },
+  { code: 'A24_AXIS_SPACE_STROKE', run: (v, read, input, supply) => a24AxisSpaceStroke(v, supply.boneTimelines(read), { rig: supply.rigInfo(read, input) }), unread: SKIP_NO_MODEL, beforeTheParse: true },
+  { code: 'A25_DETACHED_BONE_PARENTAGE', run: (v, read, input, supply) => a25DetachedBoneParentage(v, supply.skeletonRoster(read), { rig: supply.rigInfo(read, input) }), unread: SKIP_NO_MODEL, beforeTheParse: true },
+  { code: 'A26_SLOT_DRAW_ORDER', run: (v, read, input, supply) => a26SlotDrawOrder(v, supply.skeletonRoster(read), { rig: supply.rigInfo(read, input) }), unread: SKIP_NO_MODEL, beforeTheParse: true },
   { code: 'A27_REGION_NAME_MATCHES_PAGE_FILENAME', run: (v, read, input, supply) => a27RegionNameMatchesPageFilename(v, supply.atlasRegions(read, input)), unread: SKIP_NO_ATLAS },
-  { code: 'A28_RIBBON_ROWS_SHARE_WEIGHTS', run: (v, read, input, supply) => a28RibbonRowsShareWeights(v, supply.meshes(read), input.rig), unread: SKIP_NO_MODEL },
-  { code: 'A32_EVENT_KEYS_RESOLVE', run: (v, read, _input, supply) => a32EventKeysResolve(v, supply.eventKeys(read)), unread: SKIP_NO_MODEL, beforeTheParse: true },
-  { code: 'A12_NO_DARK_COLOR', run: (v, read, _input, supply) => a12NoDarkColor(v, supply.skeletonRoster(read), supply.slotColour(read).slotTimelines), unread: SKIP_NO_MODEL, beforeTheParse: true },
-  { code: 'A24_AXIS_SPACE_STROKE', run: (v, read, input, supply) => a24AxisSpaceStroke(v, supply.boneTimelines(read), input), unread: SKIP_NO_MODEL, beforeTheParse: true },
-  { code: 'A25_DETACHED_BONE_PARENTAGE', run: (v, read, input, supply) => a25DetachedBoneParentage(v, supply.skeletonRoster(read), input), unread: SKIP_NO_MODEL, beforeTheParse: true },
-  { code: 'A26_SLOT_DRAW_ORDER', run: (v, read, input, supply) => a26SlotDrawOrder(v, supply.skeletonRoster(read), input), unread: SKIP_NO_MODEL, beforeTheParse: true },
-  { code: 'A29_STROKE_WITHIN_CONTACT_DEPTH', run: (v, read, input, supply) => a29StrokeWithinContactDepth(v, supply.boneTimelines(read), input), unread: SKIP_NO_MODEL, beforeTheParse: true },
-  { code: 'A30_STROKE_WITHIN_CAP_CONTAINMENT', run: (v, read, input, supply) => a30StrokeWithinCapContainment(v, supply.boneTimelines(read), input), unread: SKIP_NO_MODEL, beforeTheParse: true },
-  { code: 'A39_DEFORM_KEEPS_TRIANGLE_WINDING', run: (v, read, input, supply) => a39DeformKeepsTriangleWinding(v, supply.deformSurvey(read), input.rig), unread: SKIP_NO_MODEL },
-  { code: 'A09_ANIMATION_DURATION_MATCHES_SPEC', run: (v, read, input, supply) => a09AnimationDurationMatchesSpec(v, supply.animationDurations(read), input.declaredDurations), unread: SKIP_NO_MODEL },
-  { code: 'A43_TWO_COLOR_TINT_LOADS_AND_POSES_AS_WRITTEN', run: (v, read, _input, supply) => a43TwoColorTintLoadsAndPosesAsWritten(v, supply.twoColour(read)), unread: SKIP_NO_MODEL },
-  { code: 'A46_SEQUENCE_ATTACHMENTS_SHOW_THE_FRAME_THE_FILE_STATES', run: (v, read, _input, supply) => a46SequenceAttachmentsShowTheFrameTheFileStates(v, supply.sequences(read)), unread: SKIP_NO_MODEL },
-  { code: 'A40_SLIDERS_COMPOSE_ON_A_SHARED_TARGET', run: (v, read, _input, supply) => a40SlidersComposeOnASharedTarget(v, supply.sliderComposition(read), supply.constraints(read)), unread: SKIP_NO_MODEL },
-  { code: 'A34_CONSTRAINT_TIMELINE_TARGETS', run: (v, read, _input, supply) => a34ConstraintTimelineTargets(v, supply.constraintTargets(read)), unread: SKIP_NO_MODEL, beforeTheParse: true },
-  { code: 'A10_NO_NAN_AFTER_STEPPING', run: (v, read, _input, supply) => a10NoNanAfterStepping(v, supply.boneTimelines(read), supply.steppedPoses(read)), unread: SKIP_NO_MODEL },
+  { code: 'A28_RIBBON_ROWS_SHARE_WEIGHTS', run: (v, read, input, supply) => a28RibbonRowsShareWeights(v, supply.meshes(read), supply.rigInfo(read, input)), unread: SKIP_NO_MODEL },
+  { code: 'A29_STROKE_WITHIN_CONTACT_DEPTH', run: (v, read, input, supply) => a29StrokeWithinContactDepth(v, supply.boneTimelines(read), { rig: supply.rigInfo(read, input) }), unread: SKIP_NO_MODEL, beforeTheParse: true },
+  { code: 'A30_STROKE_WITHIN_CAP_CONTAINMENT', run: (v, read, input, supply) => a30StrokeWithinCapContainment(v, supply.boneTimelines(read), { rig: supply.rigInfo(read, input) }), unread: SKIP_NO_MODEL, beforeTheParse: true },
 ];
 
 /** The codes the model side prints: its two parse rules, then the moved assertions. */