spine-rigc 1.9.1 → 1.9.2

package/src/assertions/facts/slider_composition.ts

@@ -0,0 +1,78 @@
+/**
+ * The sliders and the timelines their animations key, as A40 reads them
+ * (issue #1025, cut 4c-5 of step 4c of #380) — the census's F01–F04, F12,
+ * F15, F18, F19 and R3.
+ *
+ * ⭐ **The order is the runtime's.** The sliders in the `constraints` array's
+ * order, which is the update order and the order A40 calls "earlier" and
+ * "later" in; each animation's timelines in the order the runtime builds
+ * them — the slot timelines, the bone timelines, then ik, transform, path,
+ * physics, slider, the attachments' deform and sequence, the draw order and
+ * the events, each group's targets in the order the file keys them [measured:
+ * an animation keying `events`, `drawOrder`, `attachments`, `slider`,
+ * `physics`, `path`, `transform`, `ik`, `slots`, `bones` in that key order
+ * loads them slots, bones, ik, transform, path, physics, slider, deform,
+ * sequence, draw order, events]; each timeline's properties in the order it
+ * registers them. A40 groups the timelines by property in that order and
+ * prints one line per property shared, so the order is a fact both suppliers
+ * state, not a sort either applies.
+ *
+ * 🔑 **A property is named by an id both suppliers spell the same way**: the
+ * property's name, then the index of the bone, slot or constraint it
+ * addresses in the skeleton's order (`-1` for a physics timeline naming no
+ * constraint), then — for a deform or sequence timeline — the attachment it
+ * is keyed on as `skin/slot/placeholder`. The runtime spells the last as an
+ * object's serial number, which is the runtime's and not the rig's, so its
+ * supplier maps each attachment object to the address it is filed under; a
+ * physics `reset` and the draw-order and event timelines carry no index at
+ * all (measured: a named `reset` reads `physicsConstraintReset` alone).
+ *
+ * 🔸 **What applying a timeline additively does is a question, not a value.**
+ * It is posed — twice, with `add`, from two start states, under every skin —
+ * so a body asks for it (`behaviour`), and only for the timelines it needs:
+ * the validator answers with the runtime's probe, the model side with the
+ * core's (`src/core/additive.ts`), and the selftest puts every question a
+ * body asks to both.
+ *
+ * Links nothing from the runtime.
+ */
+
+/** What applying a timeline twice with `add` does (`src/core/additive.ts`' header). */
+export type AddBehaviour = 'accumulates' | 'overwrites' | 'inert';
+
+/** One property a timeline registers: the id it is shared by, the property's name, and the target and property as A40's sentence names them. */
+export interface SliderTimelineProperty {
+  readonly id: string;
+  readonly property: string;
+  readonly names: string;
+}
+
+/** One timeline of a slider's animation. */
+export interface SliderTimelineFact {
+  /** The runtime class it loads as — the word A40's sentence names `apply` on. */
+  readonly runtimeClass: string;
+  readonly properties: readonly SliderTimelineProperty[];
+}
+
+/** One slider constraint. */
+export interface SliderFact {
+  readonly name: string;
+  /** Its position in the skeleton's `constraints` array. */
+  readonly index: number;
+  /** Its setup `mix`. */
+  readonly mix: number;
+  readonly additive: boolean;
+  readonly skinRequired: boolean;
+  /** The skins whose `slider` list names it, in the skeleton's skin order. */
+  readonly skins: readonly string[];
+  /** The animation it applies, with its timelines in the runtime's order — or `null` where it applies none. */
+  readonly animation: { readonly name: string; readonly timelines: readonly SliderTimelineFact[] } | null;
+}
+
+/** What A40 reads beside the constraint facts. */
+export interface SliderCompositionFacts {
+  /** Every slider, in the `constraints` array's order. */
+  readonly sliders: readonly SliderFact[];
+  /** What the `timeline`-th timeline of `animation` does when it is applied twice with `add` — posed. */
+  behaviour(animation: string, timeline: number): AddBehaviour;
+}

package/src/assertions/facts/stepped_poses.ts

@@ -0,0 +1,74 @@
+/**
+ * The stepped poses (issue #1025, cut 4c-5a of step 4c of #380) — the census's
+ * F01, F18, R4 (the posed `inherit`) and R5 as A10 reads them: the skeleton's
+ * setup pose with every physics state reset, every animation walked on a
+ * LOOPING track from that pose in equal steps, and a bone's inheritance mode
+ * posed at one time on a fresh, non-looping track.
+ *
+ * ⭐ **A pose is handed over whole, non-finite values in place.** A10's
+ * subject is the first number of a pose that is not finite, so a supplier
+ * that refused such a pose, or wrote it as something else, would answer a
+ * different question. The runtime's supplier reads what spine-core posed; the
+ * model side's is the core's looping walk (`src/core/walk.ts`), which returns
+ * the value rather than refusing it.
+ *
+ * 🔸 **The inheritance mode is `null` where the pose holds a mode**, and the
+ * value it holds, as `String` spells it, where it holds none — the one bone
+ * reading that can be wrong with every number finite (#733): the runtime's
+ * lookup leaves a spelling it does not resolve as no mode at all.
+ *
+ * The bone timelines A10 walks for its `inherit` keys are `BoneTimelineFacts`
+ * (`./bone_timelines.ts`), the family A24, A29 and A30 read.
+ *
+ * Links nothing from the runtime: `validate()` supplies it from spine-core
+ * (`spineSteppedPoses`), the model side from the document and the core
+ * (`../model/stepped_poses.ts`).
+ */
+import type { PosedVertices, WorldTransform } from '../../nonfinite.ts';
+
+/** One bone of a pose: its world transform as computed, and its inheritance mode — `null` for a mode, else the value held. */
+export interface SteppedBone extends WorldTransform {
+  readonly inherit: string | null;
+}
+
+/** One slot of a pose: its light colour and its dark colour (`null` for a slot holding none), as computed. */
+export interface SteppedSlot {
+  readonly name: string;
+  readonly colour: readonly [number, number, number, number];
+  readonly dark: readonly [number, number, number] | null;
+}
+
+/** One pose: every bone in skeleton order, every region and mesh shown in draw order, every slot in setup order. */
+export interface SteppedFrame {
+  readonly bones: readonly SteppedBone[];
+  readonly drawn: readonly PosedVertices[];
+  readonly slots: readonly SteppedSlot[];
+}
+
+/** What A10 reads. */
+export interface SteppedPoseFacts {
+  /** The skeleton's bone count. */
+  readonly boneCount: number;
+  /** The animations, in the file's order, each with the runtime's duration (the last key of every timeline, as float32). */
+  readonly steppedAnimations: ReadonlyArray<{ readonly name: string; readonly duration: number }>;
+  /** Whether the skeleton holds an animation of this name. */
+  hasAnimation(name: string): boolean;
+  /** Whether the skeleton holds a bone of this name. */
+  hasBone(name: string): boolean;
+  /**
+   * The bone's inheritance mode with the animation applied at `time` on a
+   * fresh, non-looping track from the setup pose, every physics state reset
+   * before it — `null` where the pose holds a mode, else that value spelled by
+   * `String`, and `undefined` for a bone the skeleton does not have.
+   */
+  posedInherit(animation: string, bone: string, time: number): string | null | undefined;
+  /** How the file spells a bone's setup `inherit`: `JSON.stringify` of the stated value (`"undefined"` for none). */
+  statedInherit(bone: string): string;
+  /** The setup pose, every physics state reset, before any animation is set. */
+  setup(): SteppedFrame;
+  /**
+   * The animation set on a LOOPING track over that setup pose, then `frames`
+   * steps of `step` each — the poses after steps 1 to `frames`, in order.
+   */
+  walk(animation: string, step: number, frames: number): SteppedFrame[];
+}

package/src/assertions/model/constraint_targets.ts

@@ -0,0 +1,82 @@
+/**
+ * The model side's supply of `ConstraintTargetFacts` (issue #1025, cut 4c-5
+ * of step 4c of #380): the document's constraints and every animation's
+ * constraint groups, laid out as the Spine file lays them.
+ *
+ * - **The constraints**: the document's, in its order — which the emitter
+ *   writes the `constraints` array in — each its name and its kind, the word
+ *   the file spells its `type` with.
+ * - **The animations**: in the file's order (`fileAnimationOrder`, issue
+ *   #1034); in each the five groups in A34's fixed order, a group only where
+ *   the document holds an entry for it (`emitAnimation` writes a group only
+ *   when the model holds something for it); each group's entries in the order
+ *   the file keys them — an object the emitter fills in the document's order,
+ *   so its names land as `keyedOrder` lands them, built here as that object;
+ *   the timeline naming no physics constraint under the empty name the
+ *   emitter spells it with, where the document spells it `*`
+ *   (`EVERY_GLOBAL_PHYSICS`); each entry's timelines in the document's order,
+ *   which the emitter writes unchanged (a name-keyed map no key-order pass
+ *   touches, `src/keyorder.ts`). A document the reader accepted states every
+ *   key array as a non-empty list, a named group's entry as named timelines,
+ *   and only constraints of the kind its group names, so the clauses that
+ *   refuse those shapes have nothing to fire on here.
+ * - **The reach** of a physics timeline naming none: the core's own reading,
+ *   `unnamedReach` (`./constraints.ts`, which poses the timeline through
+ *   `posedPhysics` and reads which records took the key), over the document's
+ *   physics records in its order. The reader refuses a physics timeline name
+ *   it does not know, so every name asked of it is one the core poses.
+ *
+ * Links nothing from the runtime.
+ */
+import { fileAnimationOrder } from '../../compile.ts';
+import { EVERY_GLOBAL_PHYSICS, PHYSICS_TIMELINE_KINDS, type CorePhysicsRecord } from '../../core/constraints_physics.ts';
+import type { ConstraintTargetFacts, TargetAnimation, TargetEntry, TargetKeyArray } from '../facts/constraint_targets.ts';
+import { isObj, type Json } from '../values.ts';
+import { unnamedReach } from './constraints.ts';
+import type { ReadDocument } from './parse.ts';
+
+const list = (v: unknown): Json[] => (Array.isArray(v) ? v.filter(isObj) : []);
+const keyArray = (timeline: string, keys: unknown): TargetKeyArray => ({ timeline, keys: Array.isArray(keys) ? { count: keys.length } : { spelled: `${JSON.stringify(keys)}` } });
+
+/** One group's entries as the file keys them: an object filled in the document's order, read back in its key order. */
+function fileEntries(group: 'ik' | 'transform' | 'path' | 'physics' | 'slider', entries: readonly Json[]): TargetEntry[] {
+  const keyed: Record<string, TargetEntry> = {};
+  for (const entry of entries) {
+    if (typeof entry.name !== 'string') continue;
+    const name = group === 'physics' && entry.name === EVERY_GLOBAL_PHYSICS ? '' : entry.name;
+    keyed[name] =
+      group === 'ik' || group === 'transform'
+        ? { name, bare: null, keyArrays: [keyArray('', entry.keys)] }
+        : { name, bare: null, keyArrays: list(entry.timelines).flatMap((t) => (typeof t.name === 'string' ? [keyArray(t.name, t.keys)] : [])) };
+  }
+  return Object.values(keyed);
+}
+
+export function modelConstraintTargets(read: ReadDocument): ConstraintTargetFacts {
+  const { doc } = read;
+  const byName = new Map<string, Json>();
+  for (const anim of list(read.json.animations)) if (typeof anim.name === 'string') byName.set(anim.name, anim);
+  const animations: TargetAnimation[] = [];
+  for (const name of fileAnimationOrder(doc)) {
+    const anim = byName.get(name);
+    if (anim === undefined) continue;
+    const groups: TargetAnimation['groups'][number][] = [];
+    const constraints = isObj(anim.constraints) ? anim.constraints : {};
+    for (const group of ['ik', 'transform', 'path', 'physics', 'slider'] as const) {
+      const entries = list(constraints[group]);
+      if (entries.length > 0) groups.push({ group, entries: fileEntries(group, entries) });
+    }
+    animations.push({ name, groups });
+  }
+  const records = doc.constraints.flatMap((c): CorePhysicsRecord[] => (c.record?.kind === 'physics' ? [c.record] : []));
+  return {
+    constraints: doc.constraints.map((c) => ({ name: c.name, type: c.kind, spelled: c.name })),
+    groupsByAnimation: animations,
+    reach: (timeline) => {
+      const kind = PHYSICS_TIMELINE_KINDS.find((k) => k === timeline);
+      if (kind === undefined) return null;
+      const reached = unnamedReach(records, kind);
+      return { resets: kind === 'reset', reached: records.filter((r) => reached.has(r.name)).map((r) => r.name) };
+    },
+  };
+}

package/src/assertions/model/index.ts

@@ -12,7 +12,8 @@
  * `./linked_meshes.ts`, `./constraints.ts`; cut 4c-4's
  * `./skeleton_roster.ts`, `./bone_timelines.ts`, `./event_keys.ts`; cut
  * 4c-3's `./deform_survey.ts`, `./animation_durations.ts`, `./two_colour.ts`,
- * `./sequences.ts`)
+ * `./sequences.ts`; cut 4c-5's `./slider_composition.ts`,
+ * `./constraint_targets.ts`; cut 4c-5a's `./stepped_poses.ts`)
  * and calls the same body inside the same harness (`../harness.ts`). The
  * selftest holds the two to the same lines on every call it makes with a
  * model in hand, and `tools/verdict_gate.ts` on every recipe.
@@ -116,6 +117,15 @@ import type { DeformSurveyFacts } from '../facts/deform_survey.ts';
 import type { AnimationDurationFacts } from '../facts/animation_durations.ts';
 import type { TwoColourFacts } from '../facts/two_colour.ts';
 import type { SequenceFacts } from '../facts/sequences.ts';
+import { a40SlidersComposeOnASharedTarget } from '../bodies/a40.ts';
+import { modelSliderComposition } from './slider_composition.ts';
+import type { SliderCompositionFacts } from '../facts/slider_composition.ts';
+import { a34ConstraintTimelineTargets } from '../bodies/a34.ts';
+import { modelConstraintTargets } from './constraint_targets.ts';
+import type { ConstraintTargetFacts } from '../facts/constraint_targets.ts';
+import { a10NoNanAfterStepping } from '../bodies/a10.ts';
+import { modelSteppedPoses } from './stepped_poses.ts';
+import type { SteppedPoseFacts } from '../facts/stepped_poses.ts';
 
 /** What the model side is given. */
 export interface ModelValidateInput {
@@ -171,6 +181,9 @@ export interface ModelSupply {
   animationDurations: (read: ReadDocument) => AnimationDurationFacts;
   twoColour: (read: ReadDocument) => TwoColourFacts;
   sequences: (read: ReadDocument) => SequenceFacts;
+  sliderComposition: (read: ReadDocument) => SliderCompositionFacts;
+  constraintTargets: (read: ReadDocument) => ConstraintTargetFacts;
+  steppedPoses: (read: ReadDocument) => SteppedPoseFacts;
 }
 
 /** The suppliers the model side runs on. */
@@ -195,6 +208,9 @@ export const MODEL_SUPPLY: ModelSupply = {
   animationDurations: modelAnimationDurations,
   twoColour: modelTwoColour,
   sequences: modelSequences,
+  sliderComposition: modelSliderComposition,
+  constraintTargets: modelConstraintTargets,
+  steppedPoses: modelSteppedPoses,
 };
 
 /**
@@ -216,7 +232,7 @@ export interface MovedAssertion {
    *
    * Since cut 4c-4 also every rule `validate()` runs over the skeleton JSON
    * whatever its round trip did (A12, A24, A25, A26, A29, A30, and A32, which
-   * runs before it): on the runtime's side their verdict does not wait on the
+   * runs before it; since cut 4c-5 A34): on the runtime's side their verdict does not wait on the
    * load, so on this side it does not wait on the region rule, and where both
    * parses refuse a build the two sides' lines of these rules are still
    * compared.
@@ -269,6 +285,9 @@ export const MOVED_ASSERTIONS: readonly MovedAssertion[] = [
   { code: 'A09_ANIMATION_DURATION_MATCHES_SPEC', run: (v, read, input, supply) => a09AnimationDurationMatchesSpec(v, supply.animationDurations(read), input.declaredDurations), unread: SKIP_NO_MODEL },
   { code: 'A43_TWO_COLOR_TINT_LOADS_AND_POSES_AS_WRITTEN', run: (v, read, _input, supply) => a43TwoColorTintLoadsAndPosesAsWritten(v, supply.twoColour(read)), unread: SKIP_NO_MODEL },
   { code: 'A46_SEQUENCE_ATTACHMENTS_SHOW_THE_FRAME_THE_FILE_STATES', run: (v, read, _input, supply) => a46SequenceAttachmentsShowTheFrameTheFileStates(v, supply.sequences(read)), unread: SKIP_NO_MODEL },
+  { code: 'A40_SLIDERS_COMPOSE_ON_A_SHARED_TARGET', run: (v, read, _input, supply) => a40SlidersComposeOnASharedTarget(v, supply.sliderComposition(read), supply.constraints(read)), unread: SKIP_NO_MODEL },
+  { code: 'A34_CONSTRAINT_TIMELINE_TARGETS', run: (v, read, _input, supply) => a34ConstraintTimelineTargets(v, supply.constraintTargets(read)), unread: SKIP_NO_MODEL, beforeTheParse: true },
+  { code: 'A10_NO_NAN_AFTER_STEPPING', run: (v, read, _input, supply) => a10NoNanAfterStepping(v, supply.boneTimelines(read), supply.steppedPoses(read)), unread: SKIP_NO_MODEL },
 ];
 
 /** The codes the model side prints: its two parse rules, then the moved assertions. */

package/src/assertions/model/slider_composition.ts

@@ -0,0 +1,191 @@
+/**
+ * The model side's supply of `SliderCompositionFacts` (issue #1025, cut 4c-5
+ * of step 4c of #380): the document's sliders in its `constraints` order, the
+ * timelines of each animation they apply in the order the runtime builds
+ * them, and what each does when applied additively, as the core computes it.
+ *
+ * - **A slider's fields** are the core's record (`readSliderRecord`): `mix`,
+ *   `additive` and `skin` read at the parser's value where the document
+ *   leaves them out. The skins naming it are the document's skins in the
+ *   file's order (`fileSkinOrder`), each whose `slider` list names it.
+ * - **The timelines, in the runtime's order** (`../facts/slider_composition.ts`'
+ *   ⭐): the slot and bone timelines as the file states them (`fileSlotTimelines`,
+ *   `fileBoneTimelines` — the emitter's own passes over the document's
+ *   order), the constraint timelines in the order the runtime builds them
+ *   (`modelConstraintTimelineSources`), the attachments' deform and sequence
+ *   timelines at their three levels in the order the file keys them
+ *   (`keyedOrder` over the document's order, deform before sequence —
+ *   `emitAttachmentTimelines`' order), then the draw order and the events.
+ * - **The words.** Each timeline's class name and properties are the core's
+ *   table (`ADDITIVE_APPLY`, `src/core/additive.ts`), the one value here that
+ *   is not the document's, measured off the loaded timelines; an id's index is
+ *   the target's position in the document's bones, slots or constraints —
+ *   which the emitter writes in that order — `-1` for a physics timeline
+ *   naming none; a deform's attachment is named as the runtime names it, the
+ *   record's `name`, else its placeholder.
+ * - **The behaviour** is the core's probe over the document under no skin set
+ *   (`noSkinView`, which refuses by name a document whose skins it was not
+ *   measured over) and under each skin (`underSkin`): `additiveCells`, and the
+ *   class `additiveBehaviour` reads off them. The core suite's `CO27` holds
+ *   both to the runtime's probe; the selftest asks this supplier every
+ *   question the body asks the runtime's (`VF14`).
+ *
+ * Links nothing from the runtime.
+ */
+import { fileSkinOrder, keyedOrder } from '../../compile.ts';
+import { ADDITIVE_APPLY, additiveBehaviour, additiveCells, additiveSpelling, type AdditiveTimeline, type AdditiveView } from '../../core/additive.ts';
+import { EVERY_GLOBAL_PHYSICS, type PhysicsTimelineKind } from '../../core/constraints_physics.ts';
+import { underSkin, type CompiledDocument } from '../../core/index.ts';
+import type { BoneTimelineKind, SlotTimelineKind } from '../../core/animation.ts';
+import { noSkinView } from '../../render_core.ts';
+import { entryAddress } from '../facts/sequences.ts';
+import type { SliderCompositionFacts, SliderFact, SliderTimelineFact } from '../facts/slider_composition.ts';
+import { modelConstraintTimelineSources } from './constraints.ts';
+import { fileBoneTimelines } from './bone_timelines.ts';
+import { fileSlotTimelines } from './slot_colour.ts';
+import type { ReadDocument } from './parse.ts';
+import { isObj } from '../values.ts';
+
+/** One timeline of an animation: the facts' reading of it and the core's. */
+export interface ModelSliderTimeline {
+  fact: SliderTimelineFact;
+  core: AdditiveTimeline;
+}
+
+/** Names in the order each first appears, put in the order a JSON object keyed by them lists them (`keyedOrder`). */
+const keyedFirsts = (names: readonly string[]): string[] => keyedOrder(names.filter((name, i) => names.indexOf(name) === i));
+
+/** The words of one timeline: the table's class and properties, each id addressed by `index` (and `attachment`), and the sentence's naming. */
+function factOf(doc: CompiledDocument, core: AdditiveTimeline): SliderTimelineFact {
+  const row = ADDITIVE_APPLY[additiveSpelling(core)];
+  if (row === undefined) throw new Error(`internal: "${additiveSpelling(core)}" is no row of the additive table`);
+  const property = (p: string, index: number | null, attachment: string | null, names: string) => ({
+    id: [p, ...(index === null ? [] : [String(index)]), ...(attachment === null ? [] : [attachment])].join('|'),
+    property: p,
+    names,
+  });
+  const slotIndex = (name: string): number => doc.slots.findIndex((s) => s.name === name);
+  let properties: SliderTimelineFact['properties'];
+  switch (core.group) {
+    case 'bone': {
+      const index = doc.bones.findIndex((b) => b.name === core.bone);
+      properties = row.properties.map((p) => property(p, index, null, `bone "${core.bone}" ${p}`));
+      break;
+    }
+    case 'slot':
+      properties = row.properties.map((p) => property(p, slotIndex(core.slot), null, `slot "${core.slot}" ${p}`));
+      break;
+    case 'attachment': {
+      const record = doc.skins.find((k) => k.name === core.skin)?.attachments[core.slot]?.[core.attachment];
+      const shown = record?.name ?? core.attachment;
+      const address = entryAddress(core.skin, core.slot, core.attachment);
+      properties = row.properties.map((p) => property(p, slotIndex(core.slot), address, core.word === 'deform' ? `slot "${core.slot}" deform of "${shown}"` : `slot "${core.slot}" ${p}`));
+      break;
+    }
+    case 'drawOrder':
+    case 'events':
+      properties = row.properties.map((p) => property(p, null, null, `the skeleton's ${p}`));
+      break;
+    default: {
+      const index = core.group === 'physics' && core.constraint === EVERY_GLOBAL_PHYSICS ? -1 : doc.constraints.findIndex((c) => c.kind === core.group && c.name === core.constraint);
+      properties = row.properties.map((p) => property(p, row.address === 'none' ? null : index, null, index >= 0 ? `constraint "${core.constraint}" ${p}` : `the skeleton's ${p}`));
+    }
+  }
+  return { runtimeClass: row.runtimeClass, properties };
+}
+
+/** Every timeline of animation `name`, in the order the runtime builds them (the header). */
+export function modelAnimationTimelines(read: ReadDocument, name: string): ModelSliderTimeline[] {
+  const { doc } = read;
+  const anim = doc.animations.find((a) => a.name === name);
+  if (anim === undefined) return [];
+  const t = anim.timelines;
+  const out: AdditiveTimeline[] = [];
+  for (const { slot, timelines } of fileSlotTimelines(read).filter((s) => s.animation === name)) {
+    const target = t.slots.find((s) => s.name === slot);
+    for (const word of Object.keys(timelines)) {
+      const keys = target?.timelines.find((x) => x.kind === word)?.keys;
+      if (keys !== undefined) out.push({ group: 'slot', word: word as SlotTimelineKind, slot, keys });
+    }
+  }
+  for (const { bone, timelines } of fileBoneTimelines(read).filter((b) => b.animation === name)) {
+    const target = t.bones.find((b) => b.name === bone);
+    for (const word of isObj(timelines) ? Object.keys(timelines) : []) {
+      const keys = target?.timelines.find((x) => x.kind === word)?.keys;
+      if (keys !== undefined) out.push({ group: 'bone', word: word as BoneTimelineKind, bone, keys });
+    }
+  }
+  for (const source of modelConstraintTimelineSources(read).filter((s) => s.animation === name)) {
+    switch (source.kind) {
+      case 'ik': {
+        const keys = anim.constraints.ik.find((x) => x.name === source.name)?.keys;
+        if (keys !== undefined) out.push({ group: 'ik', word: 'ik', constraint: source.name, keys });
+        break;
+      }
+      case 'transform':
+        out.push({ group: 'transform', word: 'transform', constraint: source.name, keys: source.keys });
+        break;
+      case 'path':
+        out.push({ group: 'path', word: source.word as 'position' | 'spacing' | 'mix', constraint: source.name, keys: source.keys });
+        break;
+      case 'physics':
+        out.push({ group: 'physics', word: source.word as PhysicsTimelineKind, constraint: source.name, keys: source.keys });
+        break;
+      case 'slider':
+        out.push({ group: 'slider', word: source.word as 'time' | 'mix', constraint: source.name, keys: source.keys });
+        break;
+    }
+  }
+  const attachments = t.attachments;
+  for (const skin of keyedFirsts(attachments.map((a) => a.skin))) {
+    const inSkin = attachments.filter((a) => a.skin === skin);
+    for (const slot of keyedFirsts(inSkin.map((a) => a.slot))) {
+      const inSlot = inSkin.filter((a) => a.slot === slot);
+      for (const attachment of keyedFirsts(inSlot.map((a) => a.attachment))) {
+        for (const a of inSlot.filter((x) => x.attachment === attachment)) {
+          if (a.deform !== null) out.push({ group: 'attachment', word: 'deform', skin, slot, attachment, keys: a.deform });
+          if (a.sequence !== null) out.push({ group: 'attachment', word: 'sequence', skin, slot, attachment, keys: a.sequence });
+        }
+      }
+    }
+  }
+  if (t.drawOrder.length > 0) out.push({ group: 'drawOrder', word: 'drawOrder', keys: t.drawOrder });
+  if (t.events.length > 0) out.push({ group: 'events', word: 'events', times: t.events.map((k) => k.time) });
+  return out.map((core) => ({ fact: factOf(doc, core), core }));
+}
+
+/** The views the probe poses under: no skin set, then every skin in the file's order. */
+export function additiveViews(doc: CompiledDocument): AdditiveView[] {
+  return [{ name: '(none)', doc: noSkinView(doc) }, ...fileSkinOrder(doc).map((skin) => ({ name: skin.name, doc: underSkin(doc, skin.name) }))];
+}
+
+export function modelSliderComposition(read: ReadDocument): SliderCompositionFacts {
+  const { doc } = read;
+  const skinOrder = fileSkinOrder(doc).map((skin) => skin.name);
+  const walked = new Map<string, ModelSliderTimeline[]>();
+  const timelinesOf = (name: string): ModelSliderTimeline[] => {
+    const held = walked.get(name);
+    if (held !== undefined) return held;
+    const fresh = modelAnimationTimelines(read, name);
+    walked.set(name, fresh);
+    return fresh;
+  };
+  const sliders: SliderFact[] = [];
+  doc.constraints.forEach((c, index) => {
+    const r = c.record;
+    if (r?.kind !== 'slider') return;
+    const animation = doc.animations.some((a) => a.name === r.animation) ? { name: r.animation, timelines: timelinesOf(r.animation).map((x) => x.fact) } : null;
+    const skins = skinOrder.filter((name) => doc.skins.some((k) => k.name === name && k.constraints.slider.includes(r.name)));
+    sliders.push({ name: r.name, index, mix: r.mix, additive: r.additive, skinRequired: r.skin, skins, animation });
+  });
+  let views: AdditiveView[] | null = null;
+  return {
+    sliders,
+    behaviour: (animation, at) => {
+      const timeline = timelinesOf(animation)[at];
+      if (timeline === undefined) throw new Error(`internal: animation "${animation}" has no timeline ${at}`);
+      views ??= additiveViews(doc);
+      return additiveBehaviour(additiveCells(views, timeline.core));
+    },
+  };
+}

package/src/assertions/model/stepped_poses.ts

@@ -0,0 +1,89 @@
+/**
+ * The model side's supply of `SteppedPoseFacts` (issue #1025, cut 4c-5a of
+ * step 4c of #380): every pose A10 reads, posed by rigc's core.
+ *
+ * - **The roster**: the document's bones, and its animations in the file's
+ *   order (`fileAnimationOrder`, `src/compile.ts`), each with
+ *   `CoreAnimationTimelines.duration` — the last key of every timeline as
+ *   float32, the value `tools/pose_oracle.ts compare` holds equal to
+ *   spine-core's on its `animations` roster.
+ * - **The setup pose and each animation's walk**: the core's looping walk
+ *   (`src/core/walk.ts` — `poseWalkSetup`, `poseLoopingWalk`), which reads
+ *   A10's recipe as measured and returns a value that is not finite in place
+ *   rather than refusing it. It is held equal to spine-core's walk at
+ *   tolerance 0 by `tools/core_gate.ts`'s walk block and the selftest's
+ *   `CO25`, and the poses A10 asks for here are compared with spine-core's on
+ *   every call with a model in hand (`VF13`).
+ * - **A bone's mode**: the mode the core's bone timelines pose at the time
+ *   (`posedBones`, a fresh non-looping track: the time held at the duration),
+ *   folded as the runtime's lookup folds it (`foldInheritMode`). `readModel`
+ *   refuses a setup `inheritMode` and an `inherit` key that fold to no mode by
+ *   name, so on this side every bone of every pose holds one and the answer is
+ *   `null` — derived from the pose rather than assumed, so a reader that
+ *   started admitting such a spelling would show up here as a bone with none.
+ * - **Under no skin set**, as `validate()` poses (`noSkinView`), which refuses
+ *   by name a document whose default skin it cannot read that way.
+ *
+ * Links nothing from the runtime.
+ */
+import { fileAnimationOrder } from '../../compile.ts';
+import { foldInheritMode, type CompiledDocument } from '../../core/index.ts';
+import { posedBones } from '../../core/animation.ts';
+import { poseLoopingWalk, poseWalkSetup, type WalkPose } from '../../core/walk.ts';
+import { noSkinView } from '../../render_core.ts';
+import type { ModelBone } from '../../model.ts';
+import type { SteppedFrame, SteppedPoseFacts } from '../facts/stepped_poses.ts';
+import type { ReadDocument } from './parse.ts';
+
+/** A bone's posed mode as the facts spell it: `null` for a mode, else the value held. */
+const modeOf = (bone: ModelBone): string | null => (foldInheritMode(bone.inheritMode ?? 'normal') === null ? String(bone.inheritMode) : null);
+
+/** A channel the walk computed; a slot row holds `null` only where a rounding wrote one, which the walk does not. */
+const channel = (v: number | null): number => (v === null ? Number.NaN : v);
+
+/** One walk pose as A10 reads it, each bone's mode taken from `posed` (the bones the timelines posed at the pose's time). */
+function frameOf(pose: WalkPose, posed: readonly ModelBone[]): SteppedFrame {
+  const modes = new Map(posed.map((b) => [b.name, modeOf(b)]));
+  return {
+    bones: pose.bones.map((b) => ({ name: b.name, a: b.a, b: b.b, c: b.c, d: b.d, worldX: b.worldX, worldY: b.worldY, inherit: modes.get(b.name) ?? null })),
+    drawn: pose.drawn.map((d) => ({ slot: d.slot, attachment: d.attachment, vertices: d.vertices })),
+    slots: pose.slots.map((row) => ({
+      name: row[0],
+      colour: [channel(row[2]), channel(row[3]), channel(row[4]), channel(row[5])] as const,
+      dark: row[6] === null ? null : ([channel(row[6][0]), channel(row[6][1]), channel(row[6][2])] as const),
+    })),
+  };
+}
+
+export function modelSteppedPoses(read: ReadDocument): SteppedPoseFacts {
+  let view: CompiledDocument | null = null;
+  const viewOf = (): CompiledDocument => (view ??= noSkinView(read.doc));
+  const animationOf = (name: string) => {
+    const anim = viewOf().animations.find((a) => a.name === name);
+    if (anim === undefined) throw new Error(`internal: the model side was asked to pose animation "${name}", which the document does not hold`);
+    return anim;
+  };
+  return {
+    boneCount: read.doc.bones.length,
+    steppedAnimations: fileAnimationOrder(read.doc).flatMap((name) => {
+      const anim = read.doc.animations.find((a) => a.name === name);
+      return anim === undefined ? [] : [{ name, duration: anim.timelines.duration }];
+    }),
+    hasAnimation: (name) => read.doc.animations.some((a) => a.name === name),
+    hasBone: (name) => read.doc.bones.some((b) => b.name === name),
+    posedInherit: (animation, bone, time) => {
+      const anim = animationOf(animation);
+      const t = time < anim.timelines.duration ? time : anim.timelines.duration;
+      const posed = posedBones(viewOf(), anim.timelines, t).find((b) => b.name === bone);
+      return posed === undefined ? undefined : modeOf(posed);
+    },
+    // The document's stated mode — asked only of a bone posing none, which the reader leaves this side no document to hold.
+    statedInherit: (name) => `${JSON.stringify(read.doc.bones.find((b) => b.name === name)?.inheritMode)}`,
+    setup: () => frameOf(poseWalkSetup(viewOf()), viewOf().bones),
+    walk: (animation, step, frames) => {
+      const anim = animationOf(animation);
+      const poses = poseLoopingWalk(viewOf(), animation, new Array<number>(frames).fill(step));
+      return poses.slice(1).map((pose) => frameOf(pose, posedBones(viewOf(), anim.timelines, pose.animationTime)));
+    },
+  };
+}

package/src/bonedist.ts

@@ -77,7 +77,7 @@
  */
 import { readFileSync } from 'node:fs';
 import {
-  loadPosable,
+  loadPosedSkeleton,
   PROTOCOL_FPS,
   sampleAnimation,
   sampleSetupPose,
@@ -184,7 +184,7 @@ export interface SkeletonSize {
   degenerate: boolean;
 }
 
-function skeletonSize(posable: Posable): SkeletonSize {
+function skeletonSize(posable: Pick<Posable, 'data'>): SkeletonSize {
   const setup = sampleSetupPose(posable.data, { bones: true }).at(0);
   const bones = setup?.bones ?? [];
   const rootData = posable.data.bones.find((b) => b.parent === null) ?? posable.data.bones.at(0);
@@ -338,10 +338,17 @@ export interface BoneDistReport {
 export interface BoneDistOptions {
   candidateSkeleton: string;
   candidateAtlas: string;
-  candidateAtlasDir: string;
+  /**
+   * Where the candidate's atlas pages are. Not read since issue #1042: no
+   * figure here samples a pixel, so no page is opened, and a pair whose pages
+   * are elsewhere measures the same. Kept optional so a caller that passes it
+   * still compiles.
+   */
+  candidateAtlasDir?: string;
   referenceSkeleton: string;
   referenceAtlas: string;
-  referenceAtlasDir: string;
+  /** The reference's, as `candidateAtlasDir` — not read. */
+  referenceAtlasDir?: string;
   /** A correspondence file path, or `identity`. */
   bones: string;
   fps?: number;
@@ -398,8 +405,13 @@ function extremesOf(values: number[]): Extremes {
 export function boneDistance(options: BoneDistOptions): BoneDistReport {
   const fps = options.fps ?? PROTOCOL_FPS;
   if (!Number.isFinite(fps) || fps <= 0) throw new BoneDistError('fps must be a positive number');
-  const candidate = loadPosable(options.candidateSkeleton, options.candidateAtlas, options.candidateAtlasDir);
-  const reference = loadPosable(options.referenceSkeleton, options.referenceAtlas, options.referenceAtlasDir);
+  // Each side through spine-core, refused by name where its skeleton does not load against its atlas (issue #1042),
+  // and without its page images: nothing here samples a pixel (`loadPosedSkeleton`).
+  const posedFor = (side: 'candidate' | 'reference', skeleton: string, atlas: string): Pick<Posable, 'data'> => ({
+    data: loadPosedSkeleton(skeleton, atlas, `bonedist's ${side}: every bone's world transform is read off spine-core's pose of it`),
+  });
+  const candidate = posedFor('candidate', options.candidateSkeleton, options.candidateAtlas);
+  const reference = posedFor('reference', options.referenceSkeleton, options.referenceAtlas);
 
   const candidateBoneNames = candidate.data.bones.map((b) => b.name);
   const referenceBoneNames = new Set(reference.data.bones.map((b) => b.name));