rig-c 0.0.0-stage → 2.20.4

package/src/assertions/model/parse.ts

@@ -0,0 +1,146 @@
+/**
+ * The model side's parse (issue #1025, step 4c of #380): what stands where
+ * `A00_ROUNDTRIP_PARSE` stands when there is no spine-core object to load.
+ *
+ * Two rules, each a named line:
+ *
+ * - **`A00_MODEL_READ`** — `readModel` (`src/core/index.ts`) read the document.
+ *   Its refusals are the parse: every one names the path of what it refused,
+ *   and the line carries the reader's own sentence. A document it refuses is
+ *   one whose wrongness has no readable model to live in — a size that is
+ *   absent, a colour that is not hex, key times that do not increase (the
+ *   census found four of the slice's mutants there) — and that refusal is the
+ *   model side's verdict on it.
+ * - **`A00_MODEL_REGIONS_ON_PAGES`** — every region a record resolves through
+ *   is a region of the document's `pages`, and no region record states an
+ *   `atlas` of `null`. Measured by the census before this rule existed: 23
+ *   cases fail `A00_ROUNDTRIP_PARSE` in a selftest run, and 14 of them are
+ *   documents `readModel` accepts — a record's path naming no region (five
+ *   forged), and nine builds whose model holds `atlas: null` because the build
+ *   had no art or its pack lacked the region. spine-core refuses all fourteen
+ *   at load (`Region not found in atlas`), and the core refused them only when
+ *   it posed. This rule refuses them where the parse does, by the record's
+ *   address and the region's name.
+ *
+ * The region a record resolves through is the core's rule, called rather than
+ * restated: its name and path are `shownRow`'s (path, else name, else the
+ * placeholder), a series' frame names are `frameRegionName` over the series
+ * `readUvSequences` reads, and a name is looked up as `documentPageLookup`
+ * looks it up — the first region of that exact spelling, pages in order.
+ *
+ * ⛔ Rejected: the codes `M00_…` (`M` plus two digits names a mutant row in the
+ * selftest — `M03`, `M12` — and a reader of a report could not tell a rule
+ * from a plant), and a new assertion number (`A50`): the gate's registry would
+ * then demand the row of every `validate()` report, and these two rules have no
+ * meaning there. `A00_` because they stand in A00's place, and `_MODEL_`
+ * because they are the model side's.
+ *
+ * Links nothing from the runtime.
+ */
+import { CORE_REGION_KINDS, CoreInputError, readModel, shownRow, type CompiledDocument } from '../../core/index.ts';
+import { documentPageLookup, frameRegionName, readUvSequences } from '../../core/uvs.ts';
+import type { AssertionKind } from '../kinds.ts';
+import { rigSectionProblems } from './declared.ts';
+import type { Verdicts } from '../harness.ts';
+
+/** The reader's refusal, as a line. */
+export const A00_MODEL_READ = 'A00_MODEL_READ';
+/** The region rule, as a line. */
+export const A00_MODEL_REGIONS_ON_PAGES = 'A00_MODEL_REGIONS_ON_PAGES';
+
+/** The two rules' kinds: both are validity — a document either is one a build could pose, or it is not. */
+export const MODEL_PARSE_KIND: Readonly<Record<string, AssertionKind>> = {
+  [A00_MODEL_READ]: 'validity',
+  [A00_MODEL_REGIONS_ON_PAGES]: 'validity',
+};
+
+/** What the region rule SKIPs with when the reader refused the document. */
+export const SKIP_NO_MODEL_DOCUMENT = `the reader refused the document, so there is no record to resolve (${A00_MODEL_READ} owns that failure)`;
+/** What A08 SKIPs with on the model side over a `rigc-compiled/1` document, which states no pages to read region names off (issue #1025, cut 4c-1). */
+export const SKIP_NO_MODEL_PAGES = 'the document is a rigc-compiled/1 document, which states no pages, so there are no region names to join against';
+/** What the region rule SKIPs with when no record resolves through a region. */
+export const SKIP_NO_REGION_RECORD = 'no record of the document resolves through an atlas region';
+
+/** The document as both readings hold it: `readModel`'s, and the JSON the suppliers read spellings from. */
+export interface ReadDocument {
+  doc: CompiledDocument;
+  json: Record<string, unknown>;
+}
+
+/** `A00_MODEL_READ`'s body: the document read, or the reader's refusal as a FAIL. Returns the read document or null. */
+export function modelRead({ fail }: Verdicts, modelText: string): ReadDocument | null {
+  let doc: CompiledDocument;
+  try {
+    doc = readModel(modelText);
+  } catch (err) {
+    if (!(err instanceof CoreInputError)) throw err;
+    fail(A00_MODEL_READ, err.message);
+    return null;
+  }
+  const json = JSON.parse(modelText) as Record<string, unknown>;
+  // Issue #1054: the rig section is a source the model side reads (`./declared.ts`), so it is read here with the rest — refused by its paths, never cast.
+  const rigProblems = rigSectionProblems(json);
+  if (rigProblems.length > 0) {
+    fail(A00_MODEL_READ, `the model document: ${rigProblems.length} problem(s) in the rig section the model side reads its declarations from: ${rigProblems.join('; ')}`);
+    return null;
+  }
+  return { doc, json };
+}
+
+/**
+ * Every region name each record resolves through, by the record's address —
+ * the census's rule R-region, read with the core's own lookups. A record of a
+ * kind that draws no region (clipping, path, bounding box) resolves through
+ * none.
+ */
+export function regionNamesOf(read: ReadDocument): Array<{ where: string; names: string[]; atlasNull: boolean }> {
+  const sequences = readUvSequences(read.json);
+  const out: Array<{ where: string; names: string[]; atlasNull: boolean }> = [];
+  for (const skin of read.doc.skins) {
+    for (const [slot, table] of Object.entries(skin.attachments)) {
+      for (const [placeholder, record] of Object.entries(table)) {
+        if (!CORE_REGION_KINDS.has(record.kind)) continue;
+        const path = shownRow({ skin: skin.name, placeholder, record }).path as string;
+        const series = sequences.get(`${skin.name}/${slot}/${placeholder}`);
+        const names = series === undefined ? [path] : Array.from({ length: series.count }, (_, i) => frameRegionName(path, series, i));
+        out.push({ where: `skin "${skin.name}" slot "${slot}" placeholder "${placeholder}"`, names, atlasNull: record.kind === 'region' && record.atlas === null });
+      }
+    }
+  }
+  return out;
+}
+
+/** `A00_MODEL_REGIONS_ON_PAGES`'s body. Returns whether the document passed it. */
+export function modelRegionsOnPages({ fail, skip }: Verdicts, read: ReadDocument): boolean {
+  let records: ReturnType<typeof regionNamesOf>;
+  try {
+    records = regionNamesOf(read);
+  } catch (err) {
+    // A series `readModel` keeps only the count of: `readUvSequences` refuses its `start` or `digits` by path.
+    if (!(err instanceof CoreInputError)) throw err;
+    fail(A00_MODEL_REGIONS_ON_PAGES, err.message);
+    return false;
+  }
+  if (records.length === 0) {
+    skip(A00_MODEL_REGIONS_ON_PAGES, SKIP_NO_REGION_RECORD);
+    return true;
+  }
+  if (read.doc.pages === null) {
+    fail(A00_MODEL_REGIONS_ON_PAGES, `the document is ${read.doc.spec}, which states no pages, so none of the ${records.length} record(s) that resolve through a region can be found on one`);
+    return false;
+  }
+  const lookup = documentPageLookup(read.doc.pages);
+  let held = true;
+  for (const { where, names, atlasNull } of records) {
+    if (atlasNull) {
+      fail(A00_MODEL_REGIONS_ON_PAGES, `${where}: the region record's atlas is null — the build had no rectangle for "${names[0]}", and a runtime loading it finds no region`);
+      held = false;
+    }
+    for (const name of names) {
+      if (lookup(name) !== null) continue;
+      fail(A00_MODEL_REGIONS_ON_PAGES, `${where}: resolves through the region ${JSON.stringify(name)}, which no page of the document holds`);
+      held = false;
+    }
+  }
+  return held;
+}

package/src/assertions/model/region_joins.ts

@@ -0,0 +1,67 @@
+/**
+ * The model side's supply of `RegionJoinFacts` (issue #1025, step 4c of
+ * #380): the document's region names and every lookup a skin record makes.
+ *
+ * - **The region names** are the document's `pages` regions, page by page in
+ *   order — `pagesOfAtlas` writes them from the atlas text `build` wrote, by the
+ *   reader `PKR01` holds to spine-core's, so they are the atlas's regions in its
+ *   order, each name as the atlas spells it. A `rigc-compiled/1` document states
+ *   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
+ *   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,
+ *   through its `path`, else that name; a `sequence` makes the lookups
+ *   `attachmentRegionLookups` makes of the Spine file's, called on the
+ *   document's own sequence record.
+ *
+ * Links nothing from the runtime.
+ */
+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';
+import { attachmentRegionLookups, type AttachmentRegionJoin } from '../region_lookups.ts';
+import { isObj, type Json } from '../values.ts';
+import type { ReadDocument } from './parse.ts';
+
+/** 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[] = [];
+  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 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;
+        const name = typeof record.name === 'string' ? record.name : placeholder;
+        const path = typeof record.path === 'string' ? record.path : name;
+        joins.push({ skin: skin.name, slot, placeholder, name, lookups: attachmentRegionLookups(record.sequence, path) });
+      }
+    }
+  }
+  return { regionNames, joins };
+}
+
+export function modelRegionJoins(read: ReadDocument): RegionJoinFacts {
+  return modelRegionJoinsWith(read);
+}

package/src/assertions/model/runtime_timelines.ts

@@ -0,0 +1,78 @@
+/**
+ * The runtime's words for each timeline a document's animation can hold
+ * (issue #1054): the class it loads as, the property ids it registers and what
+ * those ids carry — the values A40's sentence prints, which the document has no
+ * field for and the core has no reason to know.
+ *
+ * ⭐ **Why they live here and not beside the core's table.** Until issue #1054
+ * this table stood in `src/core/additive.ts`, beside the mode each kind's
+ * application has: 34 runtime class names and their property names as string
+ * literals in a module that otherwise speaks the document's words (#1011's
+ * second ask). The mode is the core's — it decides what the probe computes —
+ * and stays there, keyed by the document's own words (`ADDITIVE_MODE`); what
+ * the runtime calls the timeline is a fact about the validator's other
+ * supplier, and sits here with the constraint classes' names
+ * (`RUNTIME_CONSTRAINT_CLASS`, `./constraints.ts`). Both tables are keyed by
+ * the same spelling (`additiveSpelling`), and the selftest's `CO27` holds
+ * every row of both against the timeline objects spine-core loads, over a
+ * seeded population reaching every spelling.
+ *
+ * Read off the loaded timeline objects, never written from the runtime's
+ * source: the class is the object's constructor name, the properties its
+ * registered ids' names.
+ *
+ * Links nothing from the runtime.
+ */
+
+/** What a timeline's property ids are followed by: its target's index (and, for an attachment's, the attachment), or nothing. */
+export type RuntimeTimelineAddress = 'bone' | 'slot' | 'attachment' | 'constraint' | 'none';
+
+/** One timeline spelling, as the runtime loads it: its class, the properties it registers in order, and what its ids carry. */
+export interface RuntimeTimelineRow {
+  runtimeClass: string;
+  properties: readonly string[];
+  address: RuntimeTimelineAddress;
+}
+
+const row = (runtimeClass: string, properties: readonly string[], address: RuntimeTimelineAddress): RuntimeTimelineRow => ({ runtimeClass, properties, address });
+
+/** Every timeline spelling a document's animation can hold (`additiveSpelling`'s keys), as the runtime loads it. */
+export const RUNTIME_TIMELINE: Readonly<Record<string, RuntimeTimelineRow>> = {
+  'bone rotate': row('RotateTimeline', ['rotate'], 'bone'),
+  'bone translate': row('TranslateTimeline', ['x', 'y'], 'bone'),
+  'bone translatex': row('TranslateXTimeline', ['x'], 'bone'),
+  'bone translatey': row('TranslateYTimeline', ['y'], 'bone'),
+  'bone scale': row('ScaleTimeline', ['scaleX', 'scaleY'], 'bone'),
+  'bone scalex': row('ScaleXTimeline', ['scaleX'], 'bone'),
+  'bone scaley': row('ScaleYTimeline', ['scaleY'], 'bone'),
+  'bone shear': row('ShearTimeline', ['shearX', 'shearY'], 'bone'),
+  'bone shearx': row('ShearXTimeline', ['shearX'], 'bone'),
+  'bone sheary': row('ShearYTimeline', ['shearY'], 'bone'),
+  'bone inherit': row('InheritTimeline', ['inherit'], 'bone'),
+  'slot attachment': row('AttachmentTimeline', ['attachment'], 'slot'),
+  'slot rgba': row('RGBATimeline', ['rgb', 'alpha'], 'slot'),
+  'slot rgb': row('RGBTimeline', ['rgb'], 'slot'),
+  'slot alpha': row('AlphaTimeline', ['alpha'], 'slot'),
+  'slot rgba2': row('RGBA2Timeline', ['rgb', 'alpha', 'rgb2'], 'slot'),
+  'slot rgb2': row('RGB2Timeline', ['rgb', 'rgb2'], 'slot'),
+  'attachment deform': row('DeformTimeline', ['deform'], 'attachment'),
+  'attachment sequence': row('SequenceTimeline', ['sequence'], 'attachment'),
+  ik: row('IkConstraintTimeline', ['ikConstraint'], 'constraint'),
+  transform: row('TransformConstraintTimeline', ['transformConstraint'], 'constraint'),
+  'path position': row('PathConstraintPositionTimeline', ['pathConstraintPosition'], 'constraint'),
+  'path spacing': row('PathConstraintSpacingTimeline', ['pathConstraintSpacing'], 'constraint'),
+  'path mix': row('PathConstraintMixTimeline', ['pathConstraintMix'], 'constraint'),
+  'physics inertia': row('PhysicsConstraintInertiaTimeline', ['physicsConstraintInertia'], 'constraint'),
+  'physics strength': row('PhysicsConstraintStrengthTimeline', ['physicsConstraintStrength'], 'constraint'),
+  'physics damping': row('PhysicsConstraintDampingTimeline', ['physicsConstraintDamping'], 'constraint'),
+  'physics mass': row('PhysicsConstraintMassTimeline', ['physicsConstraintMass'], 'constraint'),
+  'physics wind': row('PhysicsConstraintWindTimeline', ['physicsConstraintWind'], 'constraint'),
+  'physics gravity': row('PhysicsConstraintGravityTimeline', ['physicsConstraintGravity'], 'constraint'),
+  'physics mix': row('PhysicsConstraintMixTimeline', ['physicsConstraintMix'], 'constraint'),
+  // A reset registers its property with no constraint index, named or not (measured: both read `physicsConstraintReset`).
+  'physics reset': row('PhysicsConstraintResetTimeline', ['physicsConstraintReset'], 'none'),
+  'slider time': row('SliderTimeline', ['sliderTime'], 'constraint'),
+  'slider mix': row('SliderMixTimeline', ['sliderMix'], 'constraint'),
+  drawOrder: row('DrawOrderTimeline', ['drawOrder'], 'none'),
+  events: row('EventTimeline', ['event'], 'none'),
+};

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

@@ -0,0 +1,69 @@
+/**
+ * The model side's supply of `SkinEntryFacts` (issue #1025, step 4c of #380):
+ * the skins' region attachments and clipping count, read off the document.
+ *
+ * ⭐ **In the file's order, by the emitter's own rule.** The document holds the
+ * skins in the spec's order and the Spine file holds them in the editor's
+ * (`default` first, the rest by the editor's comparator), so a walk of the
+ * 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
+ * `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
+ * spine-core's on every multi-skin build it makes.
+ *
+ * A region's name is the record's `name`, else its placeholder — `shownRow`'s
+ * rule in the core — and its size the record's `width` and `height`, the
+ * numbers the file states (`readModel` refuses a size that is not a finite
+ * number, so a size the runtime would load as NaN has no document to arrive in).
+ *
+ * Links nothing from the runtime.
+ */
+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 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 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 === 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;
+      for (const [placeholder, record] of Object.entries(table)) out.push({ skin: skin.name, slot, placeholder, record });
+    }
+  }
+  return out;
+}
+
+export function modelSkinEntries(read: ReadDocument, order?: SkinOrder): SkinEntryFacts {
+  const regionAttachments: RegionEntry[] = [];
+  let clippingCount = 0;
+  for (const entry of fileOrderedEntries(read, order)) {
+    if (entry.record.kind === 'clipping') clippingCount++;
+    if (entry.record.kind !== 'region') continue;
+    const geometry = entry.record.geometry;
+    // `readModel` reads every region record's geometry or refuses the document, so a record without one is this module's defect.
+    if (geometry?.kind !== 'region') throw new Error(`internal: skin "${entry.skin}" slot "${entry.slot}" placeholder "${entry.placeholder}" is a region record the reader returned without its geometry`);
+    const shown = shownRow(entry);
+    regionAttachments.push({ name: shown.name, width: geometry.region.width, height: geometry.region.height, path: shown.path as string });
+  }
+  return { regionAttachments, clippingCount };
+}

package/src/assertions/model/skin_members.ts

@@ -0,0 +1,64 @@
+/**
+ * The model side's supply of `SkinMemberFacts` (issue #1025, step 4c of
+ * #380): the bones, the constraints and each skin's lists, read off the
+ * document and joined the way the runtime's loader joins them.
+ *
+ * - **Bones**: the document's `bones` in order, each with its `skinRequired`
+ *   as stated (absent is not required) and its parent entry.
+ * - **Constraints**: the document's `constraints` in order — update order, the
+ *   order the emitter writes them in — each skin-required exactly when it
+ *   states `skin: true`, the field the emitter writes through unchanged.
+ * - **Skins**: in the file's order (`fileSkinOrder`, `src/compile.ts`: a
+ *   `rigc-compiled/3` document's `editorOrder`, else the emitter's
+ *   `editorSkinOrder`, issue #1034); a
+ *   skin's bones as it lists them, each the FIRST bone of that name; its
+ *   constraints kind by kind in the emitter's key order
+ *   (`RIG_SKIN_CONSTRAINT_KEYS`, which `emitSkins` walks), each the first
+ *   constraint of that kind and name — the object the loader finds, and the
+ *   same object `constraints` holds, so a body asking whether one is listed
+ *   asks by identity. `readModel` refuses a skin listing a constraint of a
+ *   kind and name the document lacks; a bone name it lacks is this module's to
+ *   refuse, by name.
+ *
+ * Links nothing from the runtime.
+ */
+import { fileSkinOrder, skinsInFileOrder } from '../../compile.ts';
+import { RIG_SKIN_CONSTRAINT_KEYS } from '../../rig.ts';
+import type { MemberBone, MemberConstraint, MemberSkin, SkinMemberFacts } from '../facts/skin_members.ts';
+import { isObj } from '../values.ts';
+import type { ReadDocument } from './parse.ts';
+
+export function modelSkinMembers(read: ReadDocument): SkinMemberFacts {
+  const doc = read.doc;
+  const bones: MemberBone[] = [];
+  const boneByName = new Map<string, MemberBone>();
+  for (const bone of doc.bones) {
+    const parent = bone.parent === undefined ? null : boneByName.get(bone.parent);
+    if (parent === undefined) throw new Error(`internal: bone "${bone.name}" names parent "${bone.parent}", which the reader accepted and no earlier bone is`);
+    const entry: MemberBone = { name: bone.name, skinRequired: bone.skinRequired === true, parent };
+    bones.push(entry);
+    if (!boneByName.has(bone.name)) boneByName.set(bone.name, entry);
+  }
+  const constraints: Array<MemberConstraint & { kind: string }> = [];
+  const stated = Array.isArray(read.json.constraints) ? read.json.constraints.filter(isObj) : [];
+  for (const constraint of stated) {
+    constraints.push({ name: String(constraint.name), kind: String(constraint.kind), skinRequired: constraint.skin === true });
+  }
+  const skins: MemberSkin[] = skinsInFileOrder(doc.skins, fileSkinOrder(doc)).map(({ skin }) => {
+    const listedBones = skin.bones.map((name) => {
+      const found = boneByName.get(name);
+      if (found === undefined) throw new Error(`skin "${skin.name}" lists bone "${name}", which is not a bone of the document`);
+      return found;
+    });
+    const listedConstraints: MemberConstraint[] = [];
+    for (const kind of RIG_SKIN_CONSTRAINT_KEYS) {
+      for (const name of skin.constraints[kind]) {
+        const found = constraints.find((c) => c.kind === kind && c.name === name);
+        if (found === undefined) throw new Error(`internal: skin "${skin.name}" lists ${kind} constraint "${name}", which the reader accepted and the document does not hold`);
+        listedConstraints.push(found);
+      }
+    }
+    return { name: skin.name, bones: listedBones, constraints: listedConstraints };
+  });
+  return { skins, bones, constraints };
+}