spine-rigc 1.9.0 → 1.9.2

package/src/validate.ts

@@ -15,6 +15,7 @@
  */
 import { dirname, resolve } from 'node:path';
 import {
+  type Animation,
   AnimationState,
   AnimationStateData,
   AtlasAttachmentLoader,
@@ -40,6 +41,7 @@ import {
   PhysicsConstraintTimeline,
   Property,
   RegionAttachment,
+  SequenceTimeline as RuntimeSequenceTimeline,
   Skeleton,
   SkeletonJson,
   SliderData,
@@ -58,36 +60,25 @@ import {
 // them, so it is already on `package.json`'s `files` allowlist — see CLAUDE.md.
 // A19 needs the DECODED page, not its header, to measure one region's own
 // rectangle on a shared page.
-import {
-  BEZIER_POINTS,
-  curveStorage,
-  surveyDeformKeys,
-  unreachableWhy,
-  type DeformDialDispute,
-  type DeformDialTie,
-  type DeformReach,
-  type DialSpan,
-} from './deformmeasure.ts';
+import { BEZIER_POINTS, curveStorage, surveyDeformKeys } from './deformmeasure.ts';
 import {
   LEGACY_BONE_INHERIT_KEY,
   spineGeneration,
   TOPLEVEL_CONSTRAINT_ARRAYS,
   type SpineGeneration,
 } from './generation.ts';
-import { nonFiniteOfPosed } from './render.ts';
+import { posedNumbersOf } from './render.ts';
 import { BONE_INHERIT_KNOWN } from './rig.ts';
 import {
   CHANNELS_BY_KIND,
-  float32Step,
   physicsRuleFor,
-  SEQUENCE_MODES,
   SLOT_COLOR_CHANNELS,
   walkTimelines,
 } from './timelines.ts';
 import type { RigInfo } from './types.ts';
 import { ASSERTION_KIND, kindRunsUnder, type AssertionProfile } from './assertions/kinds.ts';
 import { verdictHarness, type Failure } from './assertions/harness.ts';
-import { atStoredKey, isObj, type Json } from './assertions/values.ts';
+import { isObj, type Json } from './assertions/values.ts';
 import type { SkinEntryFacts } from './assertions/facts/skin_entries.ts';
 import type { AtlasPageFacts } from './assertions/facts/atlas_pages.ts';
 import type { SlotColourFacts, SlotTimelines } from './assertions/facts/slot_colour.ts';
@@ -129,18 +120,39 @@ import { a42DrivenConstraintsUpdateAfterTheirDriver } from './assertions/bodies/
 import { a44LinkedMeshStatesNoGeometryOfItsOwn } from './assertions/bodies/a44.ts';
 import { a47IkConstraintNotMutedThroughout } from './assertions/bodies/a47.ts';
 import { a48TransformConstraintNotMutedThroughout } from './assertions/bodies/a48.ts';
+import type { RosterBone, RosterSlot, SkeletonRosterFacts } from './assertions/facts/skeleton_roster.ts';
+import type { BoneTimelineFacts, BoneTimelines } from './assertions/facts/bone_timelines.ts';
+import type { EventKeyEntry, EventKeyFacts } from './assertions/facts/event_keys.ts';
+import { a12NoDarkColor } from './assertions/bodies/a12.ts';
+import { a24AxisSpaceStroke } from './assertions/bodies/a24.ts';
+import { a25DetachedBoneParentage } from './assertions/bodies/a25.ts';
+import { a26SlotDrawOrder } from './assertions/bodies/a26.ts';
+import { a29StrokeWithinContactDepth } from './assertions/bodies/a29.ts';
+import { a30StrokeWithinCapContainment } from './assertions/bodies/a30.ts';
+import { a32EventKeysResolve, eventKeyAt } from './assertions/bodies/a32.ts';
 import {
   SKIP_NO_ANIMATION,
   SKIP_NO_ATLAS,
   SKIP_NO_ATLAS_PAGE,
-  SKIP_NO_DECLARED_DURATION,
   SKIP_NO_MESH_ATTACHMENT,
   SKIP_NO_POSE,
-  SKIP_NO_SEQUENCE,
   SKIP_NO_SKELETON,
   SKIP_NO_TIMELINE,
-  SKIP_NO_TWO_COLOR_TINT,
 } from './assertions/reasons.ts';
+import type { DeformSurveyFacts } from './assertions/facts/deform_survey.ts';
+import type { AnimationDurationFacts } from './assertions/facts/animation_durations.ts';
+import type { TwoColourFacts } from './assertions/facts/two_colour.ts';
+import { entryAddress, type EntryAddress, type SequenceFacts, type SequenceSkinEntry, type SequenceTimeline } from './assertions/facts/sequences.ts';
+import { a39DeformKeepsTriangleWinding } from './assertions/bodies/a39.ts';
+import { a09AnimationDurationMatchesSpec } from './assertions/bodies/a09.ts';
+import { a43TwoColorTintLoadsAndPosesAsWritten } from './assertions/bodies/a43.ts';
+import { a46SequenceAttachmentsShowTheFrameTheFileStates } from './assertions/bodies/a46.ts';
+import type { SliderCompositionFacts, SliderFact, SliderTimelineFact } from './assertions/facts/slider_composition.ts';
+import type { ConstraintTargetFacts, TargetAnimation, TargetKeyArray } from './assertions/facts/constraint_targets.ts';
+import { a34ConstraintTimelineTargets } from './assertions/bodies/a34.ts';
+import { a40SlidersComposeOnASharedTarget } from './assertions/bodies/a40.ts';
+import { a10NoNanAfterStepping } from './assertions/bodies/a10.ts';
+import type { SteppedFrame, SteppedPoseFacts } from './assertions/facts/stepped_poses.ts';
 
 export type { Failure } from './assertions/harness.ts';
 
@@ -284,62 +296,9 @@ export interface ValidateReport {
   stats: Record<string, number | string>;
 }
 
-/**
- * The clause A39 puts after an animation's name when the frame it measured is
- * not the track (issue #407).
- *
- * Empty on the track, which is what every animation no slider applies gets — so
- * a message about a rig with no sliders in it reads exactly as it always has.
- */
-function frameClause(reach: DeformReach): string {
-  return reach.kind === 'slider' ? ` (applied by slider "${reach.slider}", not played on a track)` : '';
-}
-
-/**
- * A dial's reach as A39's stats line spells it, or `none` when it can select no
- * part of its animation at all.
- *
- * Six decimals because a key time has six: a reach whose end is printed coarser
- * than the times it is compared against cannot be read against them.
- */
-function dialSpanText(span: DialSpan | null): string {
-  return span === null ? 'none' : `${span.lo.toFixed(6)}..${span.hi.toFixed(6)}s`;
-}
-
-/**
- * One disputed dial on A39's stats line — both answers, both reaches, and the
- * frames the artifact's answer could not have posed (issue #427).
- *
- * ⭐ **`outside:` is always there, `none` included.** The comparison it reports is
- * what decides whether a disagreement changed anything the survey measured, and a
- * comparison that came out equal must not look like one nobody made. It is the
- * difference between "both answers pose the same frames, so the disagreement is a
- * fact about rigc and not about this rig" and "these key times were surveyed
- * through a field the skeleton does not name and no settable value of the one it
- * does reaches them".
- *
- * ⚠️ No spaces anywhere in it: the stats line is `k=v` pairs joined by spaces, and
- * a value with a space in it turns one reading into two.
- */
-function dialDisputeText(dispute: DeformDialDispute): string {
-  const stated = dispute.statedResponse === null ? 'unmeasured' : dispute.statedResponse.toExponential(3);
-  return (
-    `${dispute.slider}|artifact:${dispute.bone}.${dispute.stated}@${stated}` +
-    `|reaches:${dialSpanText(dispute.statedReach)}` +
-    `|probe:${dispute.bone}.${dispute.drive}@${dispute.driveResponse.toExponential(3)}` +
-    `|reaches:${dialSpanText(dispute.driveReach)}` +
-    `|outside:${dispute.outside.length === 0 ? 'none' : dispute.outside.map((t) => `${t.toFixed(6)}s`).join('+')}`
-  );
-}
-
-/** One tied dial on the same line, in the shape that cannot be read as a dispute. */
-function dialTieText(tie: DeformDialTie): string {
-  const rivals = tie.rivals.map((r) => `${tie.bone}.${r.field}@${r.response.toExponential(3)}`).join('+');
-  return `${tie.slider}|artifact:${tie.bone}.${tie.drive}@${tie.driveResponse.toExponential(3)}|tied:${rivals}`;
-}
-
-const FRAME = 1 / 60;
-const STEP_FRAMES = 120;
+// The four sentences A39 prints a frame, a dial's reach, a dispute and a tie
+// with, and A09's one-frame slack, are `./assertions/bodies/a39.ts`'s and
+// `./assertions/bodies/a09.ts`'s since issue #1025 (cut 4c-3).
 
 /**
  * The constraint groups that spell `group.<constraint>.<timeline>` — a
@@ -696,18 +655,18 @@ export type TimelineAddBehaviour = 'accumulates' | 'overwrites' | 'inert';
  */
 const PROBE_DISPLACEMENT = 0.375;
 
-/** Every own value of a pose object a timeline could have written, as text. */
-function poseReading(pose: object): string {
-  const parts: string[] = [];
+/** Every own value of a pose object a timeline could have written, each as its key and its text. */
+function poseParts(pose: object): Array<[string, string]> {
+  const parts: Array<[string, string]> = [];
   for (const key of Object.keys(pose).sort()) {
     const value = (pose as Record<string, unknown>)[key];
     if (value === null || value === undefined || typeof value === 'number' || typeof value === 'boolean' || typeof value === 'string') {
-      parts.push(`${key}=${String(value)}`);
+      parts.push([key, String(value)]);
       continue;
     }
     if (Array.isArray(value)) {
       const entries: unknown[] = value;
-      if (entries.every((one) => typeof one === 'number')) parts.push(`${key}=[${entries.join(',')}]`);
+      if (entries.every((one) => typeof one === 'number')) parts.push([key, `[${entries.join(',')}]`]);
       continue;
     }
     if (typeof value !== 'object') continue;
@@ -717,12 +676,17 @@ function poseReading(pose: object): string {
     // structure — a bone back-reference, a slot's data — is either an identity
     // (read by name below) or something no timeline writes.
     if (keys.length > 0 && keys.every((one) => typeof record[one] === 'number')) {
-      parts.push(`${key}={${keys.map((one) => `${one}:${String(record[one])}`).join(',')}}`);
+      parts.push([key, `{${keys.map((one) => `${one}:${String(record[one])}`).join(',')}}`]);
     } else if (typeof record.name === 'string') {
-      parts.push(`${key}=@${record.name}`);
+      parts.push([key, `@${record.name}`]);
     }
   }
-  return parts.join(',');
+  return parts;
+}
+
+/** Every own value of a pose object a timeline could have written, as text. */
+function poseReading(pose: object): string {
+  return poseParts(pose).map(([key, text]) => `${key}=${text}`).join(',');
 }
 
 /** The whole of what a timeline could have changed, in one comparable string. */
@@ -848,6 +812,73 @@ export function timelineAddBehaviour(data: ReturnType<SkeletonJson['readSkeleton
   return wrote ? 'overwrites' : 'inert';
 }
 
+/** One skin under one start state of `timelineAddBehaviour`'s probe: what the cell reads, and every pose field the applications moved. */
+export interface TimelineAddCell {
+  /** The skin worn, `(none)` for no skin set. */
+  view: string;
+  state: 'setup' | 'displaced';
+  /** `A` a second application moved the pose at some time, `W` only the first did, `-` neither ever did. */
+  letter: 'A' | 'W' | '-';
+  /** Each field the first or the second application moved, at each time: `bone:<name>.<key>`, `slot:<name>.<key>` or `constraint:<name>.<key>`, with its three readings. */
+  changed: Array<{ field: string; t: number; before: string; once: string; twice: string }>;
+}
+
+/**
+ * `timelineAddBehaviour`'s probe, every cell kept: the same skins, start states,
+ * times and arguments, read per field rather than as one string — what the
+ * core suite's `CO27` holds the core's additive probe (`src/core/additive.ts`)
+ * to, cell by cell and value by value (issue #1025, cut 4c-5). The class the
+ * cells read is held to `timelineAddBehaviour`'s own answer on every timeline
+ * there, so the two cannot drift.
+ */
+export function timelineAddCells(data: ReturnType<SkeletonJson['readSkeletonData']>, timeline: Timeline): TimelineAddCell[] {
+  const fields = (skeleton: Skeleton): Map<string, string> => {
+    const out = new Map<string, string>();
+    const take = (kind: string, name: string, pose: object): void => {
+      for (const [key, text] of poseParts(pose)) out.set(`${kind}:${name}.${key}`, text);
+    };
+    for (const bone of skeleton.bones) take('bone', bone.data.name, bone.appliedPose);
+    for (const slot of skeleton.slots) take('slot', slot.data.name, slot.appliedPose);
+    for (const constraint of skeleton.constraints) take('constraint', constraint.data.name, constraint.appliedPose as object);
+    out.set('drawOrder', skeleton.drawOrder.appliedPose.map((slot) => slot.data.name).join('>'));
+    return out;
+  };
+  const cells: TimelineAddCell[] = [];
+  for (const skin of [null, ...data.skins]) {
+    const skeleton = new Skeleton(data);
+    if (skin !== null) skeleton.setSkin(skin);
+    probeStartStates(skeleton).forEach((displace, at) => {
+      const cell: TimelineAddCell = { view: skin?.name ?? '(none)', state: at === 0 ? 'setup' : 'displaced', letter: '-', changed: [] };
+      for (const time of probeTimes(timeline)) {
+        skeleton.setupPose();
+        for (const bone of skeleton.bones) bone.resetConstrained();
+        for (const slot of skeleton.slots) slot.resetConstrained();
+        for (const constraint of skeleton.constraints) constraint.resetConstrained();
+        skeleton.drawOrder.resetConstrained();
+        displace();
+        const before = fields(skeleton);
+        timeline.apply(skeleton, time, time, null, 1, MixFrom.current, true, false, true);
+        const once = fields(skeleton);
+        timeline.apply(skeleton, time, time, null, 1, MixFrom.current, true, false, true);
+        const twice = fields(skeleton);
+        let wrote = false;
+        let again = false;
+        for (const [field, b] of before) {
+          const o = once.get(field) ?? '';
+          const w = twice.get(field) ?? '';
+          if (o !== b) wrote = true;
+          if (w !== o) again = true;
+          if (o !== b || w !== o) cell.changed.push({ field, t: time, before: b, once: o, twice: w });
+        }
+        if (again) cell.letter = 'A';
+        else if (wrote && cell.letter === '-') cell.letter = 'W';
+      }
+      cells.push(cell);
+    });
+  }
+  return cells;
+}
+
 /**
  * Where two texts first differ, as A18 names it: the 1-based line and each
  * side's line, trimmed and cut to 120 characters.
@@ -898,6 +929,9 @@ export function runtimeFacts(skeletonText: string, atlasText: string): {
   regionJoins: RegionJoinFacts;
   atlasRegions: AtlasRegionFacts;
   stage: StageFacts;
+  skeletonRoster: SkeletonRosterFacts;
+  boneTimelines: BoneTimelineFacts;
+  eventKeys: EventKeyFacts;
 } | null {
   let atlas: TextureAtlas;
   let data: ReturnType<SkeletonJson['readSkeletonData']>;
@@ -918,9 +952,140 @@ export function runtimeFacts(skeletonText: string, atlasText: string): {
     regionJoins: spineRegionJoins(atlasText, raw),
     atlasRegions: { atlas },
     stage: spineStage(data),
+    skeletonRoster: rawSkeletonRoster(raw),
+    boneTimelines: rawBoneTimelines(raw),
+    eventKeys: rawEventKeys(raw),
   };
 }
 
+/**
+ * The runtime's supply of `SkeletonRosterFacts` (issue #1025, cut 4c-4): the
+ * skeleton JSON's `bones` and `slots`, read as A12, A25 and A26 always read
+ * them — a slot is any object in the array, named `String(name)`, dark where
+ * the key is present; a bone is an object with a string name, its parent the
+ * string the file states or `null`. Off the raw JSON because those three run
+ * whatever the round trip did. The model side's supply is
+ * `./assertions/model/skeleton_roster.ts`.
+ */
+export function rawSkeletonRoster(raw: Json | null): SkeletonRosterFacts {
+  const bones: RosterBone[] = [];
+  for (const bone of Array.isArray(raw?.bones) ? (raw.bones as unknown[]) : []) {
+    if (isObj(bone) && typeof bone.name === 'string') bones.push({ name: bone.name, parent: typeof bone.parent === 'string' ? bone.parent : null });
+  }
+  const slots: RosterSlot[] = (Array.isArray(raw?.slots) ? (raw.slots as unknown[]) : []).filter(isObj).map((s) => ({ name: String(s.name), dark: 'dark' in s }));
+  return { bones, slots };
+}
+
+/**
+ * The slot timelines of the skeleton JSON in the file's order — every
+ * animation that is an object, every slot entry that is an object — the walk
+ * `walkTimelines` made for A12 (issue #1025, cut 4c-4), and the same walk
+ * A45's supply makes (`spineSlotColourFacts`), here without the loaded
+ * skeleton because A12 runs whatever the round trip did. The model side
+ * supplies the same list (`fileSlotTimelines`).
+ */
+export function rawSlotTimelines(raw: Json | null): SlotTimelines[] {
+  const out: SlotTimelines[] = [];
+  const rawAnimations = isObj(raw) && isObj(raw.animations) ? raw.animations : {};
+  for (const [animation, anim] of Object.entries(rawAnimations)) {
+    if (!isObj(anim) || !isObj(anim.slots)) continue;
+    for (const [slot, timelines] of Object.entries(anim.slots)) {
+      if (!isObj(timelines)) continue;
+      out.push({ animation, slot, timelines });
+    }
+  }
+  return out;
+}
+
+/**
+ * The runtime's supply of `BoneTimelineFacts` (issue #1025, cut 4c-4): every
+ * (animation, bone) pair of the skeleton JSON, in the file's order — every
+ * animation that is an object with a `bones` object, every bone entry,
+ * whatever it holds — the walk A24, A29 and A30 made over the raw JSON. The
+ * model side's supply is `./assertions/model/bone_timelines.ts`.
+ */
+export function rawBoneTimelines(raw: Json | null): BoneTimelineFacts {
+  const boneTimelines: BoneTimelines[] = [];
+  const anims = isObj(raw?.animations) ? (raw.animations as Json) : {};
+  for (const [animation, anim] of Object.entries(anims)) {
+    if (!isObj(anim) || !isObj(anim.bones)) continue;
+    for (const [bone, timelines] of Object.entries(anim.bones as Json)) boneTimelines.push({ animation, bone, timelines });
+  }
+  return { boneTimelines };
+}
+
+/**
+ * The runtime's supply of `EventKeyFacts` (issue #1025, cut 4c-4) — and the
+ * four clauses of A32 that stay with the round trip.
+ *
+ * Every event key of the skeleton JSON, in the file's order, with what the
+ * body's one moved clause reads (the fields the key states, whether its event
+ * declares an audio path). The four clauses below run here, over the raw JSON,
+ * exactly as they ran in A32's body, and hand their findings in as `kept`, in
+ * the order they printed, with `stopped` where the clause ended the key's
+ * reading (the body prints them at the same place). They stay because each is
+ * a state the model document's reader refuses by name (`readEventKeys` in
+ * `src/core/events.ts`): a key with no string name, an event the skeleton
+ * does not declare, a time that is not a finite number, a time before the key
+ * before it — measured on forged documents, each refused at the key's
+ * address, so no readable document reaches them and the model side has no
+ * input to print them from.
+ */
+export function rawEventKeys(raw: Json | null): EventKeyFacts {
+  if (!raw) return { parsed: false, animations: false, timelines: 0, keys: [] };
+  if (!isObj(raw.animations)) return { parsed: true, animations: false, timelines: 0, keys: [] };
+  const declared = isObj(raw.events) ? (raw.events as Json) : {};
+  const known = Object.keys(declared);
+  const keys: EventKeyEntry[] = [];
+  let timelines = 0;
+  for (const [animName, anim] of Object.entries(raw.animations as Json)) {
+    if (!isObj(anim) || !Array.isArray(anim.events)) continue;
+    timelines++;
+    let previous = -Infinity;
+    (anim.events as unknown[]).forEach((key, k) => {
+      const at = eventKeyAt(animName, k);
+      const kept: string[] = [];
+      const stop = (name: string): void => void keys.push({ animation: animName, index: k, kept, stopped: true, name, sets: { volume: false, balance: false }, audio: false });
+      if (!isObj(key) || typeof key.name !== 'string') {
+        kept.push(`${at}: an event key needs a string "name"`);
+        return stop('');
+      }
+      const definition = declared[key.name];
+      if (definition === undefined) {
+        kept.push(
+          `${at}: fires "${key.name}", which the skeleton's events block does not declare` +
+            (known.length ? ` (declared: ${known.join(', ')})` : ' (that block is empty or absent)'),
+        );
+        return stop(key.name);
+      }
+      // `time` defaults to 0 when absent (`:1247`), which is what the editor
+      // writes for a firing on frame 0.
+      const time = key.time === undefined ? 0 : key.time;
+      if (typeof time !== 'number' || !Number.isFinite(time)) {
+        kept.push(`${at}: time is ${JSON.stringify(key.time)}, not a finite number`);
+        return stop(key.name);
+      }
+      if (time < previous) {
+        kept.push(
+          `${at}: "${key.name}" is at t=${time}, after a key at t=${previous} — the parser fills frames in ` +
+            'array order and never sorts them, so the earlier firing is unreachable',
+        );
+      }
+      previous = Math.max(previous, time);
+      keys.push({
+        animation: animName,
+        index: k,
+        kept,
+        stopped: false,
+        name: key.name,
+        sets: { volume: key.volume !== undefined, balance: key.balance !== undefined },
+        audio: isObj(definition) && typeof definition.audio === 'string',
+      });
+    });
+  }
+  return { parsed: true, animations: true, timelines, keys };
+}
+
 /**
  * The runtime's supply of A45's facts (issue #1025): the slot timelines read
  * off the skeleton JSON in the file's order — every animation the file keys,
@@ -959,6 +1124,156 @@ function spineSlotColourFacts(raw: Json | null, data: ReturnType<SkeletonJson['r
   };
 }
 
+/**
+ * The runtime's supply of A39's fact (issue #1025, cut 4c-3): the survey of
+ * the loaded skeleton, read and posed by spine-core (`surveyDeformKeys`) — the
+ * call A39 always made. The model side's supply is
+ * `./assertions/model/deform_survey.ts`.
+ */
+export function spineDeformSurvey(data: ReturnType<SkeletonJson['readSkeletonData']>): DeformSurveyFacts {
+  return { survey: (exempt) => surveyDeformKeys(data, exempt) };
+}
+
+/**
+ * The runtime's supply of A09's facts (issue #1025, cut 4c-3): the loaded
+ * animations in the loaded order — the file's — each with its duration and
+ * every loaded timeline's `getDuration()`, as A09 always read them. The model
+ * side's supply is `./assertions/model/animation_durations.ts`.
+ */
+export function spineAnimationDurations(data: ReturnType<SkeletonJson['readSkeletonData']>): AnimationDurationFacts {
+  return { animations: data.animations.map((anim) => ({ name: anim.name, duration: anim.duration, timelineDurations: anim.timelines.map((t) => t.getDuration()) })) };
+}
+
+/**
+ * The runtime's supply of A43's facts (issue #1025, cut 4c-3): the stated dark
+ * colours read off the skeleton JSON in the file's slot order, each slot named
+ * as A43's walk always named it; the setup dark colour the loaded slot holds;
+ * A45's walk of the file's slot timelines; whether an animation loaded; and a
+ * slot's two colours posed on a fresh, non-looping track by spine-core — setup
+ * pose, `update(0)`, `updateWorldTransform(Physics.reset)`, the track stepped
+ * to the time and applied, then `update` and `updateWorldTransform
+ * (Physics.update)` by the same time, A43's recipe unchanged. The model side's
+ * supply is `./assertions/model/two_colour.ts`.
+ */
+export function spineTwoColourFacts(raw: Json | null, data: ReturnType<SkeletonJson['readSkeletonData']>): TwoColourFacts {
+  const slotDarks: Array<{ slot: string; dark: string }> = [];
+  for (const slot of Array.isArray(raw?.slots) ? (raw.slots as unknown[]) : []) {
+    if (isObj(slot) && typeof slot.dark === 'string') slotDarks.push({ slot: String(slot.name), dark: slot.dark });
+  }
+  return {
+    slotDarks,
+    loadedDark: (name) => data.findSlot(name)?.setupPose.darkColor ?? null,
+    slotTimelines: spineSlotColourFacts(raw, data).slotTimelines,
+    hasAnimation: (name) => Boolean(data.findAnimation(name)),
+    posedTint: (animName, slotName, time) => {
+      const skeleton = new Skeleton(data);
+      const state = new AnimationState(new AnimationStateData(data));
+      state.setAnimation(0, animName, false);
+      skeleton.setupPose();
+      skeleton.update(0);
+      skeleton.updateWorldTransform(Physics.reset);
+      state.update(time);
+      state.apply(skeleton);
+      skeleton.update(time);
+      skeleton.updateWorldTransform(Physics.update);
+      const posed = skeleton.slots.find((s) => s.data.name === slotName)?.appliedPose;
+      if (posed === undefined) return undefined;
+      return { light: posed.color, dark: posed.darkColor ?? null };
+    },
+  };
+}
+
+/**
+ * The runtime's supply of A46's facts (issue #1025, cut 4c-3): the skin
+ * entries and sequence timelines read off the skeleton JSON as A46's walks
+ * always read them — the skins, a skin's slot keys and a slot's placeholders in
+ * the file's order, an entry with no `type` a region, an entry of another kind
+ * left out, a timeline whose `sequence` is not a list left out — each entry
+ * marked loaded where the slot exists and the loaded skin of that name holds an
+ * attachment at it; and what a slot shows on a fresh, non-looping track posed
+ * by spine-core — setup pose, `update(0)`, `updateWorldTransform
+ * (Physics.reset)`, the track stepped to the time and applied, A46's recipe
+ * unchanged. The loaded attachment is answered by its address: every loaded
+ * skin's `getAttachments()` gives each attachment object the skin, slot and
+ * placeholder it is filed under, and the object a linked mesh plays its
+ * timelines as (`timelineAttachment`) is answered the same way. The model
+ * side's supply is `./assertions/model/sequences.ts`.
+ */
+export function spineSequenceFacts(raw: Json | null, data: ReturnType<SkeletonJson['readSkeletonData']>): SequenceFacts {
+  const entries: SequenceSkinEntry[] = [];
+  for (const skin of isObj(raw) && Array.isArray(raw.skins) ? (raw.skins as unknown[]) : []) {
+    if (!isObj(skin) || !isObj(skin.attachments)) continue;
+    const skinName = typeof skin.name === 'string' ? skin.name : '(unnamed)';
+    const loadedSkin = data.findSkin(skinName);
+    for (const [slotName, perSlot] of Object.entries(skin.attachments)) {
+      if (!isObj(perSlot)) continue;
+      const slotIndex = data.findSlot(slotName)?.index;
+      for (const [placeholder, entry] of Object.entries(perSlot)) {
+        if (!isObj(entry)) continue;
+        const type = entry.type === undefined ? 'region' : entry.type;
+        if (type !== 'region' && type !== 'mesh' && type !== 'linkedmesh') continue;
+        const loaded = slotIndex === undefined ? null : loadedSkin?.getAttachment(slotIndex, placeholder) ?? null;
+        entries.push({ skin: skinName, slot: slotName, placeholder, name: entry.name, path: entry.path, sequence: entry.sequence, loaded: loaded !== null });
+      }
+    }
+  }
+  const timelines: SequenceTimeline[] = [];
+  const rawAnimations = isObj(raw) && isObj(raw.animations) ? raw.animations : {};
+  for (const [animation, anim] of Object.entries(rawAnimations)) {
+    if (!isObj(anim) || !isObj(anim.attachments)) continue;
+    for (const [skin, perSkin] of Object.entries(anim.attachments)) {
+      if (!isObj(perSkin)) continue;
+      for (const [slot, perSlot] of Object.entries(perSkin)) {
+        if (!isObj(perSlot)) continue;
+        for (const [placeholder, perAttachment] of Object.entries(perSlot)) {
+          if (!isObj(perAttachment) || !Array.isArray(perAttachment.sequence)) continue;
+          timelines.push({ animation, skin, slot, placeholder, keys: perAttachment.sequence as unknown[] });
+        }
+      }
+    }
+  }
+  /** Every loaded attachment object -> the address it is filed under, first filing kept. */
+  let addressOf: Map<object, EntryAddress> | null = null;
+  const address = (attachment: object): EntryAddress => {
+    if (addressOf === null) {
+      addressOf = new Map();
+      for (const skin of data.skins) {
+        for (const entry of skin.getAttachments()) {
+          if (!addressOf.has(entry.attachment)) addressOf.set(entry.attachment, entryAddress(skin.name, data.slots[entry.slotIndex].name, entry.placeholder));
+        }
+      }
+    }
+    // An attachment no skin files has no address: it can match no timeline's.
+    return addressOf.get(attachment) ?? '';
+  };
+  return {
+    entries,
+    timelines,
+    hasSlot: (slot) => data.findSlot(slot) !== null,
+    duration: (animation) => data.findAnimation(animation)?.duration ?? null,
+    posedFrame: (animName, slotName, time) => {
+      const slotIndex = data.findSlot(slotName)?.index;
+      if (slotIndex === undefined) return null;
+      const skeleton = new Skeleton(data);
+      const state = new AnimationState(new AnimationStateData(data));
+      state.setAnimation(0, animName, false);
+      skeleton.setupPose();
+      skeleton.update(0);
+      skeleton.updateWorldTransform(Physics.reset);
+      state.update(time);
+      state.apply(skeleton);
+      const pose = skeleton.slots[slotIndex].appliedPose;
+      const shown = pose.attachment;
+      if (shown === null) return null;
+      // The object it plays timelines as — `applyToSlot`'s second test — where the attachment carries one.
+      const playsAs = shown.timelineAttachment ?? shown;
+      const sequence = shown instanceof RegionAttachment || shown instanceof MeshAttachment ? shown.sequence : null;
+      const region = sequence === null ? null : ((sequence.regions[sequence.resolveIndex(pose)] as TextureAtlasRegion | null | undefined)?.name ?? null);
+      return { shown: address(shown), playsAs: address(playsAs), region };
+    },
+  };
+}
+
 /**
  * The runtime's supply of `SkinMeshFacts` (issue #1025, cut 4c-1): every
  * loaded `MeshAttachment` of every skin, linked meshes included, in the loaded
@@ -1398,6 +1713,129 @@ export function spineConstraintFacts(data: ReturnType<SkeletonJson['readSkeleton
   return { animations: data.animations.length, constraints, timelines, pathSlots };
 }
 
+/**
+ * The runtime's supply of `ConstraintTargetFacts` (issue #1025, cut 4c-5):
+ * A34's walk of the raw JSON, as A34 always walked it — the `constraints`
+ * array's objects, then each animation (`Object.entries`, the file's order)
+ * that is an object, its `ik` and `transform` groups (each entry ONE key
+ * array) and its `path`, `physics` and `slider` groups (each entry an object
+ * of named key arrays, or a bare value), each where the group is an object.
+ * `reach` builds the timeline the parser builds for a physics timeline NAME
+ * (`unnamedPhysicsTimeline`) and asks it of the file's physics constraint
+ * objects (`unnamedPhysicsReach`). The model side's supply is
+ * `./assertions/model/constraint_targets.ts`.
+ */
+export function rawConstraintTargets(raw: Json): ConstraintTargetFacts {
+  const objects = (Array.isArray(raw.constraints) ? (raw.constraints as unknown[]) : []).filter((entry): entry is Json => isObj(entry));
+  const constraints = objects.map((entry) => ({ name: typeof entry.name === 'string' ? entry.name : null, type: String(entry.type), spelled: String(entry.name) }));
+  const rawPhysics = objects.filter((entry) => entry.type === 'physics');
+  const keyArray = (timeline: string, keys: unknown): TargetKeyArray => ({ timeline, keys: Array.isArray(keys) ? { count: keys.length } : { spelled: `${JSON.stringify(keys)}` } });
+  let animations: TargetAnimation[] | null = null;
+  if (isObj(raw.animations)) {
+    animations = [];
+    for (const [name, anim] of Object.entries(raw.animations)) {
+      if (!isObj(anim)) continue;
+      const groups: TargetAnimation['groups'][number][] = [];
+      for (const group of ['ik', 'transform'] as const) {
+        if (!isObj(anim[group])) continue;
+        groups.push({ group, entries: Object.entries(anim[group] as Json).map(([target, keys]) => ({ name: target, bare: null, keyArrays: [keyArray('', keys)] })) });
+      }
+      for (const group of NAMED_TIMELINE_GROUPS) {
+        if (!isObj(anim[group])) continue;
+        groups.push({
+          group,
+          entries: Object.entries(anim[group] as Json).map(([target, timelines]) =>
+            isObj(timelines) ? { name: target, bare: null, keyArrays: Object.entries(timelines).map(([timeline, keys]) => keyArray(timeline, keys)) } : { name: target, bare: JSON.stringify(timelines), keyArrays: [] },
+          ),
+        });
+      }
+      animations.push({ name, groups });
+    }
+  }
+  return {
+    constraints,
+    groupsByAnimation: animations,
+    reach: (name) => {
+      const timeline = unnamedPhysicsTimeline(name);
+      if (timeline === null) return null;
+      return { resets: timeline instanceof PhysicsConstraintResetTimeline, reached: unnamedPhysicsReach(timeline, rawPhysics).map((one) => String(one.name)) };
+    },
+  };
+}
+
+/**
+ * The runtime's supply of `SliderCompositionFacts` (issue #1025, cut 4c-5):
+ * the loaded sliders in the `constraints` array's order, and each animation's
+ * loaded timelines in the order the runtime built them, each with its class
+ * name and its `propertyIds` — spelled as the facts spell an id (the property's
+ * name off `Property`, the index after it as loaded, and a deform or sequence
+ * timeline's attachment OBJECT replaced by the address a skin files it under,
+ * first filing kept, as `spineSequenceFacts` maps it) — and the sentence's
+ * words for each, `describe` as A40 always wrote it. `behaviour` is today's
+ * probe, `timelineAddBehaviour`. The model side's supply is
+ * `./assertions/model/slider_composition.ts`.
+ */
+export function spineSliderComposition(data: ReturnType<SkeletonJson['readSkeletonData']>): SliderCompositionFacts {
+  let addressOf: Map<object, string> | null = null;
+  const address = (attachment: object): string => {
+    if (addressOf === null) {
+      addressOf = new Map();
+      for (const skin of data.skins) {
+        for (const entry of skin.getAttachments()) {
+          if (!addressOf.has(entry.attachment)) addressOf.set(entry.attachment, entryAddress(skin.name, data.slots[entry.slotIndex].name, entry.placeholder));
+        }
+      }
+    }
+    return addressOf.get(attachment) ?? '';
+  };
+  /** What a property id points at, in the words the rig spec uses — A40's `describe`. */
+  const describe = (timeline: Timeline, id: string): string => {
+    const property = Property[Number(id.split('|')[0])] ?? id;
+    if (isBoneTimeline(timeline)) return `bone "${data.bones[timeline.boneIndex]?.name ?? timeline.boneIndex}" ${property}`;
+    if (timeline instanceof DeformTimeline) {
+      return `slot "${data.slots[timeline.slotIndex]?.name ?? timeline.slotIndex}" deform of "${timeline.attachment.name}"`;
+    }
+    if (isSlotTimeline(timeline)) return `slot "${data.slots[timeline.slotIndex]?.name ?? timeline.slotIndex}" ${property}`;
+    if (isConstraintTimeline(timeline) && timeline.constraintIndex >= 0) {
+      return `constraint "${data.constraints[timeline.constraintIndex]?.name ?? timeline.constraintIndex}" ${property}`;
+    }
+    return `the skeleton's ${property}`;
+  };
+  /** An id as the facts spell it: the property's name in place of its number, an attachment's address in place of its serial. */
+  const idOf = (timeline: Timeline, id: string): string => {
+    const [head, ...rest] = id.split('|');
+    const named = [Property[Number(head)] ?? head, ...rest];
+    if (timeline instanceof DeformTimeline || timeline instanceof RuntimeSequenceTimeline) named[2] = address(timeline.attachment);
+    return named.join('|');
+  };
+  const timelinesOf = (animation: Animation): SliderTimelineFact[] =>
+    animation.timelines.map((timeline) => ({
+      runtimeClass: timeline.constructor.name,
+      properties: timeline.propertyIds.map((id) => ({ id: idOf(timeline, id), property: Property[Number(id.split('|')[0])] ?? id, names: describe(timeline, id) })),
+    }));
+  const sliders: SliderFact[] = [];
+  data.constraints.forEach((c, index) => {
+    if (!(c instanceof SliderData)) return;
+    sliders.push({
+      name: c.name,
+      index,
+      mix: c.setupPose.mix,
+      additive: c.additive,
+      skinRequired: c.skinRequired,
+      skins: data.skins.filter((skin) => skin.constraints.includes(c)).map((skin) => skin.name),
+      animation: c.animation === null ? null : { name: c.animation.name, timelines: timelinesOf(c.animation) },
+    });
+  });
+  return {
+    sliders,
+    behaviour: (animationName, at) => {
+      const timeline = data.findAnimation(animationName)?.timelines[at];
+      if (timeline === undefined) throw new Error(`internal: animation "${animationName}" has no timeline ${at}`);
+      return timelineAddBehaviour(data, timeline);
+    },
+  };
+}
+
 /**
  * The facts cut 4c-2's bodies read, as `validate()` supplies them from a pair
  * spine-core loads — or `null` when the load throws (A00's failure). For the
@@ -1416,6 +1854,135 @@ export function runtimeRigFacts(skeletonText: string, atlasText: string): { mesh
   return { meshes: spineMeshFacts(data, raw), polygons: spinePolygonFacts(data, raw), links: spineLinkFacts(data, raw), constraints: spineConstraintFacts(data) };
 }
 
+/**
+ * Cut 4c-3's facts (issue #1025) as `validate()` supplies them from a pair
+ * spine-core loads — A39's survey, A09's durations, A43's tint and A46's series
+ * — or `null` when the load throws. For the selftest's `VF12` and
+ * `tools/verdict_gate.ts`, which hand them to the bodies and ask the model
+ * side's suppliers the same questions, value by value.
+ */
+/**
+ * The runtime's supply of A10's facts (issue #1025, cut 4c-5a): every pose A10
+ * reads, posed by spine-core exactly as A10 always posed it.
+ *
+ * - The setup pose: `setupPose()`, `update(0)`,
+ *   `updateWorldTransform(Physics.reset)`, no animation set.
+ * - Each animation's walk: `setAnimation(0, name, true)` — a LOOPING track —
+ *   over a fresh skeleton posed as above, then per step `AnimationState.update
+ *   (step)`, `apply`, `Skeleton.update(step)`, `updateWorldTransform
+ *   (Physics.update)`, one pose read after each.
+ * - A bone's mode at a key: a fresh, non-looping track, the setup pose reset,
+ *   the track stepped to the key's time and applied, then `update` and
+ *   `updateWorldTransform(Physics.update)` by the same time.
+ *
+ * A pose is read as `posedNumbersOf` reads it for `render` (every bone's world
+ * transform, every shown region's and mesh's world vertices), with each bone's
+ * `appliedPose.inherit` — `null` where it is a value `updateWorldTransform`'s
+ * switch has a case for, read off the runtime's own enum — and every slot's
+ * light and dark colour. The model side's supply is
+ * `./assertions/model/stepped_poses.ts`.
+ */
+export function spineSteppedPoses(raw: Json | null, data: ReturnType<SkeletonJson['readSkeletonData']>): SteppedPoseFacts {
+  /** Is this a mode `updateWorldTransform`'s switch has a case for? Read off the runtime's own enum. */
+  const isMode = (inherit: unknown): boolean => typeof inherit === 'number' && Inherit[inherit] !== undefined;
+  const frameOf = (skeleton: Skeleton): SteppedFrame => {
+    const { bones, drawn } = posedNumbersOf(skeleton);
+    return {
+      bones: bones.map((b, i) => {
+        const inherit = skeleton.bones[i].appliedPose.inherit;
+        return { ...b, inherit: isMode(inherit) ? null : String(inherit) };
+      }),
+      drawn,
+      slots: skeleton.slots.map((slot) => {
+        const c = slot.appliedPose.color;
+        const d = slot.appliedPose.darkColor;
+        return { name: slot.data.name, colour: [c.r, c.g, c.b, c.a] as const, dark: d === null ? null : ([d.r, d.g, d.b] as const) };
+      }),
+    };
+  };
+  return {
+    boneCount: data.bones.length,
+    steppedAnimations: data.animations.map((anim) => ({ name: anim.name, duration: anim.duration })),
+    hasAnimation: (name) => Boolean(data.findAnimation(name)),
+    hasBone: (name) => Boolean(data.findBone(name)),
+    posedInherit: (animName, boneName, time) => {
+      const skeleton = new Skeleton(data);
+      const state = new AnimationState(new AnimationStateData(data));
+      state.setAnimation(0, animName, false);
+      skeleton.setupPose();
+      skeleton.update(0);
+      skeleton.updateWorldTransform(Physics.reset);
+      state.update(time);
+      state.apply(skeleton);
+      skeleton.update(time);
+      skeleton.updateWorldTransform(Physics.update);
+      const bone = skeleton.findBone(boneName);
+      if (bone === null) return undefined;
+      const posed = bone.appliedPose.inherit;
+      return isMode(posed) ? null : String(posed);
+    },
+    statedInherit: (name) => {
+      const rawBone = Array.isArray(raw?.bones) ? (raw.bones as unknown[]).find((b) => isObj(b) && b.name === name) : undefined;
+      return `${JSON.stringify(isObj(rawBone) ? rawBone.inherit : undefined)}`;
+    },
+    setup: () => {
+      const atRest = new Skeleton(data);
+      atRest.setupPose();
+      atRest.update(0);
+      atRest.updateWorldTransform(Physics.reset);
+      return frameOf(atRest);
+    },
+    walk: (animName, step, frames) => {
+      const skeleton = new Skeleton(data);
+      const state = new AnimationState(new AnimationStateData(data));
+      state.setAnimation(0, animName, true);
+      skeleton.setupPose();
+      skeleton.update(0);
+      skeleton.updateWorldTransform(Physics.reset);
+      const out: SteppedFrame[] = [];
+      for (let i = 0; i < frames; i++) {
+        state.update(step);
+        state.apply(skeleton);
+        skeleton.update(step);
+        skeleton.updateWorldTransform(Physics.update);
+        out.push(frameOf(skeleton));
+      }
+      return out;
+    },
+  };
+}
+
+export function runtimePosedFacts(skeletonText: string, atlasText: string): { deformSurvey: DeformSurveyFacts; animationDurations: AnimationDurationFacts; twoColour: TwoColourFacts; sequences: SequenceFacts; steppedPoses: SteppedPoseFacts; boneTimelines: BoneTimelineFacts } | null {
+  let data: ReturnType<SkeletonJson['readSkeletonData']>;
+  let raw: Json;
+  try {
+    raw = JSON.parse(skeletonText) as Json;
+    data = new SkeletonJson(new AtlasAttachmentLoader(new TextureAtlas(atlasText))).readSkeletonData(JSON.parse(skeletonText));
+  } catch {
+    return null;
+  }
+  return { deformSurvey: spineDeformSurvey(data), animationDurations: spineAnimationDurations(data), twoColour: spineTwoColourFacts(raw, data), sequences: spineSequenceFacts(raw, data), steppedPoses: spineSteppedPoses(raw, data), boneTimelines: rawBoneTimelines(raw) };
+}
+
+/**
+ * Cut 4c-5's facts (issue #1025) as `validate()` supplies them from a pair
+ * spine-core loads — A40's sliders and A34's constraint groups, with the
+ * constraint facts A40 reads beside them — or `null` when the load throws.
+ * For the selftest's `VF14` and `tools/verdict_gate.ts`, which hand them to
+ * the bodies and ask the model side's suppliers the same questions.
+ */
+export function runtimeCut4c5Facts(skeletonText: string, atlasText: string): { sliderComposition: SliderCompositionFacts; constraintTargets: ConstraintTargetFacts; constraints: ConstraintFacts } | null {
+  let data: ReturnType<SkeletonJson['readSkeletonData']>;
+  let raw: Json;
+  try {
+    raw = JSON.parse(skeletonText) as Json;
+    data = new SkeletonJson(new AtlasAttachmentLoader(new TextureAtlas(atlasText))).readSkeletonData(JSON.parse(skeletonText));
+  } catch {
+    return null;
+  }
+  return { sliderComposition: spineSliderComposition(data), constraintTargets: rawConstraintTargets(raw), constraints: spineConstraintFacts(data) };
+}
+
 /** A fact supply computed on first use and kept: a supplier that throws throws inside the `check` that asked, as the body it feeds always did. */
 function once<T>(supply: () => T): () => T {
   let held: { value: T } | null = null;
@@ -1686,60 +2253,14 @@ export function validate(input: ValidateInput): ValidateReport {
   // It runs on the raw JSON rather than on the loaded data because the loaded
   // `Event` no longer remembers which fields the file wrote: an override that was
   // dropped and an override that matched the default are the same object.
-  check('A32_EVENT_KEYS_RESOLVE', () => {
-    if (!raw) return skip('A32_EVENT_KEYS_RESOLVE', 'the skeleton JSON did not parse (A00 owns that failure)');
-    if (!isObj(raw.animations)) return skip('A32_EVENT_KEYS_RESOLVE', 'the skeleton declares no animations');
-    const declared = isObj(raw.events) ? (raw.events as Json) : {};
-    const known = Object.keys(declared);
-    let sawATimeline = false;
-    for (const [animName, anim] of Object.entries(raw.animations as Json)) {
-      if (!isObj(anim) || !Array.isArray(anim.events)) continue;
-      sawATimeline = true;
-      let previous = -Infinity;
-      (anim.events as unknown[]).forEach((key, k) => {
-        const at = `animation "${animName}" event key ${k}`;
-        if (!isObj(key) || typeof key.name !== 'string') {
-          fail('A32_EVENT_KEYS_RESOLVE', `${at}: an event key needs a string "name"`);
-          return;
-        }
-        const definition = declared[key.name];
-        if (definition === undefined) {
-          fail(
-            'A32_EVENT_KEYS_RESOLVE',
-            `${at}: fires "${key.name}", which the skeleton's events block does not declare` +
-              (known.length ? ` (declared: ${known.join(', ')})` : ' (that block is empty or absent)'),
-          );
-          return;
-        }
-        // `time` defaults to 0 when absent (`:1247`), which is what the editor
-        // writes for a firing on frame 0.
-        const time = key.time === undefined ? 0 : key.time;
-        if (typeof time !== 'number' || !Number.isFinite(time)) {
-          fail('A32_EVENT_KEYS_RESOLVE', `${at}: time is ${JSON.stringify(key.time)}, not a finite number`);
-          return;
-        }
-        if (time < previous) {
-          fail(
-            'A32_EVENT_KEYS_RESOLVE',
-            `${at}: "${key.name}" is at t=${time}, after a key at t=${previous} — the parser fills frames in ` +
-              'array order and never sorts them, so the earlier firing is unreachable',
-          );
-        }
-        previous = Math.max(previous, time);
-        const hasAudio = isObj(definition) && typeof definition.audio === 'string';
-        for (const field of ['volume', 'balance'] as const) {
-          if (key[field] !== undefined && !hasAudio) {
-            fail(
-              'A32_EVENT_KEYS_RESOLVE',
-              `${at}: "${key.name}" sets ${field}, but the event declares no audio path — the parser reads ` +
-                `${field} only for an event that has one, so it is dropped in silence`,
-            );
-          }
-        }
-      });
-    }
-    if (!sawATimeline) return skip('A32_EVENT_KEYS_RESOLVE', 'no animation carries an event timeline');
-  });
+  //
+  // ✂️ Split per clause since issue #1025 (cut 4c-4): the third mode is the
+  // rig's — a readable model document states a key's `volume` and the event's
+  // `audio` — and its clause is the body's (`./assertions/bodies/a32.ts`); the
+  // first two, with "no string name" and "a time that is not a finite number",
+  // are states the document's reader refuses by name, so they stay here, in
+  // `rawEventKeys`, and the body prints what they found at their place.
+  check('A32_EVENT_KEYS_RESOLVE', () => a32EventKeysResolve(verdicts, rawEventKeys(raw)));
 
   // --- A34: a constraint timeline aims at a constraint of that type ---------
   //
@@ -1772,129 +2293,15 @@ export function validate(input: ValidateInput): ValidateReport {
   // constant now, and the message that names the timelines a group takes reads
   // them off `CHANNELS_BY_KIND` — it used to be a ternary over two groups,
   // which is a sentence that cannot be extended without being rewritten.
-  check('A34_CONSTRAINT_TIMELINE_TARGETS', () => {
-    if (!raw) return skip('A34_CONSTRAINT_TIMELINE_TARGETS', 'the skeleton JSON did not parse (A00 owns that failure)');
-    if (!isObj(raw.animations)) 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 Array.isArray(raw.constraints) ? (raw.constraints as unknown[]) : []) {
-      if (isObj(entry) && typeof entry.name === 'string') {
-        kindsOf.set(entry.name, [...(kindsOf.get(entry.name) ?? []), String(entry.type)]);
-      }
-    }
-    /** The file's physics constraints, which the unnamed physics group is read against. */
-    const rawPhysics = (Array.isArray(raw.constraints) ? (raw.constraints as unknown[]) : []).filter(
-      (entry): entry is Json => isObj(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: Array<[string, unknown]>): 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: Array<[string, unknown]>): 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 (Array.isArray(keys) && keys.length > 0) continue;
-        fail(
-          'A34_CONSTRAINT_TIMELINE_TARGETS',
-          `${at}${timeline ? ` timeline "${timeline}"` : ''}: the key array is ` +
-            `${Array.isArray(keys) ? 'empty' : JSON.stringify(keys)}; the parser reads key 0, finds nothing and ` +
-            'skips the whole timeline without a word',
-        );
-      }
-    };
-    for (const [animName, anim] of Object.entries(raw.animations as Json)) {
-      if (!isObj(anim)) continue;
-      // group.<constraint> = keys[]
-      for (const group of ['ik', 'transform'] as const) {
-        if (!isObj(anim[group])) continue;
-        for (const [name, keys] of Object.entries(anim[group] as Json)) {
-          checkTarget(`animation "${animName}" ${group} timeline "${name}"`, group, name, [['', keys]]);
-        }
-      }
-      // group.<constraint>.<timeline> = keys[]
-      for (const group of NAMED_TIMELINE_GROUPS) {
-        if (!isObj(anim[group])) continue;
-        for (const [name, timelines] of Object.entries(anim[group] as Json)) {
-          const at = `animation "${animName}" ${group} constraint "${name}"`;
-          if (!isObj(timelines)) {
-            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 ${JSON.stringify(timelines)} — ` +
-                '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 (`:1048-1054`), 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 [timelineName] of Object.entries(timelines)) {
-              const timeline = unnamedPhysicsTimeline(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 (timeline === null || unnamedPhysicsReach(timeline, rawPhysics).length > 0) continue;
-              const resets = timeline instanceof PhysicsConstraintResetTimeline;
-              fail(
-                'A34_CONSTRAINT_TIMELINE_TARGETS',
-                `${at} timeline "${timelineName}": a physics group that names no constraint writes every physics ` +
-                  `constraint ${resets ? 'the skeleton has' : `declaring "${timelineName}Global": true`}, and ` +
-                  (rawPhysics.length === 0
-                    ? 'the skeleton has no physics constraint'
-                    : `none of ${rawPhysics.map((one) => `"${String(one.name)}"`).join(', ')} does`) +
-                  ' — the parser loads it, the runtime walks every constraint, and no constraint takes the key',
-              );
-            }
-            checkKeys(at, Object.entries(timelines));
-            continue;
-          }
-          checkTarget(at, group, name, Object.entries(timelines));
-        }
-      }
-    }
-    if (!sawATimeline) {
-      return skip('A34_CONSTRAINT_TIMELINE_TARGETS', 'no animation carries a constraint timeline');
-    }
-  });
+  //
+  // ✂️ Moved whole since issue #1025 (cut 4c-5): the body is
+  // `./assertions/bodies/a34.ts`, over this file's constraint groups as the
+  // raw JSON states them (`rawConstraintTargets`), and whom a physics timeline
+  // naming no constraint reaches is still the parser's timeline asked of the
+  // file's constraint objects, through the facts.
+  check('A34_CONSTRAINT_TIMELINE_TARGETS', () =>
+    raw ? a34ConstraintTimelineTargets(verdicts, rawConstraintTargets(raw)) : skip('A34_CONSTRAINT_TIMELINE_TARGETS', 'the skeleton JSON did not parse (A00 owns that failure)'),
+  );
 
   // --- A35: a deform key's run lands inside the attachment it edits ---------
   //
@@ -2141,19 +2548,7 @@ export function validate(input: ValidateInput): ValidateReport {
 
   // --- A12: no dark / two-colour tint --------------------------------------
   // Parsed, then silently ignored by spine-html.
-  check('A12_NO_DARK_COLOR', () => {
-    const slots = Array.isArray(raw?.slots) ? (raw.slots as unknown[]) : [];
-    for (const slot of slots) {
-      if (isObj(slot) && 'dark' in slot) {
-        fail('A12_NO_DARK_COLOR', `slot "${String(slot.name)}" declares a dark colour; the renderer ignores it`);
-      }
-    }
-    walkTimelines(raw, (path, kind, name) => {
-      if (kind === 'slot' && (name === 'rgba2' || name === 'rgb2')) {
-        fail('A12_NO_DARK_COLOR', `${path}: two-colour timeline "${name}" is silently ignored by the renderer`);
-      }
-    });
-  });
+  check('A12_NO_DARK_COLOR', () => a12NoDarkColor(verdicts, rawSkeletonRoster(raw), rawSlotTimelines(raw)));
 
   // --- A05: curve arrays are 4 numbers per value channel --------------------
   check('A05_CURVE_ARRAY_LENGTH', () => {
@@ -2407,238 +2802,12 @@ export function validate(input: ValidateInput): ValidateReport {
     // reversals out of it and the report prints the rest. What stays here is the
     // SEVERITY and the exemption: the survey has no opinion about either, which
     // is what lets a report run it with no exemption at all.
-    check('A39_DEFORM_KEEPS_TRIANGLE_WINDING', () => {
-      if (!input.rig) {
-        return skip(
-          'A39_DEFORM_KEEPS_TRIANGLE_WINDING',
-          'no rig info (validating a bare directory), so the rig cannot say which slots fold on purpose',
-        );
-      }
-      const survey = surveyDeformKeys(data, new Set(input.rig.deformMayFold));
-      // 🚨 Which dial was turned, when rigc's two halves did not simply agree
-      // about that — and BEFORE any of the returns below, because every one of
-      // them is a run that posed frames through this dial (issue #427).
-      //
-      // The verdict used to live in `DeformReach.label`, which `explain` prints
-      // and nothing else does, so a `build`-only run — the normal loop, and the
-      // one an agent that cannot see the rig actually runs — never learned that
-      // the artifact and the probe named different fields.
-      //
-      // ⛔ Not a refusal, and the measurement rather than taste is why (#427).
-      // The frames this survey posed were each checked against `SliderPose.time`
-      // by the runtime itself, so a disagreement cannot make it pose one that
-      // does not happen; and the field it drives is the largest response the
-      // probe found, so it cannot make it miss one that does. What a
-      // disagreement CAN do is leave the rig naming a property no settable value
-      // of turns far enough — which is what `outside` measures and what an
-      // author can act on. A refusal would refuse a rig spine-core poses
-      // correctly at every key, with no edit that would make it green.
-      //
-      // 🔒 A tie is not a disagreement and gets a line that cannot be read as
-      // one: there the probe named no field, the artifact broke the tie, and the
-      // parent-45° geometry that reaches it is legitimate.
-      if (survey.dialTies.length) {
-        stats.deformDialsTied = survey.dialTies.length;
-        stats.deformDialTied = survey.dialTies.map(dialTieText).join(',');
-      }
-      if (survey.dialDisputes.length) {
-        stats.deformDialsDisagreed = survey.dialDisputes.length;
-        stats.deformDialDisagreed = survey.dialDisputes.map(dialDisputeText).join(',');
-      }
-      /** A key this rule is refusing, by the triple that identifies it. */
-      const refusedKey = new Set<string>();
-      for (const key of survey.keys) {
-        // ⭐ The one thing this rule cannot say about a key that draws nothing.
-        // Its own message below states the harm as "draws its texture
-        // backwards", and that sentence is false when no pixel of the mesh
-        // lands at this time — the slot has faded to alpha 0, or shows another
-        // attachment. So the key is measured, reported and not gated (issue
-        // #401). Per key and per time: the SAME slot folding at full alpha in
-        // another animation, or at another key, is refused as before, which is
-        // what makes this a measurement rather than a second `deformMayFold`.
-        if (key.draw.blank !== null) continue;
-        // And the one thing it cannot say about a key at a time no dial selects
-        // (issue #407): the frame posed is not this key's, so its geometry
-        // belongs to some other time and a winding read off it would be a
-        // measurement of the wrong thing. Named below, on the stats line.
-        if (key.dial?.unreachable === true) continue;
-        if (key.reversed.length === 0) continue;
-        refusedKey.add(`${key.animation} ${key.slot} ${key.attachment} ${key.key}`);
-        const shown = key.reversed
-          .slice(0, 4)
-          .map((r) => `${r.triangle} [${r.ids.join(',')}] ${r.before.toFixed(3)} -> ${r.after.toFixed(3)}px²`);
-        const more = key.reversed.length > shown.length ? `, and ${key.reversed.length - shown.length} more` : '';
-        fail(
-          'A39_DEFORM_KEEPS_TRIANGLE_WINDING',
-          // ⚠️ The frame is in the message whenever it is not the track, because
-          // the same key can be refused in one frame and passed over in another
-          // — two sliders applying one animation are two frames — and a message
-          // that named only the key would be ambiguous about which (issue #407).
-          `animation "${key.animation}"${frameClause(key.reach)} deform ${key.slot}/${key.attachment} ` +
-            `key ${key.key} (t=${key.time}s): ` +
-            `${key.reversed.length} of ${key.triangles} triangle(s) reverse winding — triangle ${shown.join('; triangle ')}` +
-            `${more}. The mesh has turned inside out there and draws its texture backwards` +
-            // The alpha is in the message whenever it is not full, because the
-            // one thing that would make this key exempt is alpha exactly 0 and
-            // an author who has already faded the part half out needs to be
-            // told that half is not none (issue #401).
-            (key.draw.alpha === 1
-              ? ''
-              : ` at alpha ${key.draw.alpha.toFixed(4)} — visible at that strength, and only alpha exactly 0 draws ` +
-                'no pixels at all') +
-            '. Fix the key\'s ' +
-            'offsets in the motion spec\'s deform timeline (a projection past its fold angle is the usual ' +
-            'cause — docs/FACE.md §4.2 has the closed form), or, if this slot folds on purpose, declare it ' +
-            `in the rig spec as invariants.deformMayFold: [{ "slot": "${key.slot}", "why": … }]`,
-        );
-      }
-      // --- and the folds no key lands on (issue #403) ------------------------
-      let spanFolds = 0;
-      for (const span of survey.spans) {
-        if (span.fold === null) continue;
-        // Suppressed when a bounding key already says it: one defect, one
-        // message. The span check is here for what the keys cannot see.
-        const bounded = `${span.animation} ${span.slot} ${span.attachment} `;
-        if (refusedKey.has(bounded + span.fromKey) || refusedKey.has(bounded + span.toKey)) continue;
-        spanFolds++;
-        const at = span.fold;
-        const shown = at.measure.reversed
-          .slice(0, 4)
-          .map((r) => `${r.triangle} [${r.ids.join(',')}] ${r.before.toFixed(3)} -> ${r.after.toFixed(3)}px²`);
-        const more =
-          at.measure.reversed.length > shown.length ? `, and ${at.measure.reversed.length - shown.length} more` : '';
-        // A stepped segment interpolates NOTHING — it holds the earlier key's
-        // geometry across the whole span — so saying "the runtime interpolates"
-        // there would be telling the author to look for a defect in the wrong
-        // place. What changed across a stepped span is what the slot DRAWS.
-        const held = span.curve === 'stepped';
-        fail(
-          'A39_DEFORM_KEEPS_TRIANGLE_WINDING',
-          `animation "${span.animation}"${frameClause(span.reach)} deform ${span.slot}/${span.attachment} ` +
-            `BETWEEN key ${span.fromKey} ` +
-            `(t=${span.fromTime}s) and key ${span.toKey} (t=${span.toTime}s), at t=${at.time.toFixed(6)}s` +
-            (held ? ' (a stepped segment)' : ` — ${(at.percent * 100).toFixed(1)}% of the way from one to the other`) +
-            `: ${at.measure.reversed.length} of ${at.measure.triangles} triangle(s) reverse winding — ` +
-            `triangle ${shown.join('; triangle ')}${more}. NO KEY LANDS THERE: ` +
-            (held
-              ? `a stepped segment interpolates nothing, it HOLDS key ${span.fromKey}'s geometry across the whole ` +
-                'span — so the fold is that key\'s and what changes here is what the slot draws'
-              : 'the runtime interpolates between the two keys, and the mesh is inside out for part of the way') +
-            ', drawing its texture backwards' +
-            (at.measure.draw.alpha === 1
-              ? ''
-              : ` at alpha ${at.measure.draw.alpha.toFixed(4)} — visible at that strength, and only alpha exactly 0 ` +
-                'draws no pixels at all') +
-            '. ' +
-            (held
-              ? `Fix key ${span.fromKey}'s offsets, or keep the slot drawing nothing for as long as it holds them`
-              : 'Add a key inside the span so the geometry the runtime passes through is geometry you wrote, or ' +
-                "move the two keys' offsets closer together (a projection past its fold angle is the usual cause " +
-                '— docs/FACE.md §4.2 has the closed form)') +
-            (at.measure.draw.alpha === 1
-              ? ''
-              : '; if the part is being faded out over this turn, land the alpha-0 key BEFORE the folding key ' +
-                'rather than on it, so every frame that folds is a frame that draws nothing (docs/FACE.md §9.2)') +
-            `, or, if this slot folds on purpose, declare it in the rig spec as invariants.deformMayFold: ` +
-            `[{ "slot": "${span.slot}", "why": … }]`,
-        );
-      }
-      if (survey.timelines === 0) {
-        return skip('A39_DEFORM_KEEPS_TRIANGLE_WINDING', 'no animation carries a deform timeline');
-      }
-      if (survey.keys.length === 0) {
-        const why = [
-          survey.exempted.length ? `the rig declares ${survey.exempted.join(', ')} as deformMayFold` : '',
-          survey.notAMesh.length ? `${survey.notAMesh.join(', ')} deform an attachment with no triangles` : '',
-        ].filter(Boolean);
-        return skip(
-          'A39_DEFORM_KEEPS_TRIANGLE_WINDING',
-          `no deform timeline here has a winding to keep: ${why.join('; ') || 'every mesh keyed has no triangles'}`,
-        );
-      }
-      // ⚠️ Silence is not a pass. A key passed over because nothing of it is
-      // drawn has to be visible on a green run too — this is the only surface
-      // `validate` has, and `explain`'s DEFORM block prints the whole sentence
-      // beside the key's own figures.
-      // ⚠️ Unreachable first and `blank` second, in the survey's own order, so
-      // the two counts partition the ungated keys instead of double-counting a
-      // key that is both.
-      const unreachable = survey.keys.filter((k) => k.dial?.unreachable === true);
-      const blank = survey.keys.filter((k) => k.dial?.unreachable !== true && k.draw.blank !== null);
-      const ungated = blank.length + unreachable.length;
-      const name = (k: (typeof survey.keys)[number]): string =>
-        `${k.animation}/${k.slot}/${k.attachment}#${k.key}:${k.draw.showsThisMesh ? 'alpha0' : 'notShown'}`;
-      // ⚠️ `&& spanFolds === 0` because a rig whose every key draws nothing can
-      // still fold at a time between two of them that DOES draw — that is issue
-      // #403's own case, and a SKIP printed over a refusal would be this rule
-      // reporting "nothing to measure" about the thing it just measured.
-      if (ungated === survey.keys.length && spanFolds === 0) {
-        const first = blank[0] ?? unreachable[0];
-        return skip(
-          'A39_DEFORM_KEEPS_TRIANGLE_WINDING',
-          `no deform key here is measurable in the frame its animation is reached in — ` +
-            `${first.animation} ${first.slot}/${first.attachment} key ${first.key}: ` +
-            `${first.draw.blank ?? unreachableWhy(first)}` +
-            (survey.keys.length > 1 ? `, and ${survey.keys.length - 1} more key(s) like it` : '') +
-            (unreachable.length
-              ? `. ${unreachable.length} of them at a time no dial selects, which is a rig defect this rule does ` +
-                'not refuse and does not pass over in silence either'
-              : '') +
-            (survey.spans.length
-              ? `. The ${survey.spans.length} span(s) between them were scanned too and none folds where anything ` +
-                'is drawn'
-              : ''),
-        );
-      }
-      stats.deformKeysMeasured = survey.keys.length - ungated;
-      stats.deformTrianglesMeasured = survey.trianglesMeasured;
-      stats.deformTrianglesCollapsed = survey.collapsed;
-      // Which frame each animation was posed in (issue #407) — printed only when
-      // a slider chose one, because on every other rig it says "a track" about
-      // every animation and a stats line that never varies is not a reading.
-      const frames = [...new Map(survey.keys.map((k) => [`${k.animation}/${k.reach.slider ?? 'track'}`, k])).values()];
-      if (frames.some((k) => k.reach.kind === 'slider')) {
-        stats.deformFrames = frames
-          .map((k) => `${k.animation}:${k.reach.kind === 'slider' ? `slider/${k.reach.slider}` : 'track'}`)
-          .join(',');
-      }
-      if (blank.length) {
-        stats.deformKeysNotDrawn = blank.length;
-        stats.deformNotDrawn = blank.map(name).join(',');
-        if (survey.notDrawnReversed) stats.deformNotDrawnReversed = survey.notDrawnReversed;
-      }
-      // 🚨 A key at a time no dial can select is NOT a pass and NOT a refusal —
-      // it is a rig whose slider cannot reach its own animation's key, named
-      // here so a green run cannot be read as having measured it (issue #407).
-      if (unreachable.length) {
-        stats.deformKeysUnreachable = unreachable.length;
-        stats.deformUnreachable = unreachable
-          .map((k) => `${k.animation}/${k.slot}/${k.attachment}#${k.key}@${k.dial?.applied.toFixed(6) ?? '?'}`)
-          .join(',');
-        if (survey.notReachableReversed) stats.deformUnreachableReversed = survey.notReachableReversed;
-      }
-      if (survey.exempted.length) stats.deformFoldExempt = survey.exempted.join(',');
-      // ⚠️ The between-keys scan on the stats line, on a GREEN run too (issue
-      // #403). `deformSpansScanned` is the positive control an agent can read —
-      // a scan that ran and found nothing has to be distinguishable from a scan
-      // that never ran — and `deformSpanProbes` is what it cost: 0 on a rig the
-      // closed form flags nothing in, one posed measurement per flagged window
-      // otherwise.
-      stats.deformSpansScanned = survey.spans.length;
-      // ⚠️ And the ones it could NOT scan, for the same reason the line above
-      // exists: a span bounded by a key at a time no dial selects would be
-      // solved over two poses of some other time, so it is skipped — and a skip
-      // nobody can see is the silence this whole surface is against (#407).
-      if (survey.spansNotScanned) stats.deformSpansNotScanned = survey.spansNotScanned;
-      if (survey.spanProbes) stats.deformSpanProbes = survey.spanProbes;
-      if (survey.spansNotDrawn) stats.deformSpansNotDrawn = survey.spansNotDrawn;
-      // A prediction nothing reproduced. Never a refusal — that would be the
-      // false red issues #44 and #262 already cost this file — and never a
-      // silence either: the one case that reaches it is a weighted mesh whose
-      // bones move across the span, where the closed form's fixed-pose
-      // assumption is the thing that did not hold.
-      if (survey.spansUnconfirmed) stats.deformSpansUnconfirmed = survey.spansUnconfirmed;
-    });
+    //
+    // Since issue #1025 (cut 4c-3) "here" is `./assertions/bodies/a39.ts`, which
+    // takes the survey as a fact: `spineDeformSurvey` hands it spine-core's, and
+    // the model side the core's over the model document — the same body, and the
+    // survey the two hand it held to one by `tools/survey_hashes.ts`.
+    check('A39_DEFORM_KEEPS_TRIANGLE_WINDING', () => a39DeformKeepsTriangleWinding(verdicts, spineDeformSurvey(data), input.rig));
 
     // --- A23, A41, A36, A37, A47, A48: a constraint that does nothing, quietly -
     //
@@ -2785,127 +2954,13 @@ export function validate(input: ValidateInput): ValidateReport {
     // measurement instead of two exceptions. A list of unobservable spellings
     // written into this file would have been the hand-kept table that produced
     // the defect above.
-    check('A40_SLIDERS_COMPOSE_ON_A_SHARED_TARGET', () => {
-      const sliders = data.constraints.filter((c) => c instanceof SliderData);
-      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.
-      // "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 (`./assertions/constraint_words.ts`, over
-      // the same facts the moved constraint bodies read — issue #1025), and
-      // unchanged by issue #752.
-      const mixKeyed = switchedOn(constraintFacts(), (timeline) => timeline.kind === 'slider' && timeline.word === 'mix', 1, () => true);
-      const authoritative = sliders.filter((s) => s.setupPose.mix >= 1 && !mixKeyed.has(data.constraints.indexOf(s)));
-      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<SliderData, Set<string> | null>();
-      for (const slider of authoritative) {
-        if (!slider.skinRequired) {
-          skinsOf.set(slider, null);
-          continue;
-        }
-        const names = new Set<string>();
-        for (const skin of data.skins) {
-          if (skin.constraints.includes(slider)) names.add(skin.name);
-        }
-        skinsOf.set(slider, names);
-      }
-      /** Clause 2: can these two ever run in the same frame? */
-      const canOverlap = (a: SliderData, b: SliderData): 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;
-      };
-      /** What a property id points at, in the words the rig spec uses. */
-      const describe = (timeline: Timeline, id: string): string => {
-        const property = Property[Number(id.split('|')[0])] ?? id;
-        if (isBoneTimeline(timeline)) return `bone "${data.bones[timeline.boneIndex]?.name ?? timeline.boneIndex}" ${property}`;
-        if (timeline instanceof DeformTimeline) {
-          return `slot "${data.slots[timeline.slotIndex]?.name ?? timeline.slotIndex}" deform of "${timeline.attachment.name}"`;
-        }
-        if (isSlotTimeline(timeline)) return `slot "${data.slots[timeline.slotIndex]?.name ?? timeline.slotIndex}" ${property}`;
-        if (isConstraintTimeline(timeline) && timeline.constraintIndex >= 0) {
-          return `constraint "${data.constraints[timeline.constraintIndex]?.name ?? timeline.constraintIndex}" ${property}`;
-        }
-        return `the skeleton's ${property}`;
-      };
-      /** property id -> the sliders whose animation keys it, in constraints-array order. */
-      const byProperty = new Map<string, Array<{ slider: SliderData; timeline: Timeline }>>();
-      for (const slider of authoritative) {
-        const seen = new Set<string>();
-        for (const timeline of slider.animation?.timelines ?? []) {
-          for (const id of timeline.propertyIds) {
-            if (seen.has(id)) continue;
-            seen.add(id);
-            byProperty.set(id, [...(byProperty.get(id) ?? []), { slider, timeline }]);
-          }
-        }
-      }
-      /** Posed once per timeline, because the answer is the class's and the rigs that reach here share timelines. */
-      const behaviour = new Map<Timeline, TimelineAddBehaviour>();
-      const addBehaviourOf = (timeline: Timeline): TimelineAddBehaviour => {
-        const known = behaviour.get(timeline);
-        if (known !== undefined) return known;
-        const measured = timelineAddBehaviour(data, timeline);
-        behaviour.set(timeline, measured);
-        return measured;
-      };
-      let shared = 0;
-      for (const [id, users] of byProperty) {
-        if (users.length < 2) continue;
-        shared++;
-        const at = (slider: SliderData): string =>
-          `"${slider.name}" (constraints[${data.constraints.indexOf(slider)}], 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.timeline);
-          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.constructor.name}.apply\` posed twice with ` +
-                '`add` set accumulates, so that flag is the repair here'
-              : `the ${Property[Number(id.split('|')[0])] ?? id} timeline they share writes its value outright whatever the ` +
-                `flags say — [measured] \`${later.timeline.constructor.name}.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',
-            `${describe(later.timeline, id)} 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;
-    });
+    //
+    // ✂️ Moved whole since issue #1025 (cut 4c-5): the body is
+    // `./assertions/bodies/a40.ts`, over the sliders and their animations'
+    // timelines (`spineSliderComposition`) and the constraint facts, and what a
+    // timeline does with `add` is still this probe, `timelineAddBehaviour`,
+    // asked by the body through the facts.
+    check('A40_SLIDERS_COMPOSE_ON_A_SHARED_TARGET', () => a40SlidersComposeOnASharedTarget(verdicts, spineSliderComposition(data), constraintFacts()));
 
     // --- A42: a dial that drives a constraint the array already ran ---------
     //
@@ -2989,271 +3044,104 @@ export function validate(input: ValidateInput): ValidateReport {
     check('A38_SKIN_MEMBERS_ARE_SKIN_REQUIRED', () => a38SkinMembersAreSkinRequired(verdicts, data));
 
     // --- A09: compiled duration == declared duration (rule 4) --------------
-    check('A09_ANIMATION_DURATION_MATCHES_SPEC', () => {
-      // Without the spec there is no declared duration to compare the compiled
-      // one against, and returning here used to count as a PASS — a gate saying
-      // it checked something it never looked at.
-      if (!input.declaredDurations) {
-        return skip('A09_ANIMATION_DURATION_MATCHES_SPEC', 'no motion spec supplied, so no declared duration to compare against');
-      }
-      // Same trap one level down. A **static rig** — a skeleton that exists to
-      // be posed and carries no animation at all, which is what
-      // `1-weight-and-mass`'s second export is — declares nothing and loads
-      // nothing, so both loops below iterate zero times and the assertion
-      // reported PASS. That is the vacuous green this report is built to refuse:
-      // there is no duration here, and saying so is the honest answer.
-      if (Object.keys(input.declaredDurations).length === 0 && data.animations.length === 0) {
-        return skip('A09_ANIMATION_DURATION_MATCHES_SPEC', SKIP_NO_DECLARED_DURATION);
-      }
-      for (const [name, declared] of Object.entries(input.declaredDurations)) {
-        const anim = data.findAnimation(name);
-        if (!anim) {
-          fail('A09_ANIMATION_DURATION_MATCHES_SPEC', `spec declares animation "${name}" but the skeleton has none`);
-          continue;
-        }
-        // Two arms, and the asymmetry is the point.
-        //
-        // UNDERSHOOT is R7's question — is the declared duration wrong? An
-        // animation may hold its final pose, so a last key a little before the
-        // end is ordinary and a frame of that is slack.
-        //
-        // OVERSHOOT is a different question with a different tolerance.
-        // `anim.duration` IS the largest key time (`SkeletonJson.ts:1261` takes
-        // the max over every timeline's own duration), so a loaded duration past
-        // the declared one means a KEY is past it — and nothing that plays the
-        // animation for the duration it declares will ever reach that key. Rung
-        // 6 lost a one-frame attachment reveal to a key 3.4e-5 s past the end,
-        // 1/500 of FRAME, which this comparison read as agreement (issue #54).
-        // `compile.ts` refuses that per timeline now; this is the same rule held
-        // against a skeleton the compiler never saw.
-        // The slack is one float32 step at the declared duration, and it is the
-        // same function the compiler's Rule 4 refuses on (`float32Step`, in
-        // `timelines.ts`, which says why it is a step of the float and no longer
-        // a fixed 1e-6 plus one).
-        const slack = float32Step(declared);
-        const past = anim.duration - declared;
-        if (past > slack) {
-          const late = anim.timelines.filter((t) => t.getDuration() - declared > slack).length;
-          fail(
-            'A09_ANIMATION_DURATION_MATCHES_SPEC',
-            `animation "${name}" has ${late} timeline(s) keyed past the declared duration ${declared}s — ` +
-              `the last key is at ${anim.duration}s, ${past.toFixed(6)}s late, so nothing ever samples it`,
-          );
-        } else if (declared - anim.duration > FRAME) {
-          fail(
-            'A09_ANIMATION_DURATION_MATCHES_SPEC',
-            `animation "${name}" loaded duration ${anim.duration}s, spec declares ${declared}s`,
-          );
-        }
-      }
-      for (const anim of data.animations) {
-        if (!(anim.name in input.declaredDurations)) {
-          fail('A09_ANIMATION_DURATION_MATCHES_SPEC', `skeleton has animation "${anim.name}" with no spec entry`);
-        }
-      }
-    });
+    //
+    // The body is `./assertions/bodies/a09.ts` since issue #1025 (cut 4c-3);
+    // what it reads off the loaded skeleton is `spineAnimationDurations`.
+    check('A09_ANIMATION_DURATION_MATCHES_SPEC', () => a09AnimationDurationMatchesSpec(verdicts, spineAnimationDurations(data), input.declaredDurations));
 
     // --- A10: step every animation and look for NaN ------------------------
-    check('A10_NO_NAN_AFTER_STEPPING', () => {
-      // Two clauses, and since issue #902 each is read on its own subject. The
-      // SETUP POSE is posed from the bones, so it has something to read on any
-      // skeleton that carries one; the STEPPED FRAMES are posed once per
-      // animation, so a skeleton with none has nothing to step. This used to
-      // skip the whole rule on the second fact alone, which was A15's pattern
-      // (#580) for a rule whose only clause was the stepping — and #882 gave it
-      // the setup clause without moving the skip. Measured on the static probe
-      // with a leaf bone at `rotation: 1e309` in its emitted file: `validate`
-      // printed this rule as SKIP and the run green under both profiles, and
-      // `render` refused the same file by the bone. A static rig's setup pose
-      // is the whole of what it shows, so that was the one pose nothing read.
-      //
-      // ⇒ The multi-clause rule of #580 now governs, the shape A09, A13, A33
-      // and A38 carry: the rule SKIPs only when neither clause has anything to
-      // measure, the clause that ran decides PASS or FAIL, and the clause that
-      // had nothing is named on the stats line (`nanStepping=skipped`, beside
-      // `animations=0`) the way A47 names a constraint it did not measure. A
-      // PASS row carries no detail, which is why the stats line is where.
-      //
-      // ⚠️ A09 does not follow, and that is its own name read at its word: a
-      // declared duration is a fact about an animation and nothing else, so a
-      // static rig still gives it nothing at all.
-      if (data.animations.length === 0 && data.bones.length === 0) {
-        return skip('A10_NO_NAN_AFTER_STEPPING', SKIP_NO_POSE);
-      }
-      /** Is this a mode `updateWorldTransform`'s switch has a case for? Read off the runtime's own enum. */
-      const isMode = (inherit: unknown): boolean => typeof inherit === 'number' && Inherit[inherit] !== undefined;
-
-      // -- the bone's inheritance mode, posed at every `inherit` key ---------
-      //
-      // 🚨 The one bone timeline whose value is a NAME, and the only one that
-      // can pose a NaN with a finite world: `SkeletonJson` resolves a key's mode
-      // through `Utils.enumValue`, which folds the first letter's case and
-      // nothing else, so `"NOSCALE"` resolves to `undefined` and the timeline's
-      // `Float32Array` frame stores NaN. `InheritTimeline.apply` then sets
-      // `pose.inherit = NaN`, `updateWorldTransform`'s switch matches no case,
-      // and the bone keeps whatever world matrix it had — measured on a forged
-      // two-bone chain: at the key the child's `a,b,c,d` equal the setup
-      // Normal-mode pose to the last digit while the file says `noScale`. The
-      // world position stays finite, so the loop below never saw it (#733).
-      //
-      // ⚠️ Posed AT each key rather than read off the stepping loop, because a
-      // stepped value lives from its key to the next one and a sampling grid
-      // can step over a short span entirely. What is judged is whether the
-      // posed value IS a mode — which is this assertion's name exactly — and
-      // not which mode: for any spelling the lookup resolves, the mode posed
-      // is the mode written by construction of the same lookup, so an equality
-      // here would be the parser agreeing with itself.
-      const rawAnimations = isObj(raw) && isObj(raw.animations) ? raw.animations : {};
-      let unresolved = 0;
-      for (const [animName, rawAnim] of Object.entries(rawAnimations)) {
-        if (!isObj(rawAnim) || !isObj(rawAnim.bones)) continue;
-        for (const [boneName, timelines] of Object.entries(rawAnim.bones)) {
-          if (!isObj(timelines) || !Array.isArray(timelines.inherit)) continue;
-          if (!data.findAnimation(animName) || !data.findBone(boneName)) continue;
-          for (const rawKey of timelines.inherit as unknown[]) {
-            if (!isObj(rawKey)) continue;
-            const time = typeof rawKey.time === 'number' ? rawKey.time : 0;
-            const skeleton = new Skeleton(data);
-            const state = new AnimationState(new AnimationStateData(data));
-            state.setAnimation(0, animName, false);
-            skeleton.setupPose();
-            skeleton.update(0);
-            skeleton.updateWorldTransform(Physics.reset);
-            state.update(time);
-            state.apply(skeleton);
-            skeleton.update(time);
-            skeleton.updateWorldTransform(Physics.update);
-            const posed = skeleton.findBone(boneName)?.appliedPose.inherit;
-            if (isMode(posed)) 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
-      //
-      // 🚨 Read through `nonFiniteOfPosed`, the scan `render` refuses on, and
-      // not a second opinion of it (issue #882). This loop read `worldX` and
-      // `worldY` alone until then, and a bone at `rotation: 1e309` — in its setup
-      // pose or as a `rotate` key — poses a finite position over a NaN `a`, `b`,
-      // `c` and `d` whenever it has no child offset from it: measured on every
-      // leaf bone of the three generated probes, 20 of 20 green through the whole
-      // gate, and `render` then refused the same file by the bone. So the gate
-      // said the skeleton was fine and the renderer said it was not, which is two
-      // definitions of one word. The scan reads the six terms of every bone, then
-      // the vertices of every region and mesh shown — because a bone can be
-      // finite over a vertex that is not (a `scaleX` chain whose product stays
-      // under the largest double while every corner of the child's region
-      // passes it) — and names the bone or the vertex, the term and the frame.
-      //
-      // ⚠️ The setup pose is its own surface and is read as such: every frame
-      // below is posed AFTER `state.apply`, so a bone the animation keys from
-      // t=0 never shows its setup value to the loop, and a runtime that shows
-      // the rig at rest does show it.
-      //
-      // 🔸 Posed once, before any animation is set, rather than once per
-      // animation as it was until #902: `setAnimation` does not touch the
-      // skeleton, so every animation's copy of this pose was the same pose, and
-      // the first of them was the only one ever read.
-      if (data.animations.length === 0) stats.nanStepping = 'skipped';
-      const atRest = new Skeleton(data);
-      atRest.setupPose();
-      atRest.update(0);
-      atRest.updateWorldTransform(Physics.reset);
-      const atSetup = nonFiniteOfPosed('the setup pose', atRest);
-      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, skeleton: Skeleton): string | null => {
-        for (const bone of skeleton.bones) {
-          const pose = bone.appliedPose;
-          // The setup half of the inherit-key clause above: a bone's own
-          // `inherit` goes through the same lookup, and a miss there loads
-          // `undefined` into the setup pose, which every frame copies. Only
-          // reachable on a file rigc did not write — `parseRigSpec` refuses the
-          // spelling.
-          if (!isMode(pose.inherit)) {
-            const rawBone = Array.isArray(raw?.bones)
-              ? (raw.bones as unknown[]).find((b) => isObj(b) && b.name === bone.data.name)
-              : undefined;
-            return (
-              `${where}: bone "${bone.data.name}" poses inheritance mode ${String(pose.inherit)} — its setup ` +
-              `spells inherit ${JSON.stringify(isObj(rawBone) ? rawBone.inherit : undefined)}, 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 skeleton.slots) {
-          const c = slot.appliedPose.color;
-          if (![c.r, c.g, c.b, c.a].every(Number.isFinite)) return `${where}: slot "${slot.data.name}" colour is non-finite`;
-          // The other colour a slot poses, and it was outside this loop until
-          // issue #690 for the reason every gap here has: nothing emitted one.
-          // `null` is the ordinary case — a slot with no `dark` allocates no
-          // dark colour at all — and is not a reading to make, so it is
-          // skipped rather than treated as zero.
-          const d = slot.appliedPose.darkColor;
-          if (d !== null && ![d.r, d.g, d.b].every(Number.isFinite)) {
-            return `${where}: slot "${slot.data.name}" dark colour is non-finite`;
-          }
-        }
-        return null;
-      };
-
-      // The stepping half, and on a static rig there is nothing to step: the
-      // setup pose is then the only frame the skeleton has, and the two readings
-      // a stepped frame gets are made on it instead, so a colour or an
-      // inheritance mode the rig shows at rest is not left to `render`.
-      if (data.animations.length === 0) {
-        const atRestDefect = poseDefect('the setup pose', atRest);
-        if (atRestDefect !== null) fail('A10_NO_NAN_AFTER_STEPPING', atRestDefect);
-        return;
-      }
-      for (const anim of data.animations) {
-        const skeleton = new Skeleton(data);
-        const state = new AnimationState(new AnimationStateData(data));
-        state.setAnimation(0, anim.name, true);
-        skeleton.setupPose();
-        skeleton.update(0);
-        skeleton.updateWorldTransform(Physics.reset);
-        const step = Math.max(anim.duration, 1) / STEP_FRAMES;
-        for (let i = 0; i < STEP_FRAMES; i++) {
-          state.update(step);
-          state.apply(skeleton);
-          skeleton.update(step);
-          skeleton.updateWorldTransform(Physics.update);
-          const found = nonFiniteOfPosed(
-            `animation ${JSON.stringify(anim.name)} frame ${i + 1} of ${STEP_FRAMES} (t=${((i + 1) * step).toFixed(4)}s)`,
-            skeleton,
-          );
-          if (found !== null) {
-            fail('A10_NO_NAN_AFTER_STEPPING', found);
-            return;
-          }
-          const defect = poseDefect(anim.name, skeleton);
-          if (defect !== null) {
-            fail('A10_NO_NAN_AFTER_STEPPING', defect);
-            return;
-          }
-        }
-      }
-    });
+    // The body is `./assertions/bodies/a10.ts` since issue #1025 (cut 4c-5a); what it
+    // reads off the loaded skeleton is `spineSteppedPoses` (and the raw JSON's bone
+    // timelines, `rawBoneTimelines`). The argument for each clause, as it stood
+    // inside the body:
+    //
+    // Two clauses, and since issue #902 each is read on its own subject. The
+    // SETUP POSE is posed from the bones, so it has something to read on any
+    // skeleton that carries one; the STEPPED FRAMES are posed once per
+    // animation, so a skeleton with none has nothing to step. This used to
+    // skip the whole rule on the second fact alone, which was A15's pattern
+    // (#580) for a rule whose only clause was the stepping — and #882 gave it
+    // the setup clause without moving the skip. Measured on the static probe
+    // with a leaf bone at `rotation: 1e309` in its emitted file: `validate`
+    // printed this rule as SKIP and the run green under both profiles, and
+    // `render` refused the same file by the bone. A static rig's setup pose
+    // is the whole of what it shows, so that was the one pose nothing read.
+    //
+    // ⇒ The multi-clause rule of #580 now governs, the shape A09, A13, A33
+    // and A38 carry: the rule SKIPs only when neither clause has anything to
+    // measure, the clause that ran decides PASS or FAIL, and the clause that
+    // had nothing is named on the stats line (`nanStepping=skipped`, beside
+    // `animations=0`) the way A47 names a constraint it did not measure. A
+    // PASS row carries no detail, which is why the stats line is where.
+    //
+    // ⚠️ A09 does not follow, and that is its own name read at its word: a
+    // declared duration is a fact about an animation and nothing else, so a
+    // static rig still gives it nothing at all.
+    //
+    // -- the bone's inheritance mode, posed at every `inherit` key ---------
+    //
+    // 🚨 The one bone timeline whose value is a NAME, and the only one that
+    // can pose a NaN with a finite world: `SkeletonJson` resolves a key's mode
+    // through `Utils.enumValue`, which folds the first letter's case and
+    // nothing else, so `"NOSCALE"` resolves to `undefined` and the timeline's
+    // `Float32Array` frame stores NaN. `InheritTimeline.apply` then sets
+    // `pose.inherit = NaN`, `updateWorldTransform`'s switch matches no case,
+    // and the bone keeps whatever world matrix it had — measured on a forged
+    // two-bone chain: at the key the child's `a,b,c,d` equal the setup
+    // Normal-mode pose to the last digit while the file says `noScale`. The
+    // world position stays finite, so the loop below never saw it (#733).
+    //
+    // ⚠️ Posed AT each key rather than read off the stepping loop, because a
+    // stepped value lives from its key to the next one and a sampling grid
+    // can step over a short span entirely. What is judged is whether the
+    // posed value IS a mode — which is this assertion's name exactly — and
+    // not which mode: for any spelling the lookup resolves, the mode posed
+    // is the mode written by construction of the same lookup, so an equality
+    // here would be the parser agreeing with itself.
+    //
+    // -- the whole world transform, at the setup pose and every stepped frame
+    //
+    // 🚨 Read through `firstNonFinite` (`./nonfinite.ts`) over `posedNumbersOf`,
+    // the scan `render` refuses on, and not a second opinion of it (issue #882). This loop read `worldX` and
+    // `worldY` alone until then, and a bone at `rotation: 1e309` — in its setup
+    // pose or as a `rotate` key — poses a finite position over a NaN `a`, `b`,
+    // `c` and `d` whenever it has no child offset from it: measured on every
+    // leaf bone of the three generated probes, 20 of 20 green through the whole
+    // gate, and `render` then refused the same file by the bone. So the gate
+    // said the skeleton was fine and the renderer said it was not, which is two
+    // definitions of one word. The scan reads the six terms of every bone, then
+    // the vertices of every region and mesh shown — because a bone can be
+    // finite over a vertex that is not (a `scaleX` chain whose product stays
+    // under the largest double while every corner of the child's region
+    // passes it) — and names the bone or the vertex, the term and the frame.
+    //
+    // ⚠️ The setup pose is its own surface and is read as such: every frame
+    // below is posed AFTER `state.apply`, so a bone the animation keys from
+    // t=0 never shows its setup value to the loop, and a runtime that shows
+    // the rig at rest does show it.
+    //
+    // 🔸 Posed once, before any animation is set, rather than once per
+    // animation as it was until #902: `setAnimation` does not touch the
+    // skeleton, so every animation's copy of this pose was the same pose, and
+    // the first of them was the only one ever read.
+    //
+    // The setup half of the inherit-key clause above: a bone's own
+    // `inherit` goes through the same lookup, and a miss there loads
+    // `undefined` into the setup pose, which every frame copies. Only
+    // reachable on a file rigc did not write — `parseRigSpec` refuses the
+    // spelling.
+    //
+    // The other colour a slot poses, and it was outside this loop until
+    // issue #690 for the reason every gap here has: nothing emitted one.
+    // `null` is the ordinary case — a slot with no `dark` allocates no
+    // dark colour at all — and is not a reading to make, so it is
+    // skipped rather than treated as zero.
+    //
+    // The stepping half, and on a static rig there is nothing to step: the
+    // setup pose is then the only frame the skeleton has, and the two readings
+    // a stepped frame gets are made on it instead, so a colour or an
+    // inheritance mode the rig shows at rest is not left to `render`.
+    check('A10_NO_NAN_AFTER_STEPPING', () => a10NoNanAfterStepping(verdicts, rawBoneTimelines(raw), spineSteppedPoses(raw, data)));
 
     // --- A43: the two-colour tint, read back off the runtime ----------------
     //
@@ -3289,188 +3177,11 @@ export function validate(input: ValidateInput): ValidateReport {
     // ⚠️ The hex is parsed HERE rather than through `Color.fromString`, and that
     // is the point of the clause: a check that read the required value out of the
     // same parser it is checking would agree with it whatever it did.
-    check('A43_TWO_COLOR_TINT_LOADS_AND_POSES_AS_WRITTEN', () => {
-      /** `rrggbb`, or `rrggbbaa` whose last pair the format drops. Null for anything else. */
-      const readDarkHex = (hex: string): [number, number, number] | null => {
-        const body = hex.startsWith('#') ? hex.slice(1) : hex;
-        if (!/^[\da-fA-F]{6}([\da-fA-F]{2})?$/.test(body)) return null;
-        return [0, 2, 4].map((i) => Number.parseInt(body.slice(i, i + 2), 16) / 255) as [number, number, number];
-      };
-      /** `rrggbbaa`, or `rrggbb` the runtime opens at alpha 1. Null for anything else. */
-      const readLightHex = (hex: string): [number, number, number, number] | null => {
-        const body = hex.startsWith('#') ? hex.slice(1) : hex;
-        if (!/^[\da-fA-F]{6}([\da-fA-F]{2})?$/.test(body)) return null;
-        const rgb = [0, 2, 4].map((i) => Number.parseInt(body.slice(i, i + 2), 16) / 255);
-        return [rgb[0], rgb[1], rgb[2], body.length === 8 ? Number.parseInt(body.slice(6, 8), 16) / 255 : 1];
-      };
-      /**
-       * Half a quantisation step. A channel is one byte in the file and a
-       * `Float32Array` entry in a timeline, so the widest honest gap between the
-       * number written and the number posed is well under `1/510`.
-       */
-      const STEP = 1 / 510;
-      const off = (found: number, want: number): boolean => !Number.isFinite(found) || Math.abs(found - want) > STEP;
-      const show = (c: readonly number[]): string => c.map((n) => (Number.isFinite(n) ? n.toFixed(4) : 'NaN')).join(', ');
-
-      // -- the subjects, read off the FILE ---------------------------------
-      const declared = new Map<string, string>();
-      for (const slot of Array.isArray(raw?.slots) ? (raw.slots as unknown[]) : []) {
-        if (isObj(slot) && typeof slot.dark === 'string') declared.set(String(slot.name), slot.dark);
-      }
-      // `rgb2` joined in issue #730, and it is this rule's subject rather than a
-      // new one's because it is the same tint with the light alpha left out:
-      // `RGB2Timeline` writes the light rgb and the dark colour, and on a slot
-      // with no dark colour it throws in `apply1` exactly as `RGBA2Timeline`
-      // does (measured on a forged file: `TypeError: null is not an object
-      // (evaluating 'dark.r = …')`). The one thing it does differently is the
-      // alpha it does NOT pose, which is `A45`'s question, not this one's.
-      const keyed: Array<{ anim: string; slot: string; timeline: 'rgba2' | 'rgb2'; keys: unknown[] }> = [];
-      const rawAnimations = isObj(raw) && isObj(raw.animations) ? raw.animations : {};
-      for (const [animName, anim] of Object.entries(rawAnimations)) {
-        if (!isObj(anim) || !isObj(anim.slots)) continue;
-        for (const [slotName, timelines] of Object.entries(anim.slots)) {
-          if (!isObj(timelines)) continue;
-          for (const timeline of ['rgba2', 'rgb2'] as const) {
-            const keys = timelines[timeline];
-            if (Array.isArray(keys)) keyed.push({ anim: animName, slot: slotName, timeline, keys });
-          }
-        }
-      }
-      if (declared.size === 0 && keyed.length === 0) {
-        return skip('A43_TWO_COLOR_TINT_LOADS_AND_POSES_AS_WRITTEN', SKIP_NO_TWO_COLOR_TINT);
-      }
-      stats.darkSlots = declared.size;
-      stats.rgba2Timelines = keyed.filter((t) => t.timeline === 'rgba2').length;
-      stats.rgb2Timelines = keyed.filter((t) => t.timeline === 'rgb2').length;
-
-      // -- clause 1: the setup pose ----------------------------------------
-      for (const [name, hex] of declared) {
-        const want = readDarkHex(hex);
-        const loaded = data.findSlot(name)?.setupPose.darkColor ?? null;
-        // ⚠️ "The parser kept nothing" is asked FIRST, and the order is the
-        // finding rather than a style: an empty string is both unreadable as a
-        // colour and dropped outright, and only the second sentence is about
-        // what the loaded skeleton holds. Asked the other way round, `""` was
-        // reported as "not six hex digits" — true, and about the file, on the
-        // one input where the file is not what went wrong.
-        if (loaded === null) {
-          fail(
-            'A43_TWO_COLOR_TINT_LOADS_AND_POSES_AS_WRITTEN',
-            `slot "${name}" states dark ${JSON.stringify(hex)} and the loaded skeleton holds no dark colour for ` +
-              'it at all — the slot reader takes `dark` through a truthiness test, so a falsy value is dropped ' +
-              'in silence and the slot is tinted with one colour',
-          );
-          continue;
-        }
-        if (want === null) {
-          fail(
-            'A43_TWO_COLOR_TINT_LOADS_AND_POSES_AS_WRITTEN',
-            `slot "${name}" states dark ${JSON.stringify(hex)}, which is not six hex digits — the parser reads ` +
-              'fixed two-character slices and stores whatever `parseInt` returns, so the loaded colour is ' +
-              `(${show([loaded.r, loaded.g, loaded.b])}) rather than a failure`,
-          );
-          continue;
-        }
-        const found: [number, number, number] = [loaded.r, loaded.g, loaded.b];
-        if (found.some((n, i) => off(n, want[i]))) {
-          fail(
-            'A43_TWO_COLOR_TINT_LOADS_AND_POSES_AS_WRITTEN',
-            `slot "${name}" states dark ${JSON.stringify(hex)} and the runtime loaded (${show(found)}), wanted ` +
-              `(${show(want)})`,
-          );
-        }
-      }
-
-      // -- clauses 2 and 3: every rgba2 and rgb2 timeline --------------------
-      //
-      // ⚠️ Clause 2 poisons its whole ANIMATION, not only its own timeline: the
-      // throw happens inside `state.apply`, which applies every timeline of the
-      // animation at once, so posing a second — correct — `rgba2` timeline in the
-      // same animation would take this assertion down with a `threw:` line
-      // instead of the two named failures it has already worked out.
-      const cannotPose = new Set(keyed.filter((t) => !declared.has(t.slot)).map((t) => t.anim));
-      for (const { anim: animName, slot: slotName, timeline, keys } of keyed) {
-        const where = `animation "${animName}" slot "${slotName}" ${timeline}`;
-        if (!declared.has(slotName)) {
-          fail(
-            'A43_TWO_COLOR_TINT_LOADS_AND_POSES_AS_WRITTEN',
-            `${where}: slot "${slotName}" declares no setup "dark", so the runtime allocates no dark colour for ` +
-              `it and applying this animation throws instead of tinting — give the slot a \`dark\`, or key ` +
-              `"${timeline === 'rgba2' ? 'rgba' : 'rgb'}"`,
-          );
-          continue;
-        }
-        if (cannotPose.has(animName)) continue;
-        const animation = data.findAnimation(animName);
-        if (!animation) {
-          fail('A43_TWO_COLOR_TINT_LOADS_AND_POSES_AS_WRITTEN', `${where}: the loaded skeleton has no animation "${animName}"`);
-          continue;
-        }
-        for (const rawKey of keys) {
-          if (!isObj(rawKey)) continue;
-          const time = typeof rawKey.time === 'number' ? rawKey.time : 0;
-          const wantLight = typeof rawKey.light === 'string' ? readLightHex(rawKey.light) : null;
-          const wantDark = typeof rawKey.dark === 'string' ? readDarkHex(rawKey.dark) : null;
-          // ⚠️ Posed BEFORE the key's own spelling is judged, so that a key whose
-          // hex cannot be read is still reported with the colour the runtime
-          // actually holds. `Color.setFromString` slices fixed offsets and stores
-          // whatever `parseInt` gives back, so the value found is the product
-          // here — "not six hex digits" alone would be the value REQUIRED twice
-          // over and the found value nowhere.
-          const skeleton = new Skeleton(data);
-          const state = new AnimationState(new AnimationStateData(data));
-          state.setAnimation(0, animName, false);
-          skeleton.setupPose();
-          skeleton.update(0);
-          skeleton.updateWorldTransform(Physics.reset);
-          // At the key as the runtime stores it — see `atStoredKey` (#771).
-          state.update(atStoredKey(time));
-          state.apply(skeleton);
-          skeleton.update(atStoredKey(time));
-          skeleton.updateWorldTransform(Physics.update);
-          const posed = skeleton.slots.find((s) => s.data.name === slotName)?.appliedPose;
-          const light = posed?.color;
-          const dark = posed?.darkColor ?? null;
-          if (!light || dark === null) {
-            fail(
-              'A43_TWO_COLOR_TINT_LOADS_AND_POSES_AS_WRITTEN',
-              `${where} (t=${time}): the posed skeleton has no ${light ? 'dark colour' : 'slot'} to read`,
-            );
-            continue;
-          }
-          const foundLight: [number, number, number, number] = [light.r, light.g, light.b, light.a];
-          const foundDark: [number, number, number] = [dark.r, dark.g, dark.b];
-          if (wantLight === null || wantDark === null) {
-            fail(
-              'A43_TWO_COLOR_TINT_LOADS_AND_POSES_AS_WRITTEN',
-              `${where} (t=${time}): the key states light ${JSON.stringify(rawKey.light)} and dark ` +
-                `${JSON.stringify(rawKey.dark)} — an ${timeline} key needs both, each six or eight hex digits — and the ` +
-                `runtime poses light (${show(foundLight)}), dark (${show(foundDark)})`,
-            );
-            continue;
-          }
-          // An `rgb2` key's light colour is three channels, and the posed alpha
-          // is not its to state — `RGB2Timeline` leaves it where it was — so the
-          // comparison is over the channels the timeline writes. For `rgba2`
-          // that is all four, and the line reads as it always did.
-          const lightChannels = timeline === 'rgba2' ? 4 : 3;
-          if (foundLight.slice(0, lightChannels).some((n, i) => off(n, wantLight[i]))) {
-            fail(
-              'A43_TWO_COLOR_TINT_LOADS_AND_POSES_AS_WRITTEN',
-              `${where} (t=${time}): light posed (${show(foundLight.slice(0, lightChannels))}), the key states ` +
-                `${JSON.stringify(rawKey.light)} = (${show(wantLight.slice(0, lightChannels))})`,
-            );
-          }
-          if (foundDark.some((n, i) => off(n, wantDark[i]))) {
-            fail(
-              'A43_TWO_COLOR_TINT_LOADS_AND_POSES_AS_WRITTEN',
-              `${where} (t=${time}): dark posed (${show(foundDark)}), the key states ${JSON.stringify(rawKey.dark)} ` +
-                `= (${show(wantDark)})`,
-            );
-          }
-        }
-      }
-    });
+    //
+    // The body is `./assertions/bodies/a43.ts` since issue #1025 (cut 4c-3);
+    // what it reads off the skeleton JSON and the loaded skeleton is
+    // `spineTwoColourFacts`.
+    check('A43_TWO_COLOR_TINT_LOADS_AND_POSES_AS_WRITTEN', () => a43TwoColorTintLoadsAndPosesAsWritten(verdicts, spineTwoColourFacts(raw, data)));
 
     // --- A45: the separable colour timelines own their channels ------------
     //
@@ -3530,7 +3241,7 @@ export function validate(input: ValidateInput): ValidateReport {
     // every key at sampled times — mid-frame, so a float32 key time cannot land
     // a sample on a frame boundary — and compares the region the slot shows
     // against the one the file's own statement gives: the frame the key's mode,
-    // index and delay give (`frameOf` below), and the frame names
+    // index and delay give (`frameOf` in the body), and the frame names
     // `attachmentRegionLookups` derives (the core's `frameRegionName`). Neither is
     // read off the loaded timeline, so the check is not the runtime agreeing
     // with itself.
@@ -3539,245 +3250,11 @@ export function validate(input: ValidateInput): ValidateReport {
     // `applyToSlot` returns there, and a series that is hidden is not a series
     // showing the wrong frame. A timeline with no comparable sample at all is
     // counted in `stats.sequenceSamplesUnshown` rather than failed.
-    check('A46_SEQUENCE_ATTACHMENTS_SHOW_THE_FRAME_THE_FILE_STATES', () => {
-      const NAME = 'A46_SEQUENCE_ATTACHMENTS_SHOW_THE_FRAME_THE_FILE_STATES';
-      type Series = { where: string; lookups: string[] | null; count: number; setup: number };
-      /** The loaded attachment -> what the FILE says its series is. */
-      const series = new Map<object, Series>();
-      /** `skin\0slot\0placeholder` -> the loaded attachment, for the timelines to find. */
-      const byJoin = new Map<string, object>();
-      /** Attachments whose block was already refused above — their timelines say nothing more. */
-      const refused = new Set<object>();
-      const whole = (v: unknown, fallback: number): number | null =>
-        v === undefined ? fallback : typeof v === 'number' && Number.isInteger(v) ? v : null;
-      let blocks = 0;
-      for (const skin of isObj(raw) && Array.isArray(raw.skins) ? (raw.skins as unknown[]) : []) {
-        if (!isObj(skin) || !isObj(skin.attachments)) continue;
-        const skinName = typeof skin.name === 'string' ? skin.name : '(unnamed)';
-        const loadedSkin = data.findSkin(skinName);
-        for (const [slotName, entries] of Object.entries(skin.attachments)) {
-          if (!isObj(entries)) continue;
-          const slotIndex = data.findSlot(slotName)?.index;
-          for (const [placeholder, entry] of Object.entries(entries)) {
-            if (!isObj(entry)) continue;
-            const type = entry.type === undefined ? 'region' : entry.type;
-            if (type !== 'region' && type !== 'mesh' && type !== 'linkedmesh') continue;
-            const loaded = slotIndex === undefined ? null : loadedSkin?.getAttachment(slotIndex, placeholder) ?? null;
-            const where = `skin ${JSON.stringify(skinName)} slot ${JSON.stringify(slotName)} attachment ${JSON.stringify(placeholder)}`;
-            if (loaded !== null) byJoin.set(`${skinName}\u0000${slotName}\u0000${placeholder}`, loaded);
-            if (entry.sequence === undefined || entry.sequence === null) continue;
-            blocks++;
-            const seq = entry.sequence;
-            const name = typeof entry.name === 'string' ? entry.name : placeholder;
-            const path = typeof entry.path === 'string' ? entry.path : name;
-            const count = isObj(seq) ? whole(seq.count, 0) : null;
-            const setup = isObj(seq) ? whole(seq.setup, 0) : null;
-            if ((count === null || setup === null || count < 1) && loaded !== null) refused.add(loaded);
-            if (count === null || setup === null || count < 1) {
-              fail(
-                NAME,
-                `${where}: the sequence states ${JSON.stringify(seq)}` +
-                  (isObj(seq) && seq.count === undefined
-                    ? ' and no "count" — `readSequence` reads 0 (`SkeletonJson.js:644`), so the attachment loads holding no region and draws nothing'
-                    : ' — "count" is a whole number of at least 1 and "setup" a whole number, or the series the parser builds is not the one written'),
-              );
-              continue;
-            }
-            if ((setup < 0 || setup >= count) && loaded !== null) refused.add(loaded);
-            if (setup < 0 || setup >= count) {
-              fail(
-                NAME,
-                `${where}: the sequence's setup frame is ${setup} of a ${count}-frame series (frames 0 to ${count - 1}); ` +
-                  '`Sequence.resolveIndex` clamps it, so the setup pose shows ' +
-                  `${setup < 0 ? 'no frame at all' : `frame ${count - 1}, which the file does not name`}`,
-              );
-              continue;
-            }
-            if (loaded === null) continue; // A00/A08 own an attachment that did not load
-            series.set(loaded, { where, lookups: attachmentRegionLookups(seq, path), count, setup });
-          }
-        }
-      }
-
-      /**
-       * The frame the file's statement gives for one key at one elapsed time —
-       * A46's prediction, not a call into the runtime. What holds it is the
-       * comparison it feeds: every sample sets it against the frame the posed
-       * slot shows, so a reading that disagreed with the runtime would fail A46
-       * on a correct file. A46 passing with samples posed on the selftest's
-       * series probes is that measurement for the modes they key; `M73` is its
-       * red half.
-       */
-      const frameOf = (mode: string, index: number, elapsed: number, delay: number, count: number): number => {
-        if (mode === 'hold') return index;
-        let i = index + Math.trunc(elapsed / delay + 0.00001);
-        const n = count * 2 - 2;
-        switch (mode) {
-          case 'once':
-            return Math.min(count - 1, i);
-          case 'loop':
-            return i % count;
-          case 'pingpong':
-            i = n === 0 ? 0 : i % n;
-            return i >= count ? n - i : i;
-          case 'onceReverse':
-            return Math.max(count - 1 - i, 0);
-          case 'loopReverse':
-            return count - 1 - (i % count);
-          default: // pingpongReverse
-            i = n === 0 ? 0 : (i + count - 1) % n;
-            return i >= count ? n - i : i;
-        }
-      };
-
-      let timelines = 0;
-      let compared = 0;
-      let unshown = 0;
-      const rawAnimations = isObj(raw) && isObj(raw.animations) ? raw.animations : {};
-      for (const [animName, anim] of Object.entries(rawAnimations)) {
-        if (!isObj(anim) || !isObj(anim.attachments)) continue;
-        for (const [skinName, perSkin] of Object.entries(anim.attachments)) {
-          if (!isObj(perSkin)) continue;
-          for (const [slotName, perSlot] of Object.entries(perSkin)) {
-            if (!isObj(perSlot)) continue;
-            for (const [placeholder, perAttachment] of Object.entries(perSlot)) {
-              if (!isObj(perAttachment) || !Array.isArray(perAttachment.sequence)) continue;
-              const keys = perAttachment.sequence as unknown[];
-              if (keys.length === 0) continue; // `readAnimation` skips it; A34 owns an empty timeline
-              timelines++;
-              const where = `animation ${JSON.stringify(animName)} ${skinName}/${slotName}/${placeholder} sequence`;
-              const keyed = byJoin.get(`${skinName}\u0000${slotName}\u0000${placeholder}`);
-              if (keyed === undefined) continue; // the parser throws on a missing target: A00's
-              if (refused.has(keyed)) continue; // its block is already named above
-              const own = series.get(keyed);
-              if (own === undefined) {
-                fail(
-                  NAME,
-                  `${where}: the timeline steps an attachment that carries no "sequence" block. The parser gives it a ` +
-                    'series of ONE region (`readSequence(null)` is `new Sequence(1, false)`), so every mode shows that ' +
-                    'region at every time — measured: a "loop" key on a plain region showed it throughout',
-                );
-                continue;
-              }
-              // -- the keys, as the file states them --------------------------
-              type Key = { time: number; mode: string; index: number; delay: number };
-              const read: Key[] = [];
-              let carried = 0;
-              let malformed = false;
-              keys.forEach((rawKey, k) => {
-                const key = isObj(rawKey) ? rawKey : {};
-                const at = `${where} key ${k}`;
-                const time = typeof key.time === 'number' ? key.time : 0;
-                const mode = key.mode === undefined ? 'hold' : key.mode;
-                const index = key.index === undefined ? 0 : key.index;
-                if (key.delay !== undefined) carried = typeof key.delay === 'number' ? key.delay : Number.NaN;
-                if (typeof mode !== 'string' || !(SEQUENCE_MODES as readonly string[]).includes(mode)) {
-                  malformed = true;
-                  fail(
-                    NAME,
-                    `${at} (t=${time}): mode ${JSON.stringify(key.mode)} is not one of the ${SEQUENCE_MODES.length} the ` +
-                      `format has (${SEQUENCE_MODES.join(', ')}); the parser reads \`SequenceMode[mode]\`, which is ` +
-                      'undefined, stores mode bits 0, and the key plays as "hold"',
-                  );
-                  return;
-                }
-                if (typeof index !== 'number' || !Number.isInteger(index) || index < 0 || index >= own.count) {
-                  malformed = true;
-                  fail(
-                    NAME,
-                    `${at} (t=${time}): index ${JSON.stringify(key.index)} is not a frame of the ${own.count}-frame series ` +
-                      `(0 to ${own.count - 1}); the runtime stores \`index << 4\`, truncating a fraction, and ` +
-                      '`Sequence.resolveIndex` clamps a frame past the end to the last one',
-                  );
-                  return;
-                }
-                if (mode !== 'hold' && !(carried > 0)) {
-                  malformed = true;
-                  fail(
-                    NAME,
-                    `${at} (t=${time}): "${mode}" at a delay of ${String(carried)}${key.delay === undefined ? ' (carried from the key before, 0 on the first)' : ''} — ` +
-                      'the frame advances by `(time - keyTime) / delay`, and at 0 that is Infinity, `Infinity | 0` is 0, ' +
-                      'and the key shows its first frame throughout: "hold" spelt as another mode',
-                  );
-                  return;
-                }
-                read.push({ time, mode, index, delay: carried });
-              });
-              if (malformed) continue;
-
-              // -- the pose, sampled ------------------------------------------
-              const animation = data.findAnimation(animName);
-              const slotIndex = data.findSlot(slotName)?.index;
-              if (animation === null || slotIndex === undefined) continue; // A00's
-              /** `key` is the index into `read`, or -1 before the first key (the setup frame). */
-              const samples: Array<{ time: number; key: number; steps: number }> = [];
-              const end = animation.duration;
-              if (read[0].time > 0) samples.push({ time: read[0].time / 2, key: -1, steps: 0 });
-              read.forEach((key, k) => {
-                const until = k + 1 < read.length ? read[k + 1].time : end;
-                if (key.mode === 'hold') {
-                  samples.push({ time: key.time, key: k, steps: 0 });
-                  return;
-                }
-                // Mid-frame, and enough steps to wrap every mode at least once.
-                for (let step = 0; step < own.count * 2 + 2; step++) {
-                  const time = key.time + (step + 0.5) * key.delay;
-                  if (time >= until || time > end) break;
-                  samples.push({ time, key: k, steps: step + 0.5 });
-                }
-              });
-              let shownHere = 0;
-              for (const sample of samples) {
-                const skeleton = new Skeleton(data);
-                const state = new AnimationState(new AnimationStateData(data));
-                state.setAnimation(0, animName, false);
-                skeleton.setupPose();
-                skeleton.update(0);
-                skeleton.updateWorldTransform(Physics.reset);
-                // A `hold` sample is AT its key, so it is posed at the key as
-                // the runtime stores it (`atStoredKey`); a mid-frame sample is
-                // half a delay from any key and is posed where it is.
-                state.update(sample.key >= 0 && sample.steps === 0 ? atStoredKey(sample.time) : sample.time);
-                state.apply(skeleton);
-                const pose = skeleton.slots[slotIndex].appliedPose;
-                const shown = pose.attachment;
-                // The slot must show the keyed attachment or one playing its
-                // timelines — the only case `applyToSlot` writes.
-                if (shown === null || (shown !== keyed && shown.timelineAttachment !== keyed)) continue;
-                const drawn = series.get(shown);
-                if (drawn === undefined || drawn.lookups === null) continue;
-                shownHere++;
-                compared++;
-                // The frame count the runtime folds by is the SHOWN attachment's:
-                // a link with a series of its own steps it by its source's keys.
-                const key = sample.key < 0 ? null : read[sample.key];
-                const want = key === null ? drawn.setup : frameOf(key.mode, key.index, sample.time - key.time, key.delay, drawn.count);
-                const sequence = (shown as RegionAttachment | MeshAttachment).sequence;
-                const region = (sequence.regions[sequence.resolveIndex(pose)] as TextureAtlasRegion | null | undefined)?.name ?? null;
-                if (region !== drawn.lookups[want]) {
-                  fail(
-                    NAME,
-                    `${where} (t=${Number(sample.time.toFixed(4))}): the slot shows region ${JSON.stringify(region)}, and ` +
-                      `the file states frame ${want} of ${drawn.count} — ${JSON.stringify(drawn.lookups[want])} — ` +
-                      (key === null
-                        ? 'the setup frame, before the first key'
-                        : `key ${sample.key} plays "${key.mode}" from frame ${key.index} every ${key.delay}s, ` +
-                          `${sample.steps} delay(s) in`),
-                  );
-                  break;
-                }
-              }
-              if (shownHere === 0) unshown++;
-            }
-          }
-        }
-      }
-      if (blocks === 0 && timelines === 0) return skip(NAME, SKIP_NO_SEQUENCE);
-      stats.sequenceBlocks = blocks;
-      stats.sequenceTimelines = timelines;
-      stats.sequenceSamples = compared;
-      if (unshown > 0) stats.sequenceSamplesUnshown = unshown;
-    });
+    //
+    // The body is `./assertions/bodies/a46.ts` since issue #1025 (cut 4c-3);
+    // what it reads off the skeleton JSON and the loaded skeleton is
+    // `spineSequenceFacts`, which answers an attachment by its address.
+    check('A46_SEQUENCE_ATTACHMENTS_SHOW_THE_FRAME_THE_FILE_STATES', () => a46SequenceAttachmentsShowTheFrameTheFileStates(verdicts, spineSequenceFacts(raw, data)));
   }
 
   // --- A06 / A17 / A19: the atlas against the PNGs on disk ------------------
@@ -3853,63 +3330,7 @@ export function validate(input: ValidateInput): ValidateReport {
   //
   // The axis bone itself must carry no keys at all: `invariants.axisBone` names
   // a per-cut SETUP value, and animating it swings the whole formation.
-  check('A24_AXIS_SPACE_STROKE', () => {
-    const rig = input.rig;
-    if (!rig) return skip('A24_AXIS_SPACE_STROKE', 'no rig info (validating a bare directory)');
-    if (!rig.axisBone) {
-      return skip(
-        'A24_AXIS_SPACE_STROKE',
-        `the rig "${rig.archetype}" declares no axis bone, so there is no axis space for a stroke to leave`,
-      );
-    }
-    const subtree = new Set(rig.axisSubtree);
-    const anims = isObj(raw?.animations) ? (raw.animations as Json) : {};
-    // The stroke is the subject and its keys are where it lives (#580). A rig
-    // that names an axis bone and then keys neither it nor anything under it has
-    // no stroke for this rule to find out of axis space, and a loop over nothing
-    // used to report that as held.
-    let keyed = 0;
-    for (const [animName, anim] of Object.entries(anims)) {
-      if (!isObj(anim) || !isObj(anim.bones)) continue;
-      for (const [boneName, timelines] of Object.entries(anim.bones as Json)) {
-        if (boneName === rig.axisBone) {
-          keyed++;
-          fail(
-            'A24_AXIS_SPACE_STROKE',
-            `"${animName}" keys the axis bone "${boneName}"; the axis angle is a per-cut SETUP value, not animation`,
-          );
-          continue;
-        }
-        if (subtree.has(boneName)) keyed++;
-        if (!subtree.has(boneName) || !isObj(timelines)) continue;
-        if ('translatey' in timelines) {
-          fail(
-            'A24_AXIS_SPACE_STROKE',
-            `"${animName}" gives "${boneName}" a translatey timeline; a bone under "${rig.axisBone}" moves along the axis only`,
-          );
-        }
-        const keys = (timelines as Json).translate;
-        if (!Array.isArray(keys)) continue;
-        for (const key of keys) {
-          if (!isObj(key)) continue;
-          const y = Number(key.y ?? 0);
-          if (Number.isFinite(y) && Math.abs(y) > 1e-6) {
-            fail(
-              'A24_AXIS_SPACE_STROKE',
-              `"${animName}" keys "${boneName}" translate y=${y} at t=${String(key.time ?? 0)}; the axis bone carries the direction, so keys are translateX only`,
-            );
-          }
-        }
-      }
-    }
-    if (keyed === 0) {
-      return skip(
-        'A24_AXIS_SPACE_STROKE',
-        `no animation keys the axis bone "${rig.axisBone}" or any of the ${rig.axisSubtree.length} bone(s) under ` +
-          'it, so this rig has no stroke to hold in axis space',
-      );
-    }
-  });
+  check('A24_AXIS_SPACE_STROKE', () => a24AxisSpaceStroke(verdicts, rawBoneTimelines(raw), input));
 
   // --- A25: parentage that must never happen -------------------------------
   //
@@ -3920,36 +3341,7 @@ export function validate(input: ValidateInput): ValidateReport {
   // the reason it is tempting, because the wrong parentage still loads and still
   // animates — it just lies. That is exactly the class of invariant that belongs
   // in a machine guard rather than in prose.
-  check('A25_DETACHED_BONE_PARENTAGE', () => {
-    const rig = input.rig;
-    if (!rig) return skip('A25_DETACHED_BONE_PARENTAGE', 'no rig info (validating a bare directory)');
-    if (!rig.detached.length) {
-      return skip('A25_DETACHED_BONE_PARENTAGE', `the rig "${rig.archetype}" declares no forbidden parentage`);
-    }
-    const parentOf = new Map<string, string | null>();
-    for (const bone of Array.isArray(raw?.bones) ? (raw.bones as unknown[]) : []) {
-      if (isObj(bone) && typeof bone.name === 'string') {
-        parentOf.set(bone.name, typeof bone.parent === 'string' ? bone.parent : null);
-      }
-    }
-    for (const [child, forbidden] of rig.detached) {
-      if (!parentOf.has(child)) {
-        fail('A25_DETACHED_BONE_PARENTAGE', `the rig declares "${child}" detached from "${forbidden}" but has no such bone`);
-        continue;
-      }
-      const seen = new Set<string>();
-      for (let cursor = parentOf.get(child) ?? null; cursor; cursor = parentOf.get(cursor) ?? null) {
-        if (seen.has(cursor)) break; // a cycle; the loader would have thrown first
-        seen.add(cursor);
-        if (cursor !== forbidden) continue;
-        fail(
-          'A25_DETACHED_BONE_PARENTAGE',
-          `"${child}" is a descendant of "${forbidden}"; it must not be dragged by that bone's motion`,
-        );
-        break;
-      }
-    }
-  });
+  check('A25_DETACHED_BONE_PARENTAGE', () => a25DetachedBoneParentage(verdicts, rawSkeletonRoster(raw), input));
 
   // --- A26: the slots array IS the rig's slot table ------------------------
   //
@@ -3969,56 +3361,7 @@ export function validate(input: ValidateInput): ValidateReport {
   // fills it, so a shorter array is a loss and is named as one here. A slot
   // missing from the array moves every slot below it up one index, which is
   // what a `drawOrder` key's offsets are counted against.
-  check('A26_SLOT_DRAW_ORDER', () => {
-    if (!input.rig) return skip('A26_SLOT_DRAW_ORDER', 'no rig info (validating a bare directory)');
-    const order = input.rig.slotOrder;
-    if (!order) {
-      return skip(
-        'A26_SLOT_DRAW_ORDER',
-        `the rig "${input.rig.archetype}" declares no canonical slot order, so the emitted order has nothing to disagree with`,
-      );
-    }
-    const names = (Array.isArray(raw?.slots) ? (raw.slots as unknown[]) : [])
-      .filter(isObj)
-      .map((s) => String(s.name));
-    // ⛔ **No empty-subject SKIP here, and #575 is the whole reason** (#580). The
-    // empty sequence is a subsequence of every table, so before #575 a skeleton
-    // with no slot reported its draw order held and this rule wanted the same
-    // guard its neighbours got. It no longer does: the completeness clause below
-    // reads zero emitted slots against a declared table as EVERY slot lost,
-    // which is the maximal case of exactly the defect #575 filed — so the honest
-    // verdict is a FAIL naming them, and a SKIP here would suppress it. Measured:
-    // with the guard in place a rig declaring one slot beside an artifact
-    // carrying none reported SKIP; with it gone, `"block" is declared and not
-    // emitted`. A26 therefore has no vacuous pass left to convert, the way
-    // `A07_ATLAS_TEXT_SHAPE` has none.
-    let at = 0;
-    for (const name of names) {
-      const found = order.indexOf(name, at);
-      if (found < 0) {
-        const known = order.indexOf(name);
-        fail(
-          'A26_SLOT_DRAW_ORDER',
-          known < 0
-            ? `slot "${name}" is not in the archetype's slot table`
-            : `slot "${name}" is drawn out of order (table position ${known}, after a slot at ${at})`,
-        );
-        return;
-      }
-      at = found + 1;
-    }
-    const emitted = new Set(names);
-    const missing = order.filter((name) => !emitted.has(name));
-    if (missing.length > 0) {
-      fail(
-        'A26_SLOT_DRAW_ORDER',
-        `the rig "${input.rig.archetype}" declares ${order.length} slot(s) and the skeleton has ${names.length}: ` +
-          `${missing.map((name) => `"${name}"`).join(', ')} ${missing.length === 1 ? 'is' : 'are'} declared and ` +
-          'not emitted. A slot nothing fills is emitted with no setup attachment, not dropped — dropping one ' +
-          'moves every slot below it up one index',
-      );
-    }
-  });
+  check('A26_SLOT_DRAW_ORDER', () => a26SlotDrawOrder(verdicts, rawSkeletonRoster(raw), input));
 
   // --- A27: region name == the PNG's basename ------------------------------
   //
@@ -4059,25 +3402,7 @@ export function validate(input: ValidateInput): ValidateReport {
   //     get projected onto the axis rather than read as axis coordinates.
   //     Ignoring them would let a rig pass while a recoil key closed the last few
   //     pixels of the gap.
-  check('A29_STROKE_WITHIN_CONTACT_DEPTH', () => {
-    const rig = input.rig;
-    if (!rig) return skip('A29_STROKE_WITHIN_CONTACT_DEPTH', 'no rig info (validating a bare directory)');
-    if (!rig.contactDepth) {
-      return skip(
-        'A29_STROKE_WITHIN_CONTACT_DEPTH',
-        'the manifest declares no `stroke.contact_depth`, so this cut has no measured contact ceiling to hold the stroke to',
-      );
-    }
-    const deep = deepestInwardAdvance(raw, rig);
-    stats.contactDepth = rig.contactDepth;
-    stats.deepestAdvance = Math.round(deep.total * 1000) / 1000;
-    if (deep.total > rig.contactDepth + 1e-6) {
-      fail(
-        'A29_STROKE_WITHIN_CONTACT_DEPTH',
-        `${deep.describe()} but the masses meet at ${rig.contactDepth}px — the two plates would interpenetrate`,
-      );
-    }
-  });
+  check('A29_STROKE_WITHIN_CONTACT_DEPTH', () => a29StrokeWithinContactDepth(verdicts, rawBoneTimelines(raw), input));
 
   // --- A30: inward travel stops where the drawn cover runs out -------------
   //
@@ -4100,42 +3425,7 @@ export function validate(input: ValidateInput): ValidateReport {
   // validates. Rather than assert a number that no longer means anything, refuse
   // the deformation. A cut that wants squash under a declared ceiling has to
   // re-measure containment for the scaled contour and say so.
-  check('A30_STROKE_WITHIN_CAP_CONTAINMENT', () => {
-    const rig = input.rig;
-    if (!rig) return skip('A30_STROKE_WITHIN_CAP_CONTAINMENT', 'no rig info (validating a bare directory)');
-    if (!rig.capContainmentCeiling) {
-      return skip(
-        'A30_STROKE_WITHIN_CAP_CONTAINMENT',
-        'the manifest declares no `stroke.cap_containment_ceiling`, so this cut has no measured containment ceiling',
-      );
-    }
-    const deep = deepestInwardAdvance(raw, rig);
-    stats.capCeiling = rig.capContainmentCeiling;
-    stats.deepestAdvance = Math.round(deep.total * 1000) / 1000;
-    if (deep.total > rig.capContainmentCeiling + 1e-6) {
-      fail(
-        'A30_STROKE_WITHIN_CAP_CONTAINMENT',
-        `${deep.describe()} but the leading contour leaves the occluder's opaque footprint at ` +
-          `${rig.capContainmentCeiling}px — the part would be drawn where it should be covered`,
-      );
-    }
-    const subtree = new Set(rig.axisSubtree);
-    const anims = isObj(raw?.animations) ? (raw.animations as Json) : {};
-    for (const [animName, anim] of Object.entries(anims)) {
-      if (!isObj(anim) || !isObj(anim.bones)) continue;
-      for (const [boneName, timelines] of Object.entries(anim.bones as Json)) {
-        if (!subtree.has(boneName) || !isObj(timelines)) continue;
-        for (const name of Object.keys(timelines)) {
-          if (name !== 'scale' && name !== 'scalex' && name !== 'scaley') continue;
-          fail(
-            'A30_STROKE_WITHIN_CAP_CONTAINMENT',
-            `"${animName}" gives "${boneName}" a ${name} timeline while a cap-containment ceiling is declared; ` +
-              'the ceiling was measured on the undeformed contour, so a scaled plate is outside its evidence',
-          );
-        }
-      }
-    }
-  });
+  check('A30_STROKE_WITHIN_CAP_CONTAINMENT', () => a30StrokeWithinCapContainment(verdicts, rawBoneTimelines(raw), input));
 
   // --- A18: determinism ----------------------------------------------------
   check('A18_DETERMINISTIC_EMIT', () => {
@@ -4211,63 +3501,6 @@ export function validate(input: ValidateInput): ValidateReport {
   return { failures, passed, skipped, profileSkipped, profile, stats };
 }
 
-/**
- * Deepest inward advance the animation data asks for, in axis pixels.
- *
- * Shared by A29 and A30 because they bound the SAME quantity against two
- * different measured facts. Two things spend the same clearance and so are added:
- *
- *   * the stroke — a translateX on a bone in the axis subtree. A24 guarantees
- *     there is no hidden screen-space component to miss.
- *   * the mass bone's own inward keys. It typically hangs outside the axis
- *     subtree, so its keys are screen-space by design and get PROJECTED onto the
- *     axis rather than read as axis coordinates. Ignoring them would let a rig
- *     pass while a recoil key closed the last few pixels.
- */
-function deepestInwardAdvance(
-  raw: Json | null,
-  rig: NonNullable<ValidateInput['rig']>,
-): { total: number; describe: () => string } {
-  const anims = isObj(raw?.animations) ? (raw.animations as Json) : {};
-  const subtree = new Set(rig.axisSubtree);
-  let strokeMax = 0;
-  let strokeWhere = '';
-  let massMax = 0;
-  let massWhere = '';
-  for (const [animName, anim] of Object.entries(anims)) {
-    if (!isObj(anim) || !isObj(anim.bones)) continue;
-    for (const [boneName, timelines] of Object.entries(anim.bones as Json)) {
-      if (!isObj(timelines)) continue;
-      const keys = (timelines as Json).translate;
-      if (!Array.isArray(keys)) continue;
-      for (const key of keys) {
-        if (!isObj(key)) continue;
-        if (subtree.has(boneName)) {
-          // +x is inward along the axis; a retracted key is negative and spends
-          // no clearance, so only the inward extreme matters.
-          const x = Number(key.x ?? 0);
-          if (Number.isFinite(x) && x > strokeMax) {
-            strokeMax = x;
-            strokeWhere = `${animName}.${boneName} t=${String(key.time ?? 0)}`;
-          }
-        } else if (boneName === rig.massBone && rig.inwardUnit) {
-          const inward = Number(key.x ?? 0) * rig.inwardUnit[0] + Number(key.y ?? 0) * rig.inwardUnit[1];
-          if (Number.isFinite(inward) && inward > massMax) {
-            massMax = inward;
-            massWhere = `${animName}.${boneName} t=${String(key.time ?? 0)}`;
-          }
-        }
-      }
-    }
-  }
-  return {
-    total: strokeMax + massMax,
-    describe: () =>
-      `deepest inward advance is ${(strokeMax + massMax).toFixed(3)}px (stroke ${strokeMax.toFixed(3)} at ${strokeWhere}` +
-      `${massMax > 0 ? ` + mass ${massMax.toFixed(3)} at ${massWhere}` : ''})`,
-  };
-}
-
 /**
  * Decode a weighted mesh's `vertices` run into per-vertex (boneIndex, weight).
  *