spine-rigc 1.9.1 → 1.9.2

package/cli.ts

@@ -338,13 +338,32 @@ function parseArgs(
  * unhandled `SyntaxError` with a stack trace instead of a usage error.
  */
 function readJsonFile(path: string): unknown {
+  return parseJsonNamed(readFileSync(path, 'utf8'), path);
+}
+
+/** `text`, read from `path`, parsed — and refused naming the file and where it broke when it is not JSON. */
+function parseJsonNamed(text: string, path: string): unknown {
   try {
-    return parseJsonWithPosition(readFileSync(path, 'utf8'));
+    return parseJsonWithPosition(text);
   } catch (err) {
     throw new UsageError(`cannot read ${path}: ${(err as Error).message}`);
   }
 }
 
+/**
+ * A skeleton a command was pointed at, as text — refused like every other JSON
+ * file on the command line (`parseJsonNamed`) when it is not JSON (issue
+ * #1042). `render`, `check`, `bench` and `bonedist` hand the text to a loader
+ * that parses it again, and on a file that is not JSON that parse surfaced as
+ * the runtime's `SyntaxError` and a stack, where `diff`, `preview`, `vote` and
+ * `ingest` already said `cannot read <path>`.
+ */
+function readSkeletonText(path: string): string {
+  const text = readFileSync(path, 'utf8');
+  parseJsonNamed(text, path);
+  return text;
+}
+
 /**
  * Read a cuts.json and resolve its three paths against the file's own
  * directory. Anchoring on the table rather than on the process cwd is what lets
@@ -1480,7 +1499,7 @@ function runCheck(
   // paths are what `candidatePosers` looks beside for `skeleton.model.json`.
   const poser = readPoserFlag(flags);
   return checkAgainstFrames({
-    skeletonText: readFileSync(skeletonPath, 'utf8'),
+    skeletonText: readSkeletonText(skeletonPath),
     atlasText,
     atlasDir: dirname(atlasPath),
     framesDir,
@@ -1805,7 +1824,7 @@ function cmdRender(flags: Record<string, string>): void {
   // subset roster and its pages without loading spine-core at all, and with a
   // rigc-compiled/2 document without its atlas either (issue #1020).
   const { choice, facts, pages } = loadCandidate(
-    { skeletonText: readFileSync(skeletonPath, 'utf8'), atlasText, atlasDir, label: skeletonPath },
+    { skeletonText: readSkeletonText(skeletonPath), atlasText, atlasDir, label: skeletonPath },
     { skeleton: skeletonPath, atlas: atlasPath },
     posersAsked(flags),
   );
@@ -1941,12 +1960,7 @@ function cmdRender(flags: Record<string, string>): void {
 
 /** The animation names an emitted skeleton carries, in the order it lists them. */
 function skeletonAnimationNames(skeletonText: string, path: string): string[] {
-  let parsed: unknown;
-  try {
-    parsed = parseJsonWithPosition(skeletonText);
-  } catch (err) {
-    throw new UsageError(`cannot read ${path}: ${(err as Error).message}`);
-  }
+  const parsed = parseJsonNamed(skeletonText, path);
   if (typeof parsed !== 'object' || parsed === null) throw new UsageError(`${path} is not a skeleton object`);
   const animations = (parsed as { animations?: unknown }).animations;
   if (animations === undefined) return [];
@@ -2541,8 +2555,11 @@ function cmdBench(flags: Record<string, string>, positional: string[]): void {
     throw new UsageError(`no example corpus at ${exportDir} — ${remedy} (examples/ is gitignored, not shipped)`);
   }
 
-  const { skeletonPath, atlasPath } = resolveArtifacts(flags.candidate, flags.atlas);
-  const skeletonText = readFileSync(skeletonPath, 'utf8');
+  // Both files there and the skeleton JSON before the first line is printed, refused by name as `render` refuses
+  // them (issue #1042): a missing file and a skeleton that is not JSON surfaced as an ENOENT or a SyntaxError and a
+  // stack, the second only after the validate block had printed.
+  const { skeletonPath, atlasPath } = resolveViewable({ candidate: flags.candidate, ...(flags.atlas === undefined ? {} : { atlas: flags.atlas }) });
+  const skeletonText = readSkeletonText(skeletonPath);
   const atlasText = readFileSync(atlasPath, 'utf8');
 
   console.log(`rigc bench rung ${rung.id} — ${rung.example}`);
@@ -2586,10 +2603,8 @@ function cmdBench(flags: Record<string, string>, positional: string[]): void {
       const boneDist = boneDistance({
         candidateSkeleton: skeletonPath,
         candidateAtlas: atlasPath,
-        candidateAtlasDir: dirname(atlasPath),
         referenceSkeleton: referencePath,
         referenceAtlas: join(exportDir, skeleton.atlas),
-        referenceAtlasDir: exportDir,
         bones: flags.bones,
         // Deliberately NOT `flags.fps`. Inside `bench` that flag already means
         // "the rate this frame set was recorded at, for a set with no sidecar",
@@ -2781,15 +2796,20 @@ function cmdBoneDist(flags: Record<string, string>): void {
         'names, so the mapping is an input and never a guess; pass `identity` to state that the two use the same names',
     );
   }
-  const candidate = resolveArtifacts(flags.candidate, flags.atlas);
-  const reference = resolveArtifacts(flags.reference, flags['reference-atlas']);
+  // Each side's files there and its skeleton JSON, refused by name as `render` refuses them (issue #1042); a pair
+  // that does not load is `boneDistance`'s refusal (`CandidatePairError`, exit 2 below).
+  const sideOf = (target: string, atlas: string | undefined): { skeletonPath: string; atlasPath: string } => {
+    const side = resolveViewable({ candidate: target, ...(atlas === undefined ? {} : { atlas }) });
+    readSkeletonText(side.skeletonPath);
+    return side;
+  };
+  const candidate = sideOf(flags.candidate, flags.atlas);
+  const reference = sideOf(flags.reference, flags['reference-atlas']);
   const report = boneDistance({
     candidateSkeleton: candidate.skeletonPath,
     candidateAtlas: candidate.atlasPath,
-    candidateAtlasDir: dirname(candidate.atlasPath),
     referenceSkeleton: reference.skeletonPath,
     referenceAtlas: reference.atlasPath,
-    referenceAtlasDir: dirname(reference.atlasPath),
     bones: flags.bones,
     ...(flags.fps === undefined ? {} : { fps: Number(flags.fps) }),
   });
@@ -4388,6 +4408,8 @@ try {
   // skeleton.json or an atlas from another build beside this one's model document. The same class as the
   // missing atlas above: nothing was posed or written, and it is the directory the command was pointed at that
   // has to change. The message names both files, the reason the runtime drew them and the runtime's own words.
+  // Since issue #1042 also `bonedist` and `bench --bones` on either side, and a page a candidate is drawn from that
+  // is not there, whichever poser draws it.
   if (err instanceof CandidatePairError) {
     console.error(`rigc ${command}: ${err.message}`);
     process.exit(2);

package/docs/AUTHORING.md

@@ -207,7 +207,7 @@ What the flags mean:
 | `--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 34 validity rules (**the default**) · `spine-html` = all 49, 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. 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`. 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 |
+| `--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) |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spine-rigc",
-  "version": "1.9.1",
+  "version": "1.9.2",
   "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/a10.ts

@@ -0,0 +1,116 @@
+/**
+ * A10, the body (issue #1025, cut 4c-5a of step 4c of #380): no pose the
+ * skeleton is stepped through holds a number that is not finite, or a bone
+ * with no inheritance mode.
+ *
+ * Moved out of `src/validate.ts` unchanged but for what it reads, which is
+ * `BoneTimelineFacts` (`../facts/bone_timelines.ts`) for the `inherit` keys
+ * where it read the skeleton JSON, and `SteppedPoseFacts`
+ * (`../facts/stepped_poses.ts`) where it posed a spine-core skeleton itself:
+ * the setup pose, each animation's looping walk, and a bone's mode posed at a
+ * key — which `validate()` takes from spine-core and the model side from
+ * rigc's core. The scan of a pose is `firstNonFinite` (`../../nonfinite.ts`),
+ * the sentence `render` refuses on, called rather than restated. The argument
+ * for each clause is above the `check` call, which stays in `validate()`.
+ */
+import type { Verdicts } from '../harness.ts';
+import type { BoneTimelineFacts } from '../facts/bone_timelines.ts';
+import type { SteppedFrame, SteppedPoseFacts } from '../facts/stepped_poses.ts';
+import { SKIP_NO_POSE } from '../reasons.ts';
+import { isObj } from '../values.ts';
+import { firstNonFinite } from '../../nonfinite.ts';
+import { BONE_INHERIT_KNOWN } from '../../rig.ts';
+
+/** The steps A10 takes through every animation: the walk is `max(duration, 1) / STEP_FRAMES` long per step. */
+export const STEP_FRAMES = 120;
+
+export function a10NoNanAfterStepping({ fail, skip, stats }: Verdicts, boneTimelines: BoneTimelineFacts, facts: SteppedPoseFacts): void {
+  if (facts.steppedAnimations.length === 0 && facts.boneCount === 0) {
+    skip('A10_NO_NAN_AFTER_STEPPING', SKIP_NO_POSE);
+    return;
+  }
+
+  // -- the bone's inheritance mode, posed at every `inherit` key
+  let unresolved = 0;
+  for (const { animation: animName, bone: boneName, timelines } of boneTimelines.boneTimelines) {
+    if (!isObj(timelines) || !Array.isArray(timelines.inherit)) continue;
+    if (!facts.hasAnimation(animName) || !facts.hasBone(boneName)) continue;
+    for (const rawKey of timelines.inherit as unknown[]) {
+      if (!isObj(rawKey)) continue;
+      const time = typeof rawKey.time === 'number' ? rawKey.time : 0;
+      const posed = facts.posedInherit(animName, boneName, time);
+      if (posed === null) continue;
+      unresolved++;
+      fail(
+        'A10_NO_NAN_AFTER_STEPPING',
+        `animation "${animName}" bone "${boneName}" inherit (t=${time}): the bone poses inheritance mode ` +
+          `${String(posed)} — the key spells ${JSON.stringify(rawKey.inherit)}, which the runtime's mode lookup ` +
+          `does not resolve (${BONE_INHERIT_KNOWN}), so no mode applies until the next key and the bone keeps ` +
+          'the world rotation, scale and shear it had',
+      );
+    }
+  }
+  if (unresolved > 0) return;
+
+  // -- the whole world transform, at the setup pose and every stepped frame
+  if (facts.steppedAnimations.length === 0) stats.nanStepping = 'skipped';
+  const atRest = facts.setup();
+  const atSetup = firstNonFinite('the setup pose', atRest.drawn, atRest.bones);
+  if (atSetup !== null) {
+    fail('A10_NO_NAN_AFTER_STEPPING', atSetup);
+    return;
+  }
+
+  /**
+   * What a posed frame shows that the world-transform scan does not read: a
+   * bone posing no inheritance mode, and a slot colour that is not finite.
+   * `where` leads the sentence — the animation's name at a stepped frame,
+   * as it always has, or `the setup pose` on a skeleton with no animation.
+   */
+  const poseDefect = (where: string, frame: SteppedFrame): string | null => {
+    for (const bone of frame.bones) {
+      if (bone.inherit !== null) {
+        return (
+          `${where}: bone "${bone.name}" poses inheritance mode ${bone.inherit} — its setup ` +
+          `spells inherit ${facts.statedInherit(bone.name)}, which the ` +
+          `runtime's mode lookup does not resolve (${BONE_INHERIT_KNOWN}), so its world rotation, scale and shear ` +
+          'are never computed — they stay 0 and everything the bone carries collapses to a point'
+        );
+      }
+    }
+    for (const slot of frame.slots) {
+      if (!slot.colour.every(Number.isFinite)) return `${where}: slot "${slot.name}" colour is non-finite`;
+      if (slot.dark !== null && !slot.dark.every(Number.isFinite)) {
+        return `${where}: slot "${slot.name}" dark colour is non-finite`;
+      }
+    }
+    return null;
+  };
+
+  if (facts.steppedAnimations.length === 0) {
+    const atRestDefect = poseDefect('the setup pose', atRest);
+    if (atRestDefect !== null) fail('A10_NO_NAN_AFTER_STEPPING', atRestDefect);
+    return;
+  }
+  for (const anim of facts.steppedAnimations) {
+    const step = Math.max(anim.duration, 1) / STEP_FRAMES;
+    const frames = facts.walk(anim.name, step, STEP_FRAMES);
+    for (let i = 0; i < STEP_FRAMES; i++) {
+      const frame = frames[i];
+      const found = firstNonFinite(
+        `animation ${JSON.stringify(anim.name)} frame ${i + 1} of ${STEP_FRAMES} (t=${((i + 1) * step).toFixed(4)}s)`,
+        frame.drawn,
+        frame.bones,
+      );
+      if (found !== null) {
+        fail('A10_NO_NAN_AFTER_STEPPING', found);
+        return;
+      }
+      const defect = poseDefect(anim.name, frame);
+      if (defect !== null) {
+        fail('A10_NO_NAN_AFTER_STEPPING', defect);
+        return;
+      }
+    }
+  }
+}

package/src/assertions/bodies/a34.ts

@@ -0,0 +1,133 @@
+/**
+ * A34, the body (issue #1025, cut 4c-5 of step 4c of #380): a constraint
+ * timeline aims at a constraint of that type.
+ *
+ * The argument — the two shapes, the lookup by name AND type, the empty key
+ * array the parser skips in silence, the physics group that names no
+ * constraint — stands above the `check` call in `validate()`.
+ *
+ * Moved out of `src/validate.ts` whole, every clause with it (cut 4c-4
+ * deferred it whole because its one rig clause shares this walk with the
+ * physics branch): which constraint an entry names, what it holds and whom a
+ * physics timeline naming none reaches are the rig's, and a document's records
+ * state each — except what no readable document can carry, which only the
+ * Spine text holds (a name the skeleton lacks, a name of another type, an
+ * empty key array, a bare key array where named timelines go): the model
+ * side's walk never meets those, and the reader refuses the document that
+ * would state them.
+ */
+import type { Verdicts } from '../harness.ts';
+import type { ConstraintTargetFacts, TargetKeyArray } from '../facts/constraint_targets.ts';
+import { CHANNELS_BY_KIND } from '../../timelines.ts';
+
+export function a34ConstraintTimelineTargets({ fail, skip }: Verdicts, facts: ConstraintTargetFacts): void {
+  if (facts.groupsByAnimation === null) return skip('A34_CONSTRAINT_TIMELINE_TARGETS', 'the skeleton declares no animations');
+  // name -> the KINDS declared under it, because that is the namespace the
+  // lookup this assertion is about resolves in: `findConstraint(name, type)`
+  // tests the type first, so a skeleton may carry `leg` as an ik constraint
+  // AND as a transform one and each group finds its own (issue #692). A map
+  // keyed by the name alone let the second of a pair overwrite the first, and
+  // this assertion then reported a correct file as a type mismatch.
+  const kindsOf = new Map<string, string[]>();
+  for (const entry of facts.constraints) {
+    if (entry.name !== null) kindsOf.set(entry.name, [...(kindsOf.get(entry.name) ?? []), entry.type]);
+  }
+  /** The file's physics constraints, which the unnamed physics group is read against. */
+  const rawPhysics = facts.constraints.filter((entry) => entry.type === 'physics');
+  let sawATimeline = false;
+  /** One target of one group: the name resolves, the type matches, keys exist. */
+  const checkTarget = (at: string, group: string, name: string, keyArrays: readonly TargetKeyArray[]): void => {
+    sawATimeline = true;
+    const declared = kindsOf.get(name) ?? [];
+    if (declared.length === 0) {
+      const known = [...kindsOf.entries()].filter(([, kinds]) => kinds.includes(group)).map(([n]) => n);
+      fail(
+        'A34_CONSTRAINT_TIMELINE_TARGETS',
+        `${at}: the skeleton's constraints array has no "${name}"` +
+          (known.length ? ` (${group} constraints: ${known.join(', ')})` : `, and no ${group} constraint at all`),
+      );
+      return;
+    }
+    if (!declared.includes(group)) {
+      fail(
+        'A34_CONSTRAINT_TIMELINE_TARGETS',
+        `${at}: "${name}" is declared as a "${declared.join('"/"')}" constraint, so the ${group} lookup misses it and the loader throws`,
+      );
+      return;
+    }
+    checkKeys(at, keyArrays);
+  };
+  /** The key arrays of one group entry that resolved: each one is walked, so each has to hold a key. */
+  const checkKeys = (at: string, keyArrays: readonly TargetKeyArray[]): void => {
+    if (keyArrays.length === 0) {
+      fail(
+        'A34_CONSTRAINT_TIMELINE_TARGETS',
+        `${at}: the constraint is named and carries no timeline at all; the group is walked and nothing happens`,
+      );
+      return;
+    }
+    for (const { timeline, keys } of keyArrays) {
+      if ('count' in keys && keys.count > 0) continue;
+      fail(
+        'A34_CONSTRAINT_TIMELINE_TARGETS',
+        `${at}${timeline ? ` timeline "${timeline}"` : ''}: the key array is ` +
+          `${'count' in keys ? 'empty' : keys.spelled}; the parser reads key 0, finds nothing and ` +
+          'skips the whole timeline without a word',
+      );
+    }
+  };
+  for (const { name: animName, groups } of facts.groupsByAnimation) {
+    for (const { group, entries } of groups) {
+      for (const { name, bare, keyArrays } of entries) {
+        // group.<constraint> = keys[]
+        if (group === 'ik' || group === 'transform') {
+          checkTarget(`animation "${animName}" ${group} timeline "${name}"`, group, name, keyArrays);
+          continue;
+        }
+        // group.<constraint>.<timeline> = keys[]
+        const at = `animation "${animName}" ${group} constraint "${name}"`;
+        if (bare !== null) {
+          sawATimeline = true;
+          fail(
+            'A34_CONSTRAINT_TIMELINE_TARGETS',
+            `${at}: this group maps a constraint to NAMED timelines ` +
+              `(${Object.keys(CHANNELS_BY_KIND[group]).join('/')}), and this one holds ${bare} — ` +
+              'a bare key array here is the ik/transform shape and is walked as an object',
+          );
+          continue;
+        }
+        // The empty name is not a miss: it is the physics group's global form,
+        // which `SkeletonJson` loads as `constraintIndex -1` rather than looking
+        // anything up, and which writes every physics constraint that declares
+        // the timeline's property global (issue #726). Refusing it as "no
+        // constraint called ''" was a sentence that is false about the file.
+        // What CAN be wrong with it is that it reaches nobody: the parser
+        // accepts it, the runtime walks every constraint, and none of them
+        // takes the key.
+        if (group === 'physics' && name === '') {
+          sawATimeline = true;
+          for (const { timeline: timelineName } of keyArrays) {
+            const reach = facts.reach(timelineName);
+            // A name the parser skips is skipped here too: no timeline exists
+            // to reach anybody, and whether the NAME is right is not a target
+            // question.
+            if (reach === null || reach.reached.length > 0) continue;
+            fail(
+              'A34_CONSTRAINT_TIMELINE_TARGETS',
+              `${at} timeline "${timelineName}": a physics group that names no constraint writes every physics ` +
+                `constraint ${reach.resets ? 'the skeleton has' : `declaring "${timelineName}Global": true`}, and ` +
+                (rawPhysics.length === 0 ? 'the skeleton has no physics constraint' : `none of ${rawPhysics.map((one) => `"${one.spelled}"`).join(', ')} does`) +
+                ' — the parser loads it, the runtime walks every constraint, and no constraint takes the key',
+            );
+          }
+          checkKeys(at, keyArrays);
+          continue;
+        }
+        checkTarget(at, group, name, keyArrays);
+      }
+    }
+  }
+  if (!sawATimeline) {
+    return skip('A34_CONSTRAINT_TIMELINE_TARGETS', 'no animation carries a constraint timeline');
+  }
+}

package/src/assertions/bodies/a40.ts

@@ -0,0 +1,128 @@
+/**
+ * A40, the body (issue #1025, cut 4c-5 of step 4c of #380): two sliders on
+ * one property, and the later one erases the other.
+ *
+ * The argument — why this is `validity`, the three shapes excluded
+ * structurally (authority below 1, a skin switch, different properties), the
+ * second clause and the events clause removed — stands above the `check` call
+ * in `validate()`. What a timeline does with `add` is the one fact here that
+ * is behaviour rather than a record: it is posed, and the body asks for it
+ * (`behaviour`) only for the later timeline of a shared property, once per
+ * timeline.
+ *
+ * Moved out of `src/validate.ts` whole: the sliders, their setup mix, their
+ * `additive` flag, the skins that list them, the animations they apply and the
+ * properties those animations' timelines register are the rig's, and a
+ * document's records state each; the class a timeline's additive application
+ * falls in is the core's computation over the document
+ * (`src/core/additive.ts`), held to the runtime's probe by the core suite's
+ * `CO27`. The words the sentences print are the facts' own: the runtime class
+ * a timeline loads as, the property's name, the target as the sentence names
+ * it.
+ */
+import type { Verdicts } from '../harness.ts';
+import type { ConstraintFacts } from '../facts/constraints.ts';
+import type { AddBehaviour, SliderCompositionFacts, SliderFact, SliderTimelineFact } from '../facts/slider_composition.ts';
+import { switchedOn } from '../constraint_words.ts';
+
+export function a40SlidersComposeOnASharedTarget({ fail, skip, stats }: Verdicts, facts: SliderCompositionFacts, constraints: ConstraintFacts): void {
+  const sliders = facts.sliders;
+  if (sliders.length < 2) {
+    return skip(
+      'A40_SLIDERS_COMPOSE_ON_A_SHARED_TARGET',
+      `the skeleton declares ${sliders.length} slider constraint${sliders.length === 1 ? '' : 's'}, and one slider has nothing to compose with`,
+    );
+  }
+  // Clause 1 of the "could this be correct?" list above the check.
+  // "Keyed at all" rather than "keyed live", and on purpose: this clause asks
+  // whether the mix can MOVE from its setup value, so any mix timeline
+  // disqualifies it — the question `keyedBy` answered here, through the one
+  // reading `switchedOn` gives (`../constraint_words.ts`, over the same facts
+  // the moved constraint bodies read — issue #1025), and unchanged by issue
+  // #752.
+  const mixKeyed = switchedOn(constraints, (timeline) => timeline.kind === 'slider' && timeline.word === 'mix', 1, () => true);
+  const authoritative = sliders.filter((s) => s.mix >= 1 && !mixKeyed.has(s.index));
+  if (authoritative.length < 2) {
+    return skip(
+      'A40_SLIDERS_COMPOSE_ON_A_SHARED_TARGET',
+      `${authoritative.length} of the ${sliders.length} slider constraints apply at full authority; below mix 1 an ` +
+        'apply is a lerp from the current pose rather than an overwrite, so what the others do to a shared property is a weighting',
+    );
+  }
+  /** Which skins switch a slider on, or null when it is active under every skin. */
+  const skinsOf = new Map<SliderFact, Set<string> | null>();
+  for (const slider of authoritative) skinsOf.set(slider, slider.skinRequired ? new Set(slider.skins) : null);
+  /** Clause 2: can these two ever run in the same frame? */
+  const canOverlap = (a: SliderFact, b: SliderFact): boolean => {
+    const skinsA = skinsOf.get(a) ?? null;
+    const skinsB = skinsOf.get(b) ?? null;
+    if (!skinsA || !skinsB) return true;
+    for (const name of skinsA) {
+      if (skinsB.has(name)) return true;
+    }
+    return false;
+  };
+  type User = { slider: SliderFact; timeline: SliderTimelineFact; animation: string; at: number; property: string; names: string };
+  /** property id -> the sliders whose animation keys it, in constraints-array order. */
+  const byProperty = new Map<string, User[]>();
+  for (const slider of authoritative) {
+    const seen = new Set<string>();
+    const animation = slider.animation;
+    if (animation === null) continue;
+    animation.timelines.forEach((timeline, at) => {
+      for (const { id, property, names } of timeline.properties) {
+        if (seen.has(id)) continue;
+        seen.add(id);
+        byProperty.set(id, [...(byProperty.get(id) ?? []), { slider, timeline, animation: animation.name, at, property, names }]);
+      }
+    });
+  }
+  /** Posed once per timeline, because the answer is the class's and the rigs that reach here share timelines. */
+  const behaviour = new Map<string, AddBehaviour>();
+  const addBehaviourOf = (user: User): AddBehaviour => {
+    const key = `${user.animation}\u0000${user.at}`;
+    const known = behaviour.get(key);
+    if (known !== undefined) return known;
+    const measured = facts.behaviour(user.animation, user.at);
+    behaviour.set(key, measured);
+    return measured;
+  };
+  let shared = 0;
+  for (const [, users] of byProperty) {
+    if (users.length < 2) continue;
+    shared++;
+    const at = (slider: SliderFact): string => `"${slider.name}" (constraints[${slider.index}], additive: ${String(slider.additive)})`;
+    const chain = users.map((u) => at(u.slider)).join(', ');
+    for (let j = 1; j < users.length; j++) {
+      const later = users[j];
+      const composes = addBehaviourOf(later);
+      if (composes === 'accumulates' && later.slider.additive) continue;
+      // Nothing a second slider could take away: applied with the arguments
+      // a slider passes — `firedEvents` null among them — this timeline
+      // moves no pose at all.
+      if (composes === 'inert') continue;
+      const erased = users.slice(0, j).filter((e) => canOverlap(e.slider, later.slider));
+      if (!erased.length) continue;
+      const erasedNames = `${erased.map((e) => `"${e.slider.name}"`).join(', ')} contribute${erased.length === 1 ? 's' : ''}`;
+      const why =
+        composes === 'accumulates'
+          ? `slider "${later.slider.name}" applies animation "${later.slider.animation?.name}" with additive false, and at ` +
+            'mix 1 a non-additive apply writes the value outright (`getRelativeValue` returns `setup + value`, ' +
+            '`getAbsoluteValue` returns `value`) rather than adding to the pose it found. Set `"additive": true` on ' +
+            `slider "${later.slider.name}" in the rig spec — rigc will not choose that flag for you — or key this ` +
+            `property from one slider only. [measured] \`${later.timeline.runtimeClass}.apply\` posed twice with ` +
+            '`add` set accumulates, so that flag is the repair here'
+          : `the ${later.property} timeline they share writes its value outright whatever the ` +
+            `flags say — [measured] \`${later.timeline.runtimeClass}.apply\` posed twice with \`add\` set left the ` +
+            'same value there rather than adding to it — so `"additive": true` would NOT compose these. Key this ' +
+            'property from one slider only, or move both edits into the one animation a single slider applies';
+      fail(
+        'A40_SLIDERS_COMPOSE_ON_A_SHARED_TARGET',
+        `${later.names} is keyed by the animations of ${users.length} sliders — ${chain} — and every ` +
+          `one of them applies at mix 1. Today ${at(later.slider)} wins that property and ${erasedNames} ` +
+          `nothing to it: ${why}.`,
+      );
+    }
+  }
+  stats.sliderSharedTargets = shared;
+}

package/src/assertions/facts/constraint_targets.ts

@@ -0,0 +1,56 @@
+/**
+ * The constraint timelines of every animation, as A34 walks them (issue
+ * #1025, cut 4c-5 of step 4c of #380): the constraints the skeleton declares,
+ * and each animation's `ik`, `transform`, `path`, `physics` and `slider`
+ * groups as the Spine file states them — the constraint each entry names and
+ * the key arrays under it.
+ *
+ * ⭐ **The order is the file's.** The animations in the order the file keys
+ * them, in each the five groups in that fixed order, each group's entries in
+ * the order the file keys them, each entry's timelines likewise: A34 prints
+ * one line per finding, so the walk is a fact both suppliers state.
+ *
+ * 🔸 **Which constraints a physics timeline naming none reaches is a
+ * question, not a value** — the runtime answers it by building the timeline
+ * its parser builds for the name and asking each constraint's data whether it
+ * takes the key (`unnamedPhysicsReach`), the model side by the core's own
+ * reading (`posedPhysics`, through `unnamedReach`). A body asks for it
+ * (`reach`), and the selftest puts every question to both (`VF14`).
+ *
+ * Links nothing from the runtime.
+ */
+
+/** One key array under an entry: the timeline's name (`''` for the `ik`/`transform` shape) and what it holds — how many keys, or the spelling of a value that is not a list. */
+export interface TargetKeyArray {
+  readonly timeline: string;
+  readonly keys: { readonly count: number } | { readonly spelled: string };
+}
+
+/** One entry of a group: the constraint name the file keys it by, and either the spelling of a value that is not an object where named timelines go (`bare`) or its key arrays. */
+export interface TargetEntry {
+  readonly name: string;
+  readonly bare: string | null;
+  readonly keyArrays: readonly TargetKeyArray[];
+}
+
+/** One animation: its name and the groups it states, in the walk's order. */
+export interface TargetAnimation {
+  readonly name: string;
+  readonly groups: ReadonlyArray<{ readonly group: 'ik' | 'transform' | 'path' | 'physics' | 'slider'; readonly entries: readonly TargetEntry[] }>;
+}
+
+/** What a physics timeline naming no constraint reaches: whether it is a `reset`, and the constraints that take its key. */
+export interface UnnamedReach {
+  readonly resets: boolean;
+  readonly reached: readonly string[];
+}
+
+/** What A34 reads. */
+export interface ConstraintTargetFacts {
+  /** Every entry of the skeleton's `constraints` array that is an object: its name (null when it states none as a string), its type as spelled, and its name as the sentence spells it. */
+  readonly constraints: ReadonlyArray<{ readonly name: string | null; readonly type: string; readonly spelled: string }>;
+  /** Every animation, or `null` when the skeleton declares none (its `animations` is not an object). */
+  readonly groupsByAnimation: readonly TargetAnimation[] | null;
+  /** What a physics timeline named `timeline` that names no constraint reaches — or `null` for a name the parser builds no timeline for. */
+  reach(timeline: string): UnnamedReach | null;
+}