rig-c 0.0.0-stage → 2.20.4

package/src/assertions/model/slider_composition.ts

@@ -0,0 +1,193 @@
+/**
+ * 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
+ *   validator's table (`RUNTIME_TIMELINE`, `./runtime_timelines.ts`; the
+ *   core's until issue #1054), 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`, the view measured in issue #1051) 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 { additiveBehaviour, additiveCells, additiveSpelling, type AdditiveTimeline, type AdditiveView } from '../../core/additive.ts';
+import { RUNTIME_TIMELINE } from './runtime_timelines.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 = RUNTIME_TIMELINE[additiveSpelling(core)];
+  if (row === undefined) throw new Error(`internal: "${additiveSpelling(core)}" is no row of the runtime's timeline 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/slot_colour.ts

@@ -0,0 +1,81 @@
+/**
+ * The model side's supply of `SlotColourFacts` (issue #1025, step 4c of #380).
+ *
+ * - **The slot timelines, in the file's order and spelling.** The document
+ *   holds each animation's slot timelines in the order they are applied, with
+ *   every key as the compiler built it; the Spine file keys the animations in
+ *   the editor's order and passes every key through two passes. So the
+ *   animations are put in the file's order by `fileAnimationOrder`
+ *   (`src/compile.ts`: a `rigc-compiled/3` document's `editorOrder`, else the
+ *   emitter's own rule over its names, issue #1034), and the timelines are laid out as the
+ *   file lays them and handed to the emitter's own `withoutParserDefaults` and
+ *   `inEditorKeyOrder` (`src/keyorder.ts`) — so a key field the emitter would
+ *   leave out at the parser's default is left out here too, and a body
+ *   printing `JSON.stringify(key.value)` prints what it prints over the file.
+ *   Nothing here restates either rule.
+ * - **Whether an animation exists**: the document's own roster.
+ * - **A slot's posed colour**: the core's raw entry (`poseRawAnimation`,
+ *   `src/core/raw.ts`) taking one step of the time on a fresh non-looping
+ *   track, under the view the core poses with no skin set (`noSkinView`,
+ *   `src/render_core.ts`) — the reading of what `validate()` does through
+ *   spine-core (a fresh skeleton, no skin, setup pose, the track stepped to the
+ *   time and applied). Its slot rows are the ones `CR03` holds bit for bit to
+ *   spine-core on every frame of the nineteen recipes; that the two readings
+ *   print the same A45 line is the selftest's supplier check, on every call
+ *   that poses one (`VF02`). A channel the pose read as no number is NaN, as a
+ *   non-finite channel reads on the runtime's side.
+ *
+ * Links nothing from the runtime.
+ */
+import { fileAnimationOrder } from '../../compile.ts';
+import type { CompiledDocument } from '../../core/index.ts';
+import { poseRawAnimation } from '../../core/raw.ts';
+import { inEditorKeyOrder, withoutParserDefaults } from '../../keyorder.ts';
+import { noSkinView } from '../../render_core.ts';
+import type { SlotColourFacts, SlotTimelines } from '../facts/slot_colour.ts';
+import { isObj, type Json } from '../values.ts';
+import type { ReadDocument } from './parse.ts';
+
+const list = (v: unknown): Json[] => (Array.isArray(v) ? v.filter(isObj) : []);
+
+/** Every animation's slot timelines as the Spine file states them: `animations.<name>.slots.<slot>.<timeline> = keys`. */
+export function fileSlotTimelines(read: ReadDocument): SlotTimelines[] {
+  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: Json = {};
+  for (const name of fileAnimationOrder(read.doc)) {
+    const slots: Json = {};
+    for (const slot of list((byName.get(name) as Json).slots)) {
+      if (typeof slot.name !== 'string') continue;
+      const timelines: Json = {};
+      for (const timeline of list(slot.timelines)) {
+        if (typeof timeline.name === 'string') timelines[timeline.name] = list(timeline.keys).map((key) => ({ ...key }));
+      }
+      slots[slot.name] = timelines;
+    }
+    // An animation keying no slot writes no `slots` group — `emitAnimation`'s `if (animation.slots.size)`.
+    animations[name] = Object.keys(slots).length > 0 ? { slots } : {};
+  }
+  const file = inEditorKeyOrder(withoutParserDefaults({ animations }));
+  const out: SlotTimelines[] = [];
+  for (const [animation, anim] of Object.entries(file.animations)) {
+    if (!isObj(anim) || !isObj(anim.slots)) continue;
+    for (const [slot, timelines] of Object.entries(anim.slots)) if (isObj(timelines)) out.push({ animation, slot, timelines });
+  }
+  return out;
+}
+
+export function modelSlotColour(read: ReadDocument): SlotColourFacts {
+  let view: CompiledDocument | null = null;
+  return {
+    slotTimelines: fileSlotTimelines(read),
+    hasAnimation: (name) => read.doc.animations.some((a) => a.name === name),
+    posedSlot: (animation, slot, time) => {
+      view ??= noSkinView(read.doc);
+      const row = poseRawAnimation(view, animation, [time], {}, 'animation')[1].slots.find((r) => r[0] === slot);
+      if (row === undefined) return undefined;
+      const channel = (v: number | null): number => (v === null ? Number.NaN : v);
+      return { color: { r: channel(row[2]), g: channel(row[3]), b: channel(row[4]), a: channel(row[5]) } };
+    },
+  };
+}

package/src/assertions/model/stage.ts

@@ -0,0 +1,28 @@
+/**
+ * The model side's supply of `StageFacts` (issue #1025, step 4c of #380): the
+ * stage a `rigc-compiled/3` document states (`stated.stage`, issue #1026), or,
+ * for a `/2` or `/1` document, which does not, the stage its caller gives.
+ * A `/3` document given one anyway is refused (`refuseGivenBeside`).
+ *
+ * ⚠️ A caller that gives no stage at all is refused by name rather than read as
+ * "the skeleton declares none": those are two different statements, and only
+ * the second is one the caller made. A stage stated as `null` IS that second
+ * statement, and reads as both extents absent, the way the runtime loads a
+ * header with neither key.
+ *
+ * Links nothing from the runtime.
+ */
+import type { StageFacts } from '../facts/stage.ts';
+import { refuseGivenBeside, type ModelGiven } from './given.ts';
+import type { ReadDocument } from './parse.ts';
+
+export function modelStage(read: ReadDocument, given: ModelGiven | undefined): StageFacts {
+  refuseGivenBeside(read, given);
+  // The document's own statement (issue #1026): `null` is a skeleton that declares none, read as both extents absent.
+  if (read.doc.stated !== null) {
+    const stage = read.doc.stated.stage;
+    return { width: stage?.width, height: stage?.height };
+  }
+  if (given === undefined) throw new Error(`the caller gave no stage; a ${read.doc.spec} document does not state one, so the model side cannot read it`);
+  return { width: given.stage?.width, height: given.stage?.height };
+}

package/src/assertions/model/stage_box.ts

@@ -0,0 +1,51 @@
+/**
+ * The model side's supply of `StageBoxFacts` (issue #1168): the box the
+ * document's `stage.box` asks for, and what the document's `default` skin
+ * holds there — its record as the runtime would load it, and its world
+ * vertices at the setup pose as rigc's core poses them (`poseSetup` under no
+ * skin, constraints applied, then `worldVertices`, the function every vertex
+ * attachment of the core is posed by — no second arithmetic for the box).
+ *
+ * A `/2` or `/1` document states no stage and asks nothing; a `/3` document
+ * whose stage states no box asks nothing, and neither does one that declares no
+ * stage. The core's poses are held to spine-core's at tolerance 0 by
+ * `tools/core_gate.ts`, which is what lets this side and the round trip print
+ * one line.
+ *
+ * Links nothing from the runtime.
+ */
+import { activeBones, poseSetup, rawNumber, underNoSkin } from '../../core/index.ts';
+import { worldVertices } from '../../core/vertices.ts';
+import { SKIP_NO_STAGE_BOX, type StageBoxFacts, type StageBoxHeld } from '../facts/stage_box.ts';
+import type { ReadDocument } from './parse.ts';
+
+export function modelStageBox(read: ReadDocument): StageBoxFacts {
+  const doc = read.doc;
+  const stage = doc.stated?.stage;
+  if (doc.stated === null || stage === undefined || stage === null) return { asked: null, why: SKIP_NO_STAGE_BOX, slot: false, held: null };
+  if (stage.box === undefined) return { asked: null, why: SKIP_NO_STAGE_BOX, slot: false, held: null };
+  const asked = { slot: stage.box.slot, attachment: stage.box.attachment, stage: { x: stage.x, y: stage.y, width: stage.width, height: stage.height } };
+  const slot = doc.slots.find((s) => s.name === asked.slot);
+  if (slot === undefined) return { asked, why: '', slot: false, held: null };
+  const record = doc.skins.find((k) => k.name === 'default')?.attachments[asked.slot]?.[asked.attachment];
+  if (record === undefined) return { asked, why: '', slot: true, held: null };
+  const g = record.geometry;
+  const type = record.kind === 'linkedmesh' ? 'mesh' : record.kind;
+  if (g === undefined || g.kind !== 'boundingbox') return { asked, why: '', slot: true, held: { type, weighted: false, stored: [], world: '' } };
+  const vertices = g.vertices;
+  const stored = vertices.weighted ? [] : vertices.xy.map(Math.fround);
+  const held: StageBoxHeld = { type, weighted: vertices.weighted, stored, world: poseWorld(read, slot.bone, vertices) };
+  return { asked, why: '', slot: true, held };
+}
+
+/** The box's world vertices at the setup pose under no skin, or why there are none. */
+function poseWorld(read: ReadDocument, bone: string, vertices: Parameters<typeof worldVertices>[0]): number[] | string {
+  const view = underNoSkin(read.doc);
+  if (!activeBones(view).has(bone)) return `its bone "${bone}" is inactive with no skin set, so nothing poses it`;
+  const posed = poseSetup(view, { round: rawNumber });
+  const world = posed.world;
+  if (world === null) return posed.absent.find(([block]) => block === 'setup.bones')?.[1] ?? "rigc's core does not pose this setup pose";
+  const frame = world.get(bone);
+  if (frame === undefined) return `its bone "${bone}" has no setup world transform`;
+  return worldVertices(vertices, frame, world);
+}

package/src/assertions/model/stepped_poses.ts

@@ -0,0 +1,105 @@
+/**
+ * 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`). Since issue #1179's second part
+ *   the poses come through that walk's scan assembler (`scanWalkSetup`,
+ *   `scanLoopingWalk`): the same walk, each pose carrying what A10 reads — the
+ *   bones' matrix and origin, the slot rows, the drawn attachments' slot, name
+ *   and vertices — and none of the bones' getter readings and oracle rows or
+ *   the drawn rows' UVs, triangles and colour, which nothing it reads is
+ *   computed from. The core suite's `CO43` holds the scan to the public walk's
+ *   numbers bit for bit, `CO44` what it leaves out to move none of them, and
+ *   `CO45` that the vertex arrays it hands on uncopied are each pose's own.
+ * - **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`, the view
+ *   measured in issue #1051: no skin's bones or constraints applied, a slot
+ *   looked up in the default skin alone).
+ *
+ * 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 { scanLoopingWalk, scanWalkSetup } from '../../core/walk.ts';
+import type { ScanPose } from '../../core/raw.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);
+
+/** Each bone's posed mode as the facts spell it (`modeOf`), by name. */
+const modesOf = (posed: readonly ModelBone[]): ReadonlyMap<string, string | null> => new Map(posed.map((b) => [b.name, modeOf(b)]));
+
+/** One scan pose as A10 reads it, each bone's mode taken from `modes` (`modesOf` the bones the timelines posed at the pose's time); the drawn attachments are the scan's own rows, already in the shape A10 reads. */
+function frameOf(pose: ScanPose, modes: ReadonlyMap<string, string | null>): SteppedFrame {
+  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,
+    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(scanWalkSetup(viewOf()), modesOf(viewOf().bones)),
+    walk: (animation, step, frames) => {
+      const anim = animationOf(animation);
+      const poses = scanLoopingWalk(viewOf(), animation, new Array<number>(frames).fill(step));
+      // A bone's posed mode moves only by an `inherit` timeline: every other one `posedBones` reads leaves the setup's mode on its copy. So an animation
+      // keying none poses the setup's modes at every time, and they are read once rather than posed again at each of its frames (issue #1179).
+      const keysInherit = anim.timelines.bones.some((target) => target.timelines.some((tl) => tl.kind === 'inherit'));
+      const setupModes = keysInherit ? null : modesOf(viewOf().bones);
+      return poses.slice(1).map((pose) => frameOf(pose, setupModes ?? modesOf(posedBones(viewOf(), anim.timelines, pose.animationTime))));
+    },
+  };
+}

package/src/assertions/model/two_colour.ts

@@ -0,0 +1,61 @@
+/**
+ * The model side's supply of `TwoColourFacts` (issue #1025, cut 4c-3 of step
+ * 4c of #380).
+ *
+ * - **The stated dark colours**: the document's slots in their order — the
+ *   emitted slot array's — each `dark` as the document holds it, which the
+ *   emitter writes into the slot unchanged (`emitSlot`). `readModel` refuses
+ *   a `dark` that is not six or eight hex digits, so a spelling the runtime
+ *   would load as NaN or drop has no document to arrive in.
+ * - **The loaded dark colour**: the core's reading of that hex (`readColour`,
+ *   its first three channels) — the reading the setup pose's slot rows carry,
+ *   which `tools/pose_oracle.ts compare` holds equal to spine-core's on its
+ *   `setup.slots` block, on the grid and under `--raw`.
+ * - **The slot timelines**: `fileSlotTimelines` (`./slot_colour.ts`), the walk
+ *   A45 reads — the file's order and spelling, through the emitter's own
+ *   passes.
+ * - **A slot's posed colours**: the core's raw entry (`poseRawAnimation`,
+ *   `src/core/raw.ts`) taking one step of the time on a fresh track, under the
+ *   view the core poses with no skin set (`noSkinView`), as A45's posed colour
+ *   is taken — the slot row's light channels and its dark colour, NaN where the
+ *   row reads no number. No gate samples the times A43 asks for (a key's own
+ *   time), so the selftest compares these values with spine-core's at every
+ *   time the body asks, on every call with a model in hand (`VF12`).
+ *
+ * Links nothing from the runtime.
+ */
+import { readColour, type CompiledDocument } from '../../core/index.ts';
+import { poseRawAnimation } from '../../core/raw.ts';
+import { noSkinView } from '../../render_core.ts';
+import type { DarkColour, TwoColourFacts } from '../facts/two_colour.ts';
+import type { ReadDocument } from './parse.ts';
+import { fileSlotTimelines } from './slot_colour.ts';
+
+/** A channel the pose read as no number, as a non-finite channel reads on the runtime's side. */
+const channel = (v: number | null): number => (v === null ? Number.NaN : v);
+
+export function modelTwoColour(read: ReadDocument): TwoColourFacts {
+  let view: CompiledDocument | null = null;
+  const slotDarks = read.doc.slots.flatMap((slot) => (typeof slot.dark === 'string' ? [{ slot: slot.name, dark: slot.dark }] : []));
+  return {
+    slotDarks,
+    loadedDark: (name): DarkColour | null => {
+      const dark = read.doc.slots.find((s) => s.name === name)?.dark;
+      if (dark === undefined) return null;
+      const [r, g, b] = readColour(dark);
+      return { r, g, b };
+    },
+    slotTimelines: fileSlotTimelines(read),
+    hasAnimation: (name) => read.doc.animations.some((a) => a.name === name),
+    posedTint: (animation, slot, time) => {
+      view ??= noSkinView(read.doc);
+      const row = poseRawAnimation(view, animation, [time], {}, 'animation')[1].slots.find((r) => r[0] === slot);
+      if (row === undefined) return undefined;
+      const dark = row[6];
+      return {
+        light: { r: channel(row[2]), g: channel(row[3]), b: channel(row[4]), a: channel(row[5]) },
+        dark: dark === null ? null : { r: channel(dark[0]), g: channel(dark[1]), b: channel(dark[2]) },
+      };
+    },
+  };
+}

package/src/assertions/model/vertex_polygons.ts

@@ -0,0 +1,72 @@
+/**
+ * The model side's supply of `PolygonFacts` (issue #1025, step 4c of #380):
+ * the document's bounding boxes, clipping attachments and paths, and the
+ * clip ends it states.
+ *
+ * - **The polygons** in the loaded walk's order, `fileOrderedEntries`
+ *   (`./skin_entries.ts`). A polygon's `worldVerticesLength` is twice the
+ *   `vertexCount` the record states — the number the emitter copies into the
+ *   file, which the parser doubles into the length it reads the vertices to
+ *   (`readVertices`); the selftest compares it with spine-core's on every
+ *   call. A path's `closed` and `lengths` are the core's reading of the record
+ *   (`readGeometry`: `closed` absent reads the parser's `false`).
+ * - **The clip ends** in the order the file spells them: the skins and each
+ *   skin's slot keys in the order `fileSkinOrder` gives (`src/compile.ts`,
+ *   issue #1034: a `rigc-compiled/3` document's `editorOrder`, else the
+ *   emitter's `editorSkinOrder` and `editorSlotKeyOrder`, the functions
+ *   `emitSkins` is handed), each slot's records in table order — every clipping record that
+ *   states an `end`, with the `end` as it states it.
+ *
+ * `encoding` is empty on every polygon: the document states the weighted
+ * form outright, so a run's decode has no subject here.
+ *
+ * Links nothing from the runtime.
+ */
+import { fileSkinOrder, skinsInFileOrder } from '../../compile.ts';
+import { shownRow } from '../../core/index.ts';
+import type { ClipEnd, PolygonEntry, PolygonFacts } from '../facts/vertex_polygons.ts';
+import { isObj, type Json } from '../values.ts';
+import { fileOrderedEntries } from './skin_entries.ts';
+import type { ReadDocument } from './parse.ts';
+
+/** The document's own record of one skin entry, as the JSON spells it. */
+export function documentRecord(read: ReadDocument, skin: string, slot: string, placeholder: string): Json {
+  const skins = Array.isArray(read.json.skins) ? read.json.skins.filter(isObj) : [];
+  const table = skins.find((s) => s.name === skin)?.attachments;
+  const record = isObj(table) && isObj(table[slot]) ? (table[slot] as Json)[placeholder] : undefined;
+  if (!isObj(record)) throw new Error(`internal: skin "${skin}" slot "${slot}" placeholder "${placeholder}" is a record the reader returned and the document does not spell`);
+  return record;
+}
+
+/** Every record of the document in the order the Spine file spells it: skins, then each skin's slot keys, then the slot's table. */
+export function fileSpelledEntries(read: ReadDocument): Array<{ skin: string; slot: string; placeholder: string; record: Json }> {
+  const out: Array<{ skin: string; slot: string; placeholder: string; record: Json }> = [];
+  for (const { skin, slots } of skinsInFileOrder(read.doc.skins, fileSkinOrder(read.doc))) {
+    for (const slot of slots) {
+      for (const placeholder of Object.keys(skin.attachments[slot] ?? {})) out.push({ skin: skin.name, slot, placeholder, record: documentRecord(read, skin.name, slot, placeholder) });
+    }
+  }
+  return out;
+}
+
+const WHAT: Readonly<Record<string, string>> = { boundingbox: 'bounding box', clipping: 'clipping attachment', path: 'path' };
+
+export function modelPolygonFacts(read: ReadDocument): PolygonFacts {
+  const polygons: PolygonEntry[] = [];
+  for (const entry of fileOrderedEntries(read)) {
+    const g = entry.record.geometry;
+    if (g === undefined || (g.kind !== 'boundingbox' && g.kind !== 'clipping' && g.kind !== 'path')) continue;
+    const stated = documentRecord(read, entry.skin, entry.slot, entry.placeholder).vertexCount;
+    polygons.push({
+      what: `${WHAT[g.kind]} "${shownRow(entry).name}"`,
+      worldVerticesLength: typeof stated === 'number' ? stated * 2 : Number.NaN,
+      path: g.kind === 'path' ? { closed: g.closed, lengths: g.lengths } : null,
+      encoding: [],
+    });
+  }
+  const clipEnds: ClipEnd[] = [];
+  for (const { slot, placeholder, record } of fileSpelledEntries(read)) {
+    if (record.kind === 'clipping' && record.end !== undefined) clipEnds.push({ placeholder, slot, end: record.end });
+  }
+  return { polygons, clipEnds, slots: read.doc.slots.map((s) => s.name) };
+}