rig-c 0.0.0-stage → 2.20.4

package/skills/rigc-face/SKILL.md

@@ -0,0 +1,60 @@
+---
+name: rigc-face
+description: Author a face on plain Spine data with rigc — a blink, a gaze shift, a breathing portrait and a head turn a few degrees off axis, built from deform timelines and per-part parallax. Use when the request is a talking or living portrait, a standing character, an expression or a head turn, such as "rig this face", "make the portrait blink and look around" or "turn the head". Not for Live2D file conversion, cutting a face illustration into parts, or VTuber-style real-time face tracking.
+license: MIT
+compatibility: Requires Bun 1.2 or later and the npm package spine-rigc.
+---
+
+# Face — a turn, a gaze and a blink
+
+Load this when the request is a **head rather than a body**: a drawn face that
+breathes, blinks, moves its eyes and turns a few degrees off axis. Every rule below
+is owned by [FACE.md](https://github.com/firejune/rigc/blob/main/docs/FACE.md); this file says when to open it and what
+it will not do for you.
+
+## Non-negotiables
+
+- **Validation is never bypassed.** `build` writes nothing on a red gate, and there
+  is no flag that changes that — AUTHORING §0.
+- **The compiler never invents a value.** A `deform` key states every vertex it
+  moves; the geometry a turn implies is evaluated by you and written into the spec,
+  never inferred by the compiler — AUTHORING §4 and FACE §1.
+- **The validator's messages are the instructions.** Read each named failure as the
+  pointer to the file that has to change — AUTHORING §5.
+
+## What this guide will not do
+
+A `deform` key's own geometry is measured now.
+`A39_DEFORM_KEEPS_TRIANGLE_WINDING` refuses a key that folds a mesh inside out —
+per key, per interpolated span between two keys, per frame and per skin — and
+names the reversed triangles with their signed areas. `invariants.deformMayFold`
+in the rig spec is the one declared exemption, so reach for it when the slot
+folds on purpose and never to quiet a refusal you have not read. It is an
+**archetype** rule: a `--profile spine` build prints `PROF` for it and says
+nothing about the fold, so author under `--profile spine-html`.
+
+What `A39` still cannot say is whether the projection was the right one —
+nothing measures whether 12° was the angle the shot wanted. FACE §9.2 is that
+demonstration, three builds with one of them refused, and §9.3 is the
+differential audit and the three limits it does not lift.
+
+## Read, in this order
+
+1. [AUTHORING.md](https://github.com/firejune/rigc/blob/main/docs/AUTHORING.md) — the `deform` timeline field by field
+   and what rigc refuses in it (§4), the failure map (§5–§6), the editor's
+   conventions (§10).
+2. [MOTION.md](https://github.com/firejune/rigc/blob/main/docs/MOTION.md) — timing, easing and the offset table (§3),
+   candidates and the ballot (§4–§5). A blink and a gaze are ordinary motion work.
+3. [FACE.md](https://github.com/firejune/rigc/blob/main/docs/FACE.md) — the face's own geometry: the closed form every
+   number in a turn comes from (§1), the hierarchy underneath (§3), what
+   foreshortens (§5), and the deform audit gap (§9).
+4. Then [RIGGING.md](https://github.com/firejune/rigc/blob/main/docs/RIGGING.md) for the hierarchy as a general rule
+   rather than this closed form, and [INGEST.md](https://github.com/firejune/rigc/blob/main/docs/INGEST.md) if the head
+   arrived as a compiled skeleton.
+
+Every guide linked here is in the installed package at `node_modules/spine-rigc/docs/`,
+which is the copy that matches the rigc you run; the links go to the repository's
+`main`. Inside the Claude Code plugin the same files are at `${CLAUDE_PLUGIN_ROOT}/docs/`.
+
+The install line and the build → validate → render → check loop are in the `rigc`
+skill.

package/skills/rigc-ingest/SKILL.md

@@ -0,0 +1,78 @@
+---
+name: rigc-ingest
+description: Work with a Spine skeleton.json somebody else authored — exported from the Spine editor or another tool — using rigc. Read and validate it, understand a complaint rigc raised about it, decompile it into rigc specs with `rigc ingest`, normalise, re-pivot or rename it, and extend it with an animation it does not have. Use when the input is an existing skeleton.json with its .atlas and page images rather than loose part PNGs. Not for Live2D file conversion or runtime tracking.
+license: MIT
+compatibility: Requires Bun 1.2 or later and the npm package spine-rigc.
+---
+
+# Ingest — a skeleton you did not author
+
+Load this when what you were handed is **already a skeleton**: a `skeleton.json`
+with its `.atlas` and page images, and a request to understand it, answer a
+complaint about it, re-express it, or extend it. Every rule below is owned by
+[INGEST.md](https://github.com/firejune/rigc/blob/main/docs/INGEST.md); this file says when to open it and what it will
+not do for you.
+
+## Non-negotiables
+
+- **Validation is never bypassed.** `validate` reads a foreign file as it is, and
+  `build` writes nothing on a red gate — AUTHORING §0.
+- **The compiler never invents a value, and neither does the decompiler.** The
+  specs state every bone, slot and key; what the export left implicit is written
+  down before it compiles. `rigc ingest` obeys the same rule from the other side —
+  what it cannot read out of the skeleton is a named **finding**, never a guess —
+  INGEST §2.0 and §2.
+- **The validator's messages are the instructions.** A red line on an export is a
+  fact about the file, and sometimes about the rule — INGEST §3 says which, and
+  AUTHORING §5 names the file to change.
+
+## Start here: `rigc ingest`
+
+```bash
+rigc ingest hero.json --out specs/
+rigc build --rig specs/rig.json --motion specs/motion.json --images parts/ --out build/
+```
+
+It reads the skeleton — **only** the skeleton — and writes the rig spec and motion
+spec that rebuild it: **byte for byte for a skeleton rigc emitted**, and for an editor
+export the weaker claim `diff` measures, with three kinds of benign difference left —
+INGEST §2.3. Two values it will not guess: the
+**stage** (a skeleton that declares none is carried as declaring none, and `--stage`
+adds a box to one — an editor export *may* be such a file, though every one in the
+example corpus carries a box, and passing the flag at a file that declares a box is
+refused rather than ignored) and each animation's **duration** (the largest key time,
+recorded as a finding).
+Read `findings.json`: a `BLOCK` line means the rebuild will be missing something and
+the command exits non-zero. Every code it can print — gutter, exit, meaning, what to
+do — is the finding-code table in INGEST §2.0. Keep the `note` both specs carry.
+
+## What this guide will not do
+
+rigc still cannot **edit** a skeleton: there is no command that opens one and
+changes it, so every change is expressed in the specs — INGEST §0. `diff`'s ratios
+say how much of a reference's structure a candidate reproduces, so extending or
+renaming a foreign skeleton lowers them by design, and neither `validate` nor `diff`
+has a pass bar — INGEST §0 and §4.
+
+⚠️ This section said *"there is no route from it to specs, so every change goes
+through transcription"* until 2026-09-17. That route exists now and it is the first
+thing to reach for; transcription by hand is what you fall back on for a construct
+`ingest` reports as a blocker.
+
+## Read, in this order
+
+1. [INGEST.md](https://github.com/firejune/rigc/blob/main/docs/INGEST.md) — what every command will and will not do with
+   a foreign file (§0), `ingest` and transcription (§2), what each validator
+   complaint means on an export (§3), and the re-pivot, rename and extend
+   recipes (§4).
+2. [AUTHORING.md](https://github.com/firejune/rigc/blob/main/docs/AUTHORING.md) — the two spec files the transcription
+   targets (§3–§4), the failure map (§5–§6), and the coordinate contract (§11.2).
+3. Then [RIGGING.md](https://github.com/firejune/rigc/blob/main/docs/RIGGING.md) for why the re-pivot edit has the shape
+   it has, and [MOTION.md](https://github.com/firejune/rigc/blob/main/docs/MOTION.md) for the animation you are adding.
+
+Every guide linked here is in the installed package at `node_modules/spine-rigc/docs/`,
+which is the copy that matches the rigc you run; the links go to the repository's
+`main`. Inside the Claude Code plugin the same files are at `${CLAUDE_PLUGIN_ROOT}/docs/`.
+
+The install line and the build → validate → render → check loop are in the `rigc`
+skill.

package/skills/rigc-motion/SKILL.md

@@ -0,0 +1,51 @@
+---
+name: rigc-motion
+description: Author a Spine animation with rigc from key poses — an idle, a loop, a move from one picture to another — with timing and spacing, ease in and out, anticipation, arcs, overlap, follow-through, squash and stretch, and candidate variants a person can choose between. Use when the request is a movement on an existing or planned rig, in the animator's words too: "animate this rig", "make it breathe", "go from pose A to pose B", "make it feel heavier", "the cape should follow through". Not for Live2D, separating an image into parts, or real-time tracking.
+license: MIT
+compatibility: Requires Bun 1.2 or later and the npm package spine-rigc.
+---
+
+# Motion — what goes between two poses
+
+Load this when the request is a **movement rather than a skeleton**: a sentence of
+intent, between zero and N pictures of what the movement passes through, and a
+Spine animation somebody would choose coming back. Every rule below is owned by
+[MOTION.md](https://github.com/firejune/rigc/blob/main/docs/MOTION.md); this file says when to open it and what it will
+not do for you.
+
+## Non-negotiables
+
+- **Validation is never bypassed.** `build` writes nothing on a red gate, and there
+  is no flag that changes that — AUTHORING §0.
+- **The compiler never invents a value.** A key with no time, a curve with no kind, a
+  bone the rig does not declare — each is refused by name before anything is
+  written — AUTHORING §4 and §6.
+- **The validator's messages are the instructions.** Read each named failure as the
+  pointer to the file that has to change — AUTHORING §5.
+
+## What this guide will not do
+
+Nothing here grades a movement, and no instrument named here can. `build` says a
+file is valid, `check` says how far it is from pictures you were given, and the one
+thing that judges a movement is a person's eye through `rigc vote` — MOTION §0.
+
+## Read, in this order
+
+1. [AUTHORING.md](https://github.com/firejune/rigc/blob/main/docs/AUTHORING.md) — the motion spec field by field (§4),
+   the failure map (§5–§6), reading reference frames (§8) and checking against
+   them (§9), what the editor does when nobody tells it otherwise (§10), and
+   reading a pose out of a picture (§11–§12).
+2. [MOTION.md](https://github.com/firejune/rigc/blob/main/docs/MOTION.md) — the normal form every motion request
+   reduces to (§0), timing, easing and the per-bone offset table (§3), and how to
+   spread candidates so a ballot informs (§4–§5).
+3. Then [RIGGING.md](https://github.com/firejune/rigc/blob/main/docs/RIGGING.md) if the skeleton itself is what you have
+   to decide; [FACE.md](https://github.com/firejune/rigc/blob/main/docs/FACE.md) if the movement is a blink, a gaze or a
+   head turn; [INGEST.md](https://github.com/firejune/rigc/blob/main/docs/INGEST.md) if the rig arrived as a compiled
+   skeleton rather than loose parts.
+
+Every guide linked here is in the installed package at `node_modules/spine-rigc/docs/`,
+which is the copy that matches the rigc you run; the links go to the repository's
+`main`. Inside the Claude Code plugin the same files are at `${CLAUDE_PLUGIN_ROOT}/docs/`.
+
+The install line and the build → validate → render → check loop are in the `rigc`
+skill.

package/skills/rigc-rigging/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: rigc-rigging
+description: Decide a Spine rig's hierarchy with rigc — how many bones, where each pivot sits, what hangs off what, offsets, chains and what a chain can reach, siblings versus chains, constraints as structure — and which of those decisions the reference frames can check. Use when the request is a skeleton from loose part PNGs, such as "rig these parts", "make a Spine skeleton" or "where do the joints go", before any motion is authored. Not for Live2D, cutting an illustration into parts, or VTuber-style tracking.
+license: MIT
+compatibility: Requires Bun 1.2 or later and the npm package spine-rigc.
+---
+
+# Rigging — the hierarchy itself
+
+Load this when the request is a **skeleton rather than a movement**: loose part
+PNGs in, a bone hierarchy out. Every rule below is owned by
+[RIGGING.md](https://github.com/firejune/rigc/blob/main/docs/RIGGING.md); this file says when to open it and what it
+will not do for you.
+
+## Non-negotiables
+
+- **Validation is never bypassed.** `build` writes nothing on a red gate, and there
+  is no flag that changes that — AUTHORING §0.
+- **The compiler never invents a value.** A bone's `parent`, a slot's `bone`, a
+  constraint's `target` resolve by name and a miss is refused by name; a missing
+  number is a `CompileError` naming the field — AUTHORING §2 and §3.
+- **The validator's messages are the instructions.** Read each named failure as the
+  pointer to the file that has to change — AUTHORING §5.
+
+## What this guide will not do
+
+Nothing grades a hierarchy. A rig with its head off its torso passes the gate, the
+pixels are nearly blind to structure, and the two instruments that see it at all
+are named in RIGGING §11 — neither as a pass bar.
+
+## Read, in this order
+
+1. [AUTHORING.md](https://github.com/firejune/rigc/blob/main/docs/AUTHORING.md) — the rig spec field by field (§3),
+   the failure map (§5–§6), reading a pose out of a picture (§8.1, §11, §12),
+   and the editor's own conventions (§10).
+2. [RIGGING.md](https://github.com/firejune/rigc/blob/main/docs/RIGGING.md) — the structure itself: what identifies a
+   pivot and what moving one costs (§2–§3), gauges (§4), what a chain can reach
+   (§6), and the instruments that see structure (§11).
+3. Then [MOTION.md](https://github.com/firejune/rigc/blob/main/docs/MOTION.md) once the skeleton exists;
+   [FACE.md](https://github.com/firejune/rigc/blob/main/docs/FACE.md) if the figure is a head;
+   [INGEST.md](https://github.com/firejune/rigc/blob/main/docs/INGEST.md) if the skeleton was handed to you already
+   compiled.
+
+Every guide linked here is in the installed package at `node_modules/spine-rigc/docs/`,
+which is the copy that matches the rigc you run; the links go to the repository's
+`main`. Inside the Claude Code plugin the same files are at `${CLAUDE_PLUGIN_ROOT}/docs/`.
+
+The install line and the build → validate → render → check loop are in the `rigc`
+skill.

package/src/areaband.ts

@@ -0,0 +1,159 @@
+/**
+ * The area band a triangle's sign is read against — the one A39 reads a
+ * winding by, and the one the mesh-quality measurement reads orientation and
+ * degeneracy by (`src/meshquality.ts`).
+ *
+ * Moved here unchanged from `src/deformsurvey.ts`, which imports these back
+ * and re-exports every name it exported before, so no caller changed an import
+ * — and `stretchSingularValues` after them (issue #1230), for the motion
+ * comparison (`src/meshcompare.ts`), which reads a triangle's stretch the way
+ * the deform survey does and must not reach the compiler either.
+ * They moved because a module the `spine-rigc/mesh` entry reaches has to read
+ * the same band, and `src/deformsurvey.ts` reaches the compiler and the core
+ * (`src/deformstructure.ts`, `src/core/`) — a geometry entry that loaded the
+ * compiler to read three numbers would also close an import cycle through
+ * `src/compile.ts`, which imports `src/mesh.ts`.
+ *
+ * Imports nothing: no clock, no runtime, no other module.
+ */
+
+/**
+ * How near zero a triangle's area has to be, as a fraction of the largest
+ * triangle in the same mesh at the same pose, before a sign is not read off it.
+ *
+ * A RELATIVE band, because an absolute one has no scale that means anything on
+ * its own — these are pixel² figures on whatever plate the rig was drawn at, and
+ * `gallery/flex`'s leaf tops out at 792.6 px² where `spineboy-pro`'s hoverboard
+ * reaches 3338.4 px². On those two it comes to 7.9e-4 and 3.3e-3 px².
+ *
+ * ⚠️ It is **not** what holds the float32 noise off; `float32AreaNoise` is, and
+ * the two are combined rather than ranked because on a big mesh the noise bound
+ * is the larger of them. This one is the shape band: it keeps a setup triangle
+ * that has no area from being read as a reversal of anything, and a triangle the
+ * key collapses onto zero from being read as turned over.
+ */
+export const DEFORM_AREA_EPSILON = 1e-6;
+
+/** Half an ulp of a float32 mantissa — the relative error of one stored coordinate. */
+const FLOAT32_HALF_ULP = 2 ** -24;
+
+/**
+ * An upper bound on how much of a triangle's signed area is float32 noise.
+ *
+ * The world vertices arrive in a `Float32Array`, so each coordinate carries up
+ * to `|c|·2⁻²⁴` of error. An area is `½·(Δx₁·Δy₂ − Δx₂·Δy₁)`, and propagating
+ * that error through one product gives `Δ·|c|·2⁻²⁴` twice over; four such terms
+ * across the two products, halved, bounds the area error by `2·C²·2⁻²⁴` with `C`
+ * the largest coordinate magnitude in the mesh (which also bounds every `Δ`).
+ * Doubled once more for the subtraction, so the constant is 4.
+ *
+ * On a mesh whose vertices reach 500 units that is 6e-2 px², i.e. **larger** than
+ * the relative band above — which is the whole reason this exists. It is a bound
+ * rather than a measurement, and deliberately loose: what has to stay clear of it
+ * is a genuine reversal, and the smallest one anywhere in the corpus is
+ * `spineboy-pro`'s hoverboard triangle at 8.478 px², more than two orders of
+ * magnitude above. Nothing measured lands between the two, so nothing between
+ * them is being tuned.
+ */
+export function float32AreaNoise(world: ArrayLike<number>): number {
+  let coordinate = 0;
+  for (let i = 0; i < world.length; i++) coordinate = Math.max(coordinate, Math.abs(world[i]));
+  return 4 * coordinate * coordinate * FLOAT32_HALF_ULP;
+}
+
+/**
+ * Twice-signed area, halved, of every triangle of `triangles` over the
+ * interleaved `x, y` world vertices in `world`.
+ *
+ * The SIGN is the whole point and the magnitude is the tolerance's yardstick, so
+ * this returns the signed figure rather than an absolute one. Positive and
+ * negative are not "correct" and "wrong" — a mesh may be wound either way, and
+ * what A39 reads is whether one triangle's sign CHANGED.
+ */
+export function triangleAreas(world: ArrayLike<number>, triangles: ArrayLike<number>): number[] {
+  const out: number[] = [];
+  for (let t = 0; t + 2 < triangles.length; t += 3) {
+    const i0 = triangles[t] * 2;
+    const i1 = triangles[t + 1] * 2;
+    const i2 = triangles[t + 2] * 2;
+    const x0 = world[i0];
+    const y0 = world[i0 + 1];
+    out.push(0.5 * ((world[i1] - x0) * (world[i2 + 1] - y0) - (world[i2] - x0) * (world[i1 + 1] - y0)));
+  }
+  return out;
+}
+
+/**
+ * The dead band a set of areas is read against.
+ *
+ * Both bands, and the wider one wins. The relative one is about the SHAPE (a
+ * triangle with no area has no winding); the noise one is about the arithmetic (a
+ * sign read off float32 rounding is not a measurement). Each is the larger on a
+ * different mesh.
+ */
+export function areaBand(plainAreas: readonly number[], ...worlds: ReadonlyArray<ArrayLike<number>>): number {
+  const largest = plainAreas.reduce((m, a) => Math.max(m, Math.abs(a)), 0);
+  let band = largest * DEFORM_AREA_EPSILON;
+  for (const world of worlds) band = Math.max(band, float32AreaNoise(world));
+  return band;
+}
+
+/**
+ * The two singular values of the linear map that takes one triangle onto the
+ * other — the largest and smallest factor by which it scales a direction.
+ *
+ * ## Why this is the texture's stretch
+ *
+ * A mesh's uvs are fixed to the attachment and a deform never touches them, so
+ * the texture is mapped affinely onto the *plain* triangle and the same texels
+ * end up on the *deformed* one. The change in that mapping is exactly `J = D·P⁻¹`
+ * with `P` and `D` the two triangles' edge pairs, and its singular values are the
+ * worst stretch and the worst squash the drawing takes there. A σ of 1.4 means
+ * every texel in that direction is drawn 1.4 px wide; 0.6 means the art is
+ * crushed to 60%.
+ *
+ * `σ₁·σ₂ = |det J|` is the signed-area ratio's magnitude, which is why the two
+ * quantities in the report cannot disagree — and `DR01` is the control that says
+ * so on a case whose ratio the closed form predicts.
+ *
+ * Returns `null` for a plain triangle with no area: `P` is singular, there is no
+ * map, and inventing one would be the report's own version of the false green
+ * this file exists to avoid. Those triangles are counted as `degenerate`.
+ */
+export function stretchSingularValues(
+  plain: ArrayLike<number>,
+  deformed: ArrayLike<number>,
+  triangles: ArrayLike<number>,
+  t: number,
+): { max: number; min: number } | null {
+  const i0 = triangles[t * 3] * 2;
+  const i1 = triangles[t * 3 + 1] * 2;
+  const i2 = triangles[t * 3 + 2] * 2;
+  const ux = plain[i1] - plain[i0];
+  const uy = plain[i1 + 1] - plain[i0 + 1];
+  const vx = plain[i2] - plain[i0];
+  const vy = plain[i2 + 1] - plain[i0 + 1];
+  const det = ux * vy - vx * uy;
+  if (det === 0) return null;
+  const px = deformed[i1] - deformed[i0];
+  const py = deformed[i1 + 1] - deformed[i0 + 1];
+  const qx = deformed[i2] - deformed[i0];
+  const qy = deformed[i2 + 1] - deformed[i0 + 1];
+  // J = D·P⁻¹, written out — P⁻¹ = (1/det)·[[vy, −vx], [−uy, ux]].
+  const a = (px * vy - qx * uy) / det;
+  const b = (-px * vx + qx * ux) / det;
+  const c = (py * vy - qy * uy) / det;
+  const d = (-py * vx + qy * ux) / det;
+  // σ₁² + σ₂² = ‖J‖²_F and σ₁·σ₂ = |det J|, which is two equations for the two
+  // values and needs no eigen decomposition. The discriminant is non-negative in
+  // exact arithmetic (it is `(σ₁² − σ₂²)²`); the clamp is for rounding on a map
+  // that is very nearly a rotation.
+  const frobenius = a * a + b * b + c * c + d * d;
+  const determinant = a * d - b * c;
+  const discriminant = Math.max(0, frobenius * frobenius - 4 * determinant * determinant);
+  const root = Math.sqrt(discriminant);
+  return {
+    max: Math.sqrt(Math.max(0, (frobenius + root) / 2)),
+    min: Math.sqrt(Math.max(0, (frobenius - root) / 2)),
+  };
+}

package/src/assertions/bodies/a01.ts

@@ -0,0 +1,23 @@
+/**
+ * A01, restated over the emitted text (issue #1060): the clause
+ * `validate()` runs in `src/validate.ts`, word for word, over the skeleton JSON — the
+ * text rigc wrote, read by rigc's own reader rather than by spine-core's. The
+ * round trip's copy is unchanged and runs in `cli.ts build`; this one runs in
+ * the gate of the entry that links none of the runtime
+ * (`../emitted/index.ts`), and the selftest's `RC28` holds the two to the
+ * same lines on every recipe and on this assertion's mutants.
+ */
+import type { Verdicts } from '../harness.ts';
+import { TOPLEVEL_CONSTRAINT_ARRAYS } from '../../generation.ts';
+import type { Json } from '../values.ts';
+
+export function a01NoLegacyToplevelConstraintArrays({ fail }: Verdicts, raw: Json | null): void {
+  for (const key of TOPLEVEL_CONSTRAINT_ARRAYS) {
+    if (raw && key in raw) {
+      fail(
+        'A01_NO_LEGACY_TOPLEVEL_CONSTRAINT_ARRAYS',
+        `top-level "${key}" array present; 4.3 wants it inside "constraints" with type:"${key}"`,
+      );
+    }
+  }
+}

package/src/assertions/bodies/a02.ts

@@ -0,0 +1,21 @@
+/**
+ * A02, restated over the emitted text (issue #1060): the clause
+ * `validate()` runs in `src/validate.ts`, word for word, over the skeleton JSON — the
+ * text rigc wrote, read by rigc's own reader rather than by spine-core's. The
+ * round trip's copy is unchanged and runs in `cli.ts build`; this one runs in
+ * the gate of the entry that links none of the runtime
+ * (`../emitted/index.ts`), and the selftest's `RC28` holds the two to the
+ * same lines on every recipe and on this assertion's mutants.
+ */
+import type { Verdicts } from '../harness.ts';
+import { LEGACY_BONE_INHERIT_KEY } from '../../generation.ts';
+import { isObj, type Json } from '../values.ts';
+
+export function a02NoBoneTransformKey({ fail }: Verdicts, raw: Json | null): void {
+  const bones = Array.isArray(raw?.bones) ? (raw.bones as unknown[]) : [];
+  for (const bone of bones) {
+    if (isObj(bone) && LEGACY_BONE_INHERIT_KEY in bone) {
+      fail('A02_NO_BONE_TRANSFORM_KEY', `bone "${String(bone.name)}" uses "transform", the key 4.0 and 4.1 spelled; 4.2 and 4.3 spell it "inherit"`);
+    }
+  }
+}

package/src/assertions/bodies/a03.ts

@@ -0,0 +1,27 @@
+/**
+ * A03, the body (issue #1025, step 4c of #380): every region attachment has a
+ * finite, positive width and height (case 6c).
+ *
+ * Moved out of `src/validate.ts` unchanged but for what it reads: the region
+ * attachments are a fact (`../facts/skin_entries.ts`) rather than the list
+ * `validate()` filled from spine-core's loaded skins, so the same body runs over
+ * the model document. The `check` call — and so where the verdict sits in the
+ * report — stays in `validate()`.
+ */
+import type { Verdicts } from '../harness.ts';
+import type { SkinEntryFacts } from '../facts/skin_entries.ts';
+import { SKIP_NO_REGION_ATTACHMENT } from '../reasons.ts';
+
+export function a03RegionWidthHeightFinite({ fail, skip }: Verdicts, { regionAttachments }: SkinEntryFacts): void {
+  // ⟨subject⟩_⟨property⟩: with no region there is no size to find non-finite,
+  // and a loop over nothing used to report that as held (#580).
+  if (regionAttachments.length === 0) return skip('A03_REGION_WIDTH_HEIGHT_FINITE', SKIP_NO_REGION_ATTACHMENT);
+  for (const att of regionAttachments) {
+    if (!Number.isFinite(att.width) || !Number.isFinite(att.height)) {
+      fail('A03_REGION_WIDTH_HEIGHT_FINITE', `region "${att.name}" loaded w=${att.width} h=${att.height}`);
+    }
+    if (att.width <= 0 || att.height <= 0) {
+      fail('A03_REGION_WIDTH_HEIGHT_FINITE', `region "${att.name}" has a non-positive size`);
+    }
+  }
+}

package/src/assertions/bodies/a04.ts

@@ -0,0 +1,40 @@
+/**
+ * A04, the body (issue #1025, step 4c of #380): every mesh has triangles, in
+ * threes, each an index into its own vertices (case 6f).
+ *
+ * Moved out of `src/validate.ts` clause by clause. The three clauses about
+ * the triangles are about the rig — a document's mesh states its triangles
+ * and its vertices, so the same wrongness has a place to live there (where
+ * the reader refuses two of the three by the record's name) — and moved. The
+ * two about the vertex run — a weighted run whose length is not a multiple of
+ * three, an unweighted array of another length than the `uvs` — are about
+ * the encoding: the document states the weighted form outright, and the flat
+ * run is written by the emitter. They stay with the round trip, which hands
+ * their findings in as each mesh's `encoding`, printed where the body always
+ * printed them.
+ */
+import type { Verdicts } from '../harness.ts';
+import type { MeshFacts } from '../facts/mesh_attachments.ts';
+import { SKIP_NO_MESH_ATTACHMENT } from '../reasons.ts';
+
+export function a04MeshTrianglesAndEncoding({ fail, skip }: Verdicts, { meshes }: MeshFacts): void {
+  if (meshes.length === 0) return skip('A04_MESH_TRIANGLES_AND_ENCODING', SKIP_NO_MESH_ATTACHMENT);
+  for (const mesh of meshes) {
+    if (!mesh.triangles || mesh.triangles.length === 0) {
+      fail('A04_MESH_TRIANGLES_AND_ENCODING', `mesh "${mesh.name}" has no triangles`);
+      continue;
+    }
+    if (mesh.triangles.length % 3 !== 0) {
+      fail('A04_MESH_TRIANGLES_AND_ENCODING', `mesh "${mesh.name}" triangle count is not a multiple of 3`);
+    }
+    const vertexCount = mesh.worldVerticesLength / 2;
+    for (const idx of mesh.triangles) {
+      if (idx < 0 || idx >= vertexCount) {
+        fail('A04_MESH_TRIANGLES_AND_ENCODING', `mesh "${mesh.name}" index ${idx} is outside 0..${vertexCount - 1}`);
+        break;
+      }
+    }
+    // The encoding's own clauses, kept with the round trip (the header).
+    for (const detail of mesh.encoding) fail('A04_MESH_TRIANGLES_AND_ENCODING', detail);
+  }
+}

package/src/assertions/bodies/a05.ts

@@ -0,0 +1,56 @@
+/**
+ * A05, restated over the emitted text (issue #1060): the clause
+ * `validate()` runs in `src/validate.ts`, word for word, over the skeleton JSON — the
+ * text rigc wrote, read by rigc's own reader rather than by spine-core's. The
+ * round trip's copy is unchanged and runs in `cli.ts build`; this one runs in
+ * the gate of the entry that links none of the runtime
+ * (`../emitted/index.ts`), and the selftest's `RC28` holds the two to the
+ * same lines on every recipe and on this assertion's mutants.
+ */
+import type { Verdicts } from '../harness.ts';
+import { SKIP_NO_TIMELINE } from '../reasons.ts';
+import { CHANNELS_BY_KIND, walkTimelines } from '../../timelines.ts';
+import { isObj, type Json } from '../values.ts';
+
+export function a05CurveArrayLength({ fail, skip }: Verdicts, raw: Json | null): void {
+  // Two clauses, so the SKIP needs both to be empty (#580). The vocabulary
+  // clause below measures every timeline it is handed — an unchecked name is a
+  // finding whether or not any key on it carries a curve — so a skeleton with
+  // timelines and no curve at all has still been measured. What measures
+  // nothing is a skeleton `walkTimelines` never calls back on.
+  let timelines = 0;
+  walkTimelines(raw, (path, kind, name, keys) => {
+    timelines++;
+    const table = CHANNELS_BY_KIND[kind];
+    if (!(name in table)) {
+      fail('A05_CURVE_ARRAY_LENGTH', `${path}: unchecked ${kind} timeline "${name}" — extend the validator`);
+      return;
+    }
+    const channels = table[name];
+    for (const key of keys) {
+      if (!isObj(key) || !('curve' in key)) continue;
+      const curve = key.curve;
+      if (channels === null) {
+        fail('A05_CURVE_ARRAY_LENGTH', `${path}: timeline "${name}" cannot carry a curve`);
+        continue;
+      }
+      if (curve === 'stepped') continue;
+      if (!Array.isArray(curve)) {
+        fail('A05_CURVE_ARRAY_LENGTH', `${path}: curve is ${JSON.stringify(curve)}, expected "stepped" or an array`);
+        continue;
+      }
+      if (curve.length !== channels * 4) {
+        fail(
+          'A05_CURVE_ARRAY_LENGTH',
+          `${path} (t=${String(key.time ?? 0)}): curve has ${curve.length} numbers, "${name}" needs ${channels} channels x 4 = ${channels * 4}`,
+        );
+      }
+      for (const n of curve) {
+        if (typeof n !== 'number' || !Number.isFinite(n)) {
+          fail('A05_CURVE_ARRAY_LENGTH', `${path}: curve holds a non-finite value ${JSON.stringify(n)}`);
+        }
+      }
+    }
+  });
+  if (timelines === 0) return skip('A05_CURVE_ARRAY_LENGTH', SKIP_NO_TIMELINE);
+}