spine-rigc 1.9.0 → 1.9.2

package/src/assertions/model/constraints.ts

@@ -19,10 +19,12 @@
  *   runtime's), and the timelines it carries are the bone and slot timelines
  *   plus the count of every later group the reader counts.
  * - **The timelines**: the animations in the file's order
- *   (`editorAnimationOrder`, the function the emitter is handed); in each the
- *   groups in the runtime's order (`../facts/constraints.ts`' ⭐) and each
- *   group's entries and timelines in the document's order, which the emitter
- *   writes unchanged. A key's time and value are the core's (float32), and a
+ *   (`fileAnimationOrder`, issue #1034: a `rigc-compiled/3` document's
+ *   `editorOrder`, else the emitter's own rule over its names); in each the
+ *   groups in the runtime's order (`../facts/constraints.ts`' ⭐), each
+ *   group's entries in the order the file keys them — the document's, an
+ *   integer-like constraint name first (`keyedOrder`) — and each entry's
+ *   timelines in the document's order, which the emitter writes unchanged. A key's time and value are the core's (float32), and a
  *   Bézier segment's samples `bezierPolyline` over the numbers the document
  *   states — the runtime's curve, as the core reproduces it.
  * - **The reach of a physics timeline naming none** is asked of the core's
@@ -39,7 +41,7 @@
  *
  * Links nothing from the runtime.
  */
-import { editorAnimationOrder } from '../../compile.ts';
+import { fileAnimationOrder, keyedOrder, type OrderedDocument } from '../../compile.ts';
 import { bezierPolyline, type CoreAnimationTimelines, type CoreKey } from '../../core/animation.ts';
 import { TRANSFORM_MIXES, TRANSFORM_PROPERTIES, type CoreConstraintRecord } from '../../core/constraints.ts';
 import { EVERY_GLOBAL_PHYSICS, posedPhysics, type CorePhysicsRecord, type PhysicsTimelineKind } from '../../core/constraints_physics.ts';
@@ -144,39 +146,55 @@ export interface ModelConstraintTimelineSource {
   keys: readonly CoreKey[];
 }
 
+/** How the animations are put in the file's order: `fileAnimationOrder`. A parameter only so the selftest can show what another order would print (`VF11`). */
+export type AnimationFileOrder = (doc: OrderedDocument) => readonly string[];
+
+/**
+ * `entries` in the order the Spine file keys them by name (issue #1034): each
+ * constraint group of an animation is an object the emitter fills in the
+ * model's order, so the names are grouped as they first appear and put
+ * through `keyedOrder` — an integer-like name first — and every entry of one
+ * name keeps its place among them.
+ */
+function inKeyedOrder<T extends { name: string }>(entries: readonly T[]): T[] {
+  const names = entries.map((e) => e.name);
+  return keyedOrder(names.filter((n, i) => names.indexOf(n) === i)).flatMap((name) => entries.filter((e) => e.name === name));
+}
+
 /** Every constraint timeline of the document, in the order the runtime builds them (the header) — the walk `modelConstraintFacts` reads, and the selftest's measurement of each derivation. */
-export function modelConstraintTimelineSources(read: ReadDocument): ModelConstraintTimelineSource[] {
+export function modelConstraintTimelineSources(read: ReadDocument, animations: AnimationFileOrder = fileAnimationOrder): ModelConstraintTimelineSource[] {
   const { doc } = read;
   const jsonAnimations = Array.isArray(read.json.animations) ? read.json.animations.filter(isObj) : [];
   const out: ModelConstraintTimelineSource[] = [];
-  for (const name of editorAnimationOrder(doc.animations.map((a) => a.name))) {
+  for (const name of animations(doc)) {
     const anim = doc.animations.find((a) => a.name === name);
     if (anim === undefined) continue;
     const c = anim.constraints;
-    for (const tl of c.ik) out.push({ animation: name, kind: 'ik', word: 'ik', name: tl.name, keys: tl.keys });
-    for (const tl of c.transform) out.push({ animation: name, kind: 'transform', word: 'transform', name: tl.name, keys: tl.keys });
-    for (const entry of c.path) {
+    for (const tl of inKeyedOrder(c.ik)) out.push({ animation: name, kind: 'ik', word: 'ik', name: tl.name, keys: tl.keys });
+    for (const tl of inKeyedOrder(c.transform)) out.push({ animation: name, kind: 'transform', word: 'transform', name: tl.name, keys: tl.keys });
+    for (const entry of inKeyedOrder(c.path)) {
       for (const word of Object.keys(entry)) {
         if (word === 'position' || word === 'spacing' || word === 'mix') out.push({ animation: name, kind: 'path', word, name: entry.name, keys: entry[word] ?? [] });
       }
     }
-    for (const tl of c.physicsKeyed ?? []) out.push({ animation: name, kind: 'physics', word: tl.kind, name: tl.name, keys: tl.keys });
+    for (const tl of inKeyedOrder(c.physicsKeyed ?? [])) out.push({ animation: name, kind: 'physics', word: tl.kind, name: tl.name, keys: tl.keys });
     // A slider entry's timelines in the order the document lists them, which `readSliderTimelines` keeps by name only.
     const jsonSliders = ((): Json[] => {
       const json = jsonAnimations.find((a) => a.name === name)?.constraints;
       return isObj(json) && Array.isArray(json.slider) ? json.slider.filter(isObj) : [];
     })();
-    c.slider.forEach((entry, i) => {
-      const listed = Array.isArray(jsonSliders[i]?.timelines) ? (jsonSliders[i].timelines as unknown[]).filter(isObj).map((t) => t.name) : [];
+    // Paired with the document's own entry by index before the walk is put in the file's order.
+    const sliders = c.slider.map((entry, i) => ({ name: entry.name, entry, listed: Array.isArray(jsonSliders[i]?.timelines) ? (jsonSliders[i].timelines as unknown[]).filter(isObj).map((t) => t.name) : [] }));
+    for (const { entry, listed } of inKeyedOrder(sliders)) {
       for (const word of listed) {
         if (word === 'time' || word === 'mix') out.push({ animation: name, kind: 'slider', word, name: entry.name, keys: entry[word] ?? [] });
       }
-    });
+    }
   }
   return out;
 }
 
-export function modelConstraintFacts(read: ReadDocument): ConstraintFacts {
+export function modelConstraintFacts(read: ReadDocument, animations: AnimationFileOrder = fileAnimationOrder): ConstraintFacts {
   const { doc } = read;
   const constraints: ConstraintEntry[] = doc.constraints.map((c) => {
     if (c.record === undefined) throw new Error(`internal: ${c.kind} constraint "${c.name}" is one the reader returned without its record`);
@@ -184,7 +202,7 @@ export function modelConstraintFacts(read: ReadDocument): ConstraintFacts {
   });
   const indexOf = (kind: ConstraintKind, name: string): number => doc.constraints.findIndex((c) => c.kind === kind && c.name === name);
   const physicsRecords = doc.constraints.flatMap((c) => (c.record?.kind === 'physics' ? [c.record] : []));
-  const timelines: ConstraintTimeline[] = modelConstraintTimelineSources(read).map(({ animation, kind, word, name, keys }) => {
+  const timelines: ConstraintTimeline[] = modelConstraintTimelineSources(read, animations).map(({ animation, kind, word, name, keys }) => {
     const constraint = name === EVERY_GLOBAL_PHYSICS && kind === 'physics' ? -1 : indexOf(kind, name);
     const reach = constraint >= 0 ? [constraint] : [...unnamedReach(physicsRecords, word as PhysicsTimelineKind)].map((n) => indexOf('physics', n)).sort((a, b) => a - b);
     const rule = kind === 'physics' ? physicsRuleFor(word) : undefined;

package/src/assertions/model/deform_survey.ts

@@ -0,0 +1,24 @@
+/**
+ * The model side's supply of `DeformSurveyFacts` (issue #1025, cut 4c-3 of
+ * step 4c of #380): the survey off the model document alone —
+ * `surveyOfModel` (`src/deformsurvey.ts`), the document's structure read by
+ * `modelStructure` (`src/deformstructure.ts`) and every pose taken by the
+ * core's poser. It is the survey `explain` takes of a build that carries a
+ * model document (`surveyOfBuild`'s model path) and the one
+ * `tools/survey_hashes.ts` holds byte for byte to spine-core's on every corpus
+ * row; called, not restated.
+ *
+ * A pose the core refuses — a construct it leaves out, a value it computes as
+ * no number — is a `CoreInputError` naming why, and it reaches A39 as the
+ * refusal: the line the harness prints for a body that threw, the core's
+ * sentence in it. A survey that is not the runtime's is never handed on.
+ *
+ * Links nothing from the runtime.
+ */
+import { surveyOfModel } from '../../deformsurvey.ts';
+import type { DeformSurveyFacts } from '../facts/deform_survey.ts';
+import type { ReadDocument } from './parse.ts';
+
+export function modelDeformSurvey(read: ReadDocument): DeformSurveyFacts {
+  return { survey: (exempt) => surveyOfModel(read.doc, exempt) };
+}

package/src/assertions/model/event_keys.ts

@@ -0,0 +1,45 @@
+/**
+ * The model side's supply of `EventKeyFacts` (issue #1025, cut 4c-4 of #380):
+ * every event key of the document, with the declaration it fires.
+ *
+ * - **The order is the file's.** The animations by `editorAnimationOrder`
+ *   (`src/compile.ts`, the function the emitter is handed), and an animation's
+ *   keys in the document's order, which is the order `emitAnimation` writes
+ *   the model's list in; an animation with no event key writes no `events`
+ *   group, so it carries no event timeline here either.
+ * - **The moved clause's inputs.** Which of `volume` and `balance` the key
+ *   states — the document's key carries the fields the file's does, and the
+ *   parser-default pass leaves an event key's audio fields alone (its row is
+ *   `time` only) — and whether the declaration names an audio path, the
+ *   `audio` the document's `events` section states for that name.
+ * - **No `kept` finding, ever.** The four clauses that stay with the round
+ *   trip are states `readModel` refuses (`readEventKeys`), so on a document
+ *   this side has read none of them can hold.
+ *
+ * Links nothing from the runtime.
+ */
+import { editorAnimationOrder } from '../../compile.ts';
+import type { EventKeyEntry, EventKeyFacts } from '../facts/event_keys.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) : []);
+
+export function modelEventKeys(read: ReadDocument): EventKeyFacts {
+  const audio = new Map<string, boolean>();
+  for (const def of list(read.json.events)) if (typeof def.name === 'string') audio.set(def.name, typeof def.audio === 'string');
+  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 keys: EventKeyEntry[] = [];
+  let timelines = 0;
+  for (const animation of editorAnimationOrder([...byName.keys()])) {
+    const events = list((byName.get(animation) as Json).events);
+    if (events.length === 0) continue;
+    timelines++;
+    events.forEach((key, index) => {
+      const name = String(key.name);
+      keys.push({ animation, index, kept: [], stopped: false, name, sets: { volume: key.volume !== undefined, balance: key.balance !== undefined }, audio: audio.get(name) ?? false });
+    });
+  }
+  return { parsed: true, animations: true, timelines, keys };
+}

package/src/assertions/model/index.ts

@@ -9,7 +9,11 @@
  * the body inside its own `check`; this entry supplies them from the document
  * (`./parse.ts`, `./skin_entries.ts`, `./atlas_pages.ts`, `./slot_colour.ts`;
  * cut 4c-2's `./mesh_attachments.ts`, `./vertex_polygons.ts`,
- * `./linked_meshes.ts`, `./constraints.ts`)
+ * `./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`; 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.
@@ -88,6 +92,40 @@ import type { MeshFacts } from '../facts/mesh_attachments.ts';
 import type { PolygonFacts } from '../facts/vertex_polygons.ts';
 import type { LinkFacts } from '../facts/linked_meshes.ts';
 import type { ConstraintFacts } from '../facts/constraints.ts';
+import { a12NoDarkColor } from '../bodies/a12.ts';
+import { a24AxisSpaceStroke } from '../bodies/a24.ts';
+import { a25DetachedBoneParentage } from '../bodies/a25.ts';
+import { a26SlotDrawOrder } from '../bodies/a26.ts';
+import { a29StrokeWithinContactDepth } from '../bodies/a29.ts';
+import { a30StrokeWithinCapContainment } from '../bodies/a30.ts';
+import { a32EventKeysResolve } from '../bodies/a32.ts';
+import { modelSkeletonRoster } from './skeleton_roster.ts';
+import { modelBoneTimelines } from './bone_timelines.ts';
+import { modelEventKeys } from './event_keys.ts';
+import type { SkeletonRosterFacts } from '../facts/skeleton_roster.ts';
+import type { BoneTimelineFacts } from '../facts/bone_timelines.ts';
+import type { EventKeyFacts } from '../facts/event_keys.ts';
+import { a39DeformKeepsTriangleWinding } from '../bodies/a39.ts';
+import { a09AnimationDurationMatchesSpec } from '../bodies/a09.ts';
+import { a43TwoColorTintLoadsAndPosesAsWritten } from '../bodies/a43.ts';
+import { a46SequenceAttachmentsShowTheFrameTheFileStates } from '../bodies/a46.ts';
+import { modelDeformSurvey } from './deform_survey.ts';
+import { modelAnimationDurations } from './animation_durations.ts';
+import { modelTwoColour } from './two_colour.ts';
+import { modelSequences } from './sequences.ts';
+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 {
@@ -96,7 +134,7 @@ export interface ModelValidateInput {
   /** The directory the document's page names resolve against — the build's `--out`. */
   atlasDir: string;
   profile: AssertionProfile;
-  /** The rig info the build carries, as `validate()` is handed it — A13, A15, A19 (cut 4c-1) and A20, A21, A28, A41, A47, A48 (cut 4c-2) read it; optional because `ValidateInput.rig` is: absent for a bare directory, on both sides. */
+  /** The rig info the build carries, as `validate()` is handed it — A13, A15, A19 (cut 4c-1) and A20, A21, A28, A41, A47, A48 (cut 4c-2) and A24, A25, A26, A29, A30 (cut 4c-4) read it; optional because `ValidateInput.rig` is: absent for a bare directory, on both sides. */
   rig?: RigInfo;
   /**
    * The stage and the pages' `pma`, for a `rigc-compiled/2` or `/1` document,
@@ -106,6 +144,8 @@ export interface ModelValidateInput {
    * `given` beside it is refused by name.
    */
   given?: ModelGiven;
+  /** The motion spec's declared durations, as `validate()` is handed them — A09 reads them (cut 4c-3); absent where the caller has no motion spec, on both sides. */
+  declaredDurations?: Record<string, number>;
 }
 
 /** The model side's report: `validate()`'s shape, over the moved assertions and the two parse rules. */
@@ -134,6 +174,16 @@ export interface ModelSupply {
   polygons: (read: ReadDocument) => PolygonFacts;
   links: (read: ReadDocument) => LinkFacts;
   constraints: (read: ReadDocument) => ConstraintFacts;
+  skeletonRoster: (read: ReadDocument) => SkeletonRosterFacts;
+  boneTimelines: (read: ReadDocument) => BoneTimelineFacts;
+  eventKeys: (read: ReadDocument) => EventKeyFacts;
+  deformSurvey: (read: ReadDocument) => DeformSurveyFacts;
+  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. */
@@ -151,6 +201,16 @@ export const MODEL_SUPPLY: ModelSupply = {
   polygons: modelPolygonFacts,
   links: modelLinkFacts,
   constraints: modelConstraintFacts,
+  skeletonRoster: modelSkeletonRoster,
+  boneTimelines: modelBoneTimelines,
+  eventKeys: modelEventKeys,
+  deformSurvey: modelDeformSurvey,
+  animationDurations: modelAnimationDurations,
+  twoColour: modelTwoColour,
+  sequences: modelSequences,
+  sliderComposition: modelSliderComposition,
+  constraintTargets: modelConstraintTargets,
+  steppedPoses: modelSteppedPoses,
 };
 
 /**
@@ -169,6 +229,13 @@ export interface MovedAssertion {
    * model side's place for a rule `validate()` runs BEFORE its round trip
    * (A08, issue #589), so that a region miss is named by the rule's own
    * sentence on both sides while the parse beside it refuses the file.
+   *
+   * 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; 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.
    */
   beforeTheParse?: boolean;
 }
@@ -207,6 +274,20 @@ export const MOVED_ASSERTIONS: readonly MovedAssertion[] = [
   { code: 'A19_OVERLAY_PNGS_HAVE_ALPHA', run: (v, read, input, supply) => a19OverlayPngsHaveAlpha(v, supply.atlasRegions(read, input), supply.stage(read, input), supply.skinEntries(read), input), unread: SKIP_NO_ATLAS },
   { code: 'A27_REGION_NAME_MATCHES_PAGE_FILENAME', run: (v, read, input, supply) => a27RegionNameMatchesPageFilename(v, supply.atlasRegions(read, input)), unread: SKIP_NO_ATLAS },
   { code: 'A28_RIBBON_ROWS_SHARE_WEIGHTS', run: (v, read, input, supply) => a28RibbonRowsShareWeights(v, supply.meshes(read), input.rig), unread: SKIP_NO_MODEL },
+  { code: 'A32_EVENT_KEYS_RESOLVE', run: (v, read, _input, supply) => a32EventKeysResolve(v, supply.eventKeys(read)), unread: SKIP_NO_MODEL, beforeTheParse: true },
+  { code: 'A12_NO_DARK_COLOR', run: (v, read, _input, supply) => a12NoDarkColor(v, supply.skeletonRoster(read), supply.slotColour(read).slotTimelines), unread: SKIP_NO_MODEL, beforeTheParse: true },
+  { code: 'A24_AXIS_SPACE_STROKE', run: (v, read, input, supply) => a24AxisSpaceStroke(v, supply.boneTimelines(read), input), unread: SKIP_NO_MODEL, beforeTheParse: true },
+  { code: 'A25_DETACHED_BONE_PARENTAGE', run: (v, read, input, supply) => a25DetachedBoneParentage(v, supply.skeletonRoster(read), input), unread: SKIP_NO_MODEL, beforeTheParse: true },
+  { code: 'A26_SLOT_DRAW_ORDER', run: (v, read, input, supply) => a26SlotDrawOrder(v, supply.skeletonRoster(read), input), unread: SKIP_NO_MODEL, beforeTheParse: true },
+  { code: 'A29_STROKE_WITHIN_CONTACT_DEPTH', run: (v, read, input, supply) => a29StrokeWithinContactDepth(v, supply.boneTimelines(read), input), unread: SKIP_NO_MODEL, beforeTheParse: true },
+  { code: 'A30_STROKE_WITHIN_CAP_CONTAINMENT', run: (v, read, input, supply) => a30StrokeWithinCapContainment(v, supply.boneTimelines(read), input), unread: SKIP_NO_MODEL, beforeTheParse: true },
+  { code: 'A39_DEFORM_KEEPS_TRIANGLE_WINDING', run: (v, read, input, supply) => a39DeformKeepsTriangleWinding(v, supply.deformSurvey(read), input.rig), unread: SKIP_NO_MODEL },
+  { 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/linked_meshes.ts

@@ -1,8 +1,8 @@
 /**
  * The model side's supply of `LinkFacts` (issue #1025, step 4c of #380): the
  * document's `linkedmesh` records, in the order the Spine file spells them —
- * the skins by the emitter's `editorSkinOrder`, each skin's slot keys by its
- * `editorSlotKeyOrder`, each slot's records in table order
+ * the skins and each skin's slot keys in the file's order (`fileSkinOrder`,
+ * issue #1034), each slot's records in table order
  * (`fileSpelledEntries`, `./vertex_polygons.ts`).
  *
  * `encoding` is empty on every link: a link record has no geometry field, so

package/src/assertions/model/mesh_attachments.ts

@@ -6,7 +6,7 @@
  * Every value is the document's, through a function rigc already runs:
  *
  * - **The order** is `fileOrderedEntries` (`./skin_entries.ts`), the skins
- *   put in the file's order by the emitter's `editorSkinOrder`.
+ *   put in the file's order (`fileSkinOrder`, issue #1034).
  * - **A binding's bone** is the index the emitter writes for its name,
  *   `boneIndexOf` over the document's bones (`src/emit_spine.ts`), and its
  *   weight the float32 the runtime stores a vertex array in (`Math.fround`,

package/src/assertions/model/region_joins.ts

@@ -9,9 +9,10 @@
  *   no pages, and the registry skips A08 on it by name rather than reading that
  *   as an atlas that declares no region (`./index.ts`).
  * - **The lookups** walk the document's skins as the file lays them: the skins
- *   by the emitter's `editorSkinOrder`, a skin's slot keys by its
- *   `editorSlotKeyOrder` (both `src/compile.ts`, the functions `emitSkins` is
- *   handed) — NOT the draw order `./skin_entries.ts` walks, because A08 walks the
+ *   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 — NOT the draw order `./skin_entries.ts` walks, because A08 walks the
  *   file's keys and the loaded skins do not — and a slot's records in its
  *   table's order. A record of a kind that resolves a region (`CORE_REGION_KINDS`:
  *   region, mesh, linked mesh) joins under its `name`, else its placeholder,
@@ -21,7 +22,7 @@
  *
  * Links nothing from the runtime.
  */
-import { editorSkinOrder, editorSlotKeyOrder } from '../../compile.ts';
+import { fileSkinOrder, skinsInFileOrder } from '../../compile.ts';
 import { CORE_REGION_KINDS } from '../../core/index.ts';
 import type { SkinTableEntry } from '../../model.ts';
 import type { RegionJoinFacts } from '../facts/region_joins.ts';
@@ -29,19 +30,26 @@ import { attachmentRegionLookups, type AttachmentRegionJoin } from '../region_lo
 import { isObj, type Json } from '../values.ts';
 import type { ReadDocument } from './parse.ts';
 
-/** The joins, with the skins and their slot keys put in order by `skins` and `slotKeys` — the emitter's unless the selftest asks what the document's own order would print. */
-export function modelRegionJoinsWith(
-  read: ReadDocument,
-  skins: <T extends { name: string }>(list: readonly T[]) => T[] = editorSkinOrder,
-  slotKeys: <T>(table: Record<string, T>) => Record<string, T> = editorSlotKeyOrder,
-): RegionJoinFacts {
+/** The skins and each skin's slot keys in an order other than the file's — a parameter only so the selftest can show what that order would print. */
+export type SlotKeyWalk = <T extends Json & { name: string }>(skins: readonly T[]) => Array<{ skin: T; slots: readonly string[] }>;
+
+/**
+ * The joins, with the skins and their slot keys in the file's order — the order
+ * a `rigc-compiled/3` document states, else the emitter's rule
+ * (`fileSkinOrder`, issue #1034) — unless the selftest hands `order`, the
+ * skins and each skin's slot keys in another order, to show what it would
+ * print (`VF09`, `VF11`).
+ */
+export function modelRegionJoinsWith(read: ReadDocument, order?: SlotKeyWalk): RegionJoinFacts {
   const pages = read.doc.pages;
   const regionNames = pages === null ? null : pages.flatMap((page) => page.regions.map((region) => region.name));
   const stated = (Array.isArray(read.json.skins) ? read.json.skins.filter(isObj) : []).filter((skin): skin is Json & { name: string } => typeof skin.name === 'string');
   const joins: AttachmentRegionJoin[] = [];
-  for (const skin of skins(stated)) {
+  const walk = order === undefined ? skinsInFileOrder(stated, fileSkinOrder(read.doc)) : order(stated);
+  for (const { skin, slots } of walk) {
     if (!isObj(skin.attachments)) continue;
-    for (const [slot, table] of Object.entries(slotKeys(skin.attachments))) {
+    for (const slot of slots) {
+      const table = skin.attachments[slot];
       if (!isObj(table)) continue;
       for (const [placeholder, record] of Object.entries(table)) {
         if (!isObj(record) || !CORE_REGION_KINDS.has(record.kind as SkinTableEntry['kind'])) continue;

package/src/assertions/model/sequences.ts

@@ -0,0 +1,157 @@
+/**
+ * The model side's supply of `SequenceFacts` (issue #1025, cut 4c-3 of step
+ * 4c of #380).
+ *
+ * - **The skin entries**, in the file's order: the skins and each skin's slot
+ *   keys as `fileSkinOrder` gives them (`src/compile.ts`, issue #1034 — a
+ *   `rigc-compiled/3` document's stated `editorOrder`, else the emitter's
+ *   rule; the walk `./region_joins.ts` makes for A08, which walks the same
+ *   keys), and a slot's records in its table's order. A record of a kind that draws a
+ *   region (`CORE_REGION_KINDS`) is an entry; its `name` and `path` are the
+ *   record's own, which the emitter writes unchanged, and its `sequence` is
+ *   spelled as the file spells it — written by the emitter's own
+ *   `emitSequenceBlock` (the document's block also carries each frame's atlas
+ *   rectangle, which the file does not) and passed through
+ *   `withoutParserDefaults`, which leaves out `start: 1` and `setup: 0`. A
+ *   document the reader and the region rule accepted loads every record, so
+ *   every entry is `loaded`.
+ * - **The sequence timelines**: the animations in `fileAnimationOrder`'s order,
+ *   and each animation's `attachments` group at its three levels (skin, slot,
+ *   attachment) in the order the file keys them — `keyedOrder` over the
+ *   document's order, which is the model's, as `src/deformstructure.ts` walks
+ *   the same group (issue #1034) — passed through
+ *   `withoutParserDefaults` and `inEditorKeyOrder` (`src/keyorder.ts`), so a
+ *   key's `delay` the parser would read off the key before it is left out
+ *   here exactly where the file leaves it out, and A46 prints what it prints
+ *   over the file.
+ * - **A slot at a pose**: 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`) — A45's posed colour
+ *   and A43's posed tint are taken the same way. The entry the slot shows is
+ *   the pose's shown record; the entry whose timelines it plays is the core's
+ *   own rule for a linked mesh that plays its source's (`timelineIdentity`,
+ *   whose condition is the record's `timelines`); and the region its series resolves to is `drawnRegions`
+ *   (`src/core/uvs.ts`), which refuses by name the one case whose reading was
+ *   not measured — a linked mesh with a series of its own, stepped over its
+ *   source's frame count. No gate samples the times A46 asks for (mid-frame,
+ *   and each `hold` 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 { fileAnimationOrder, fileSkinOrder, keyedOrder, skinsInFileOrder } from '../../compile.ts';
+import { CORE_REGION_KINDS, CoreInputError, type CompiledDocument } from '../../core/index.ts';
+import { poseRawAnimation } from '../../core/raw.ts';
+import { documentPageLookup, drawnRegions, readUvSequences } from '../../core/uvs.ts';
+import { inEditorKeyOrder, withoutParserDefaults } from '../../keyorder.ts';
+import { emitSequenceBlock } from '../../emit_spine.ts';
+import type { ModelSequence, SkinTableEntry } from '../../model.ts';
+import { noSkinView } from '../../render_core.ts';
+import { entryAddress, type SequenceFacts, type SequenceSkinEntry, type SequenceTimeline } from '../facts/sequences.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) : []);
+
+/** The skin entries that draw a region, in the file's order, each `sequence` spelled as the file spells it. */
+function fileEntries(read: ReadDocument): SequenceSkinEntry[] {
+  const stated = list(read.json.skins).filter((skin): skin is Json & { name: string } => typeof skin.name === 'string');
+  const picked: Array<{ skin: string; slot: string; placeholder: string; record: Json }> = [];
+  const shell: Json[] = [];
+  for (const { skin, slots } of skinsInFileOrder(stated, fileSkinOrder(read.doc))) {
+    if (!isObj(skin.attachments)) continue;
+    const attachments: Json = {};
+    for (const slot of slots) {
+      const table = skin.attachments[slot];
+      if (!isObj(table)) continue;
+      const placeholders: Json = {};
+      for (const [placeholder, record] of Object.entries(table)) {
+        if (!isObj(record) || !CORE_REGION_KINDS.has(record.kind as SkinTableEntry['kind'])) continue;
+        picked.push({ skin: skin.name, slot, placeholder, record });
+        // Only what the omission pass reads to spell the series: the attachment's type, then the block as the emitter writes it
+        // (`emitSequenceBlock`: the four fields the file carries, never the document's per-frame `atlas`, in a fresh object — the pass edits in place).
+        placeholders[placeholder] = { ...(record.kind === 'region' ? {} : { type: record.kind }), ...(isObj(record.sequence) ? { sequence: emitSequenceBlock(record.sequence as unknown as ModelSequence) } : {}) };
+      }
+      attachments[slot] = placeholders;
+    }
+    shell.push({ name: skin.name, attachments });
+  }
+  withoutParserDefaults({ skins: shell });
+  return picked.map(({ skin, slot, placeholder, record }) => {
+    const spelled = (((shell.find((s) => s.name === skin) as Json).attachments as Json)[slot] as Json)[placeholder] as Json;
+    return { skin, slot, placeholder, name: record.name, path: record.path, sequence: spelled.sequence, loaded: true };
+  });
+}
+
+/** 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));
+
+/** Every animation's sequence timelines in the file's order and spelling: `animations.<name>.attachments.<skin>.<slot>.<placeholder>.sequence = keys`. */
+function fileSequenceTimelines(read: ReadDocument): SequenceTimeline[] {
+  const byName = new Map<string, Json>();
+  for (const anim of list(read.json.animations)) if (typeof anim.name === 'string') byName.set(anim.name, anim);
+  type Level = { name: string; json: Json };
+  const named = (v: unknown): Level[] => list(v).flatMap((json) => (typeof json.name === 'string' ? [{ name: json.name, json }] : []));
+  /** One level of the group in the order the file keys it: `keyedOrder` over the document's order, each name's entries together. */
+  const inFileOrder = (levels: Level[]): Array<[string, Json[]]> => keyedFirsts(levels.map((l) => l.name)).map((name) => [name, levels.filter((l) => l.name === name).map((l) => l.json)]);
+  const order = fileAnimationOrder(read.doc);
+  const walk: Array<{ animation: string; skin: string; slot: string; placeholder: string }> = [];
+  const animations: Json = {};
+  for (const name of order) {
+    const anim = byName.get(name);
+    if (anim === undefined) continue;
+    const bySkin: Json = {};
+    for (const [skin, skinEntries] of inFileOrder(named(anim.attachments))) {
+      const bySlot: Json = {};
+      for (const [slot, slotEntries] of inFileOrder(skinEntries.flatMap((e) => named(e.slots)))) {
+        const byAttachment: Json = {};
+        for (const [placeholder, attachments] of inFileOrder(slotEntries.flatMap((e) => named(e.attachments)))) {
+          const timelines: Json = {};
+          // `deform` then `sequence`, each only where the document holds it — `emitAttachmentTimelines`' order.
+          for (const attachment of attachments) {
+            for (const word of ['deform', 'sequence'] as const) if (Array.isArray(attachment[word])) timelines[word] = list(attachment[word]).map((key) => ({ ...key }));
+          }
+          byAttachment[placeholder] = timelines;
+          if (Array.isArray(timelines.sequence)) walk.push({ animation: name, skin, slot, placeholder });
+        }
+        bySlot[slot] = byAttachment;
+      }
+      bySkin[skin] = bySlot;
+    }
+    animations[name] = Object.keys(bySkin).length > 0 ? { attachments: bySkin } : {};
+  }
+  // The emitter's own passes over the keys (`withoutParserDefaults`, `inEditorKeyOrder`), then the walk read back in the order built above.
+  const file = inEditorKeyOrder(withoutParserDefaults({ animations }));
+  return walk.map(({ animation, skin, slot, placeholder }) => {
+    const timelines = ((((file.animations[animation] as Json).attachments as Json)[skin] as Json)[slot] as Json)[placeholder] as Json;
+    return { animation, skin, slot, placeholder, keys: timelines.sequence as unknown[] };
+  });
+}
+
+export function modelSequences(read: ReadDocument): SequenceFacts {
+  let view: CompiledDocument | null = null;
+  return {
+    entries: fileEntries(read),
+    timelines: fileSequenceTimelines(read),
+    hasSlot: (slot) => read.doc.slots.some((s) => s.name === slot),
+    duration: (animation) => read.doc.animations.find((a) => a.name === animation)?.timelines.duration ?? null,
+    posedFrame: (animation, slot, time) => {
+      view ??= noSkinView(read.doc);
+      const pose = poseRawAnimation(view, animation, [time], {}, 'animation')[1];
+      const shown = pose.shown.find((s) => s.slot === slot);
+      if (shown === undefined) return null;
+      const at = entryAddress(shown.skin, slot, shown.placeholder);
+      const g = shown.geometry;
+      const record = view.skins.find((k) => k.name === shown.skin)?.attachments[slot]?.[shown.placeholder];
+      // A linked mesh that plays its source's timelines plays them as its source (`timelineIdentity` in `src/core/deform.ts`, the
+      // runtime's `timelineAttachment`); every other entry plays its own.
+      const playsAs = g.kind === 'linkedmesh' && record?.timelines === true ? entryAddress(g.skin, g.slot, g.source) : at;
+      if (g.kind !== 'region' && g.kind !== 'mesh' && g.kind !== 'linkedmesh') return { shown: at, playsAs, region: null };
+      if (read.doc.pages === null) throw new CoreInputError('the document states no pages, so no region a series resolves to can be named');
+      const resolved = drawnRegions(view, pose.shown, [slot], { sequences: readUvSequences(read.json), lookup: documentPageLookup(read.doc.pages) });
+      if (resolved.drawn === null) throw new CoreInputError(`the core does not name the region slot "${slot}" shows at t=${time}: ${resolved.why}`);
+      return { shown: at, playsAs, region: resolved.drawn[0]?.region ?? null };
+    },
+  };
+}

package/src/assertions/model/skeleton_roster.ts

@@ -0,0 +1,23 @@
+/**
+ * The model side's supply of `SkeletonRosterFacts` (issue #1025, cut 4c-4 of
+ * #380): the document's bones and slots, in the document's order.
+ *
+ * The emitter writes the file's `bones` and `slots` arrays in the model's
+ * order and never re-sorts them (`emitBones`, `emitSlots` in
+ * `src/emit_spine.ts`; a slot's order is the draw order a draw-order key's
+ * offsets count in), and the document writes each list in that same order, so
+ * the document's lists are the file's. A bone's parent is the name the
+ * document states, `null` for a root; a slot declares a dark colour where the
+ * document states one, which is where `emitSlots` writes the key.
+ *
+ * Links nothing from the runtime.
+ */
+import type { SkeletonRosterFacts } from '../facts/skeleton_roster.ts';
+import type { ReadDocument } from './parse.ts';
+
+export function modelSkeletonRoster(read: ReadDocument): SkeletonRosterFacts {
+  return {
+    bones: read.doc.bones.map((bone) => ({ name: bone.name, parent: bone.parent ?? null })),
+    slots: read.doc.slots.map((slot) => ({ name: slot.name, dark: slot.dark !== undefined })),
+  };
+}

package/src/assertions/model/skin_entries.ts

@@ -8,8 +8,9 @@
  * document in its own order lists the same entries in another order on a rig
  * whose skins the comparator moves — the census measured that on 3 of 52
  * multi-skin compiles. The skins are therefore put in the file's order by
- * calling `editorSkinOrder` from `src/compile.ts`, the function the emitter is
- * handed (`emitSkins`), not by a copy of its rule. Within a skin the entries go
+ * `fileSkinOrder` from `src/compile.ts` (issue #1034): the order a
+ * `rigc-compiled/3` document states, else `editorSkinOrder`, the function the
+ * emitter is handed (`emitSkins`) — never a copy of its rule. Within a skin the entries go
  * slot by slot in the skeleton's slot order — the document's `slots`, which is
  * the emitted array's order — and a slot's entries in its table's order, which
  * the emitter writes unchanged; the selftest measures this walk equal to
@@ -22,18 +23,27 @@
  *
  * Links nothing from the runtime.
  */
-import { editorSkinOrder } from '../../compile.ts';
+import { fileSkinOrder, skinsInFileOrder } from '../../compile.ts';
 import { shownRow } from '../../core/index.ts';
 import type { RegionEntry, SkinEntryFacts } from '../facts/skin_entries.ts';
 import type { ReadDocument } from './parse.ts';
 
-/** How the skins are put in the file's order: the emitter's rule. A parameter only so the selftest can show what the document's own order would print (`VF05`). */
+/** How the skins are put in an order other than the file's. A parameter only so the selftest can show what the document's own order would print (`VF05`). */
 export type SkinOrder = <T extends { name: string }>(skins: readonly T[]) => T[];
 
-/** The skins' entries in the file's walk order, each with its skin, slot and placeholder. */
-export function fileOrderedEntries(read: ReadDocument, order: SkinOrder = editorSkinOrder): Array<{ skin: string; slot: string; placeholder: string; record: ReadDocument['doc']['skins'][number]['attachments'][string][string] }> {
+/**
+ * The document's skins in the file's order (issue #1034): `fileSkinOrder` —
+ * a `rigc-compiled/3` document's `editorOrder`, the one source on `/3`, else
+ * the emitter's own rule (`editorSkinOrder`) over the document's skins.
+ */
+export function skinsInTheFilesOrder<T extends { name: string }>(read: ReadDocument, skins: readonly T[]): T[] {
+  return skinsInFileOrder(skins, fileSkinOrder(read.doc)).map((walk) => walk.skin);
+}
+
+/** The skins' entries in the file's walk order, each with its skin, slot and placeholder; `order`, when given, replaces the file's skin order (`VF05`). */
+export function fileOrderedEntries(read: ReadDocument, order?: SkinOrder): Array<{ skin: string; slot: string; placeholder: string; record: ReadDocument['doc']['skins'][number]['attachments'][string][string] }> {
   const out: ReturnType<typeof fileOrderedEntries> = [];
-  for (const skin of order(read.doc.skins)) {
+  for (const skin of order === undefined ? skinsInTheFilesOrder(read, read.doc.skins) : order(read.doc.skins)) {
     for (const { name: slot } of read.doc.slots) {
       const table = skin.attachments[slot];
       if (table === undefined) continue;
@@ -43,7 +53,7 @@ export function fileOrderedEntries(read: ReadDocument, order: SkinOrder = editor
   return out;
 }
 
-export function modelSkinEntries(read: ReadDocument, order: SkinOrder = editorSkinOrder): SkinEntryFacts {
+export function modelSkinEntries(read: ReadDocument, order?: SkinOrder): SkinEntryFacts {
   const regionAttachments: RegionEntry[] = [];
   let clippingCount = 0;
   for (const entry of fileOrderedEntries(read, order)) {