spine-rigc 1.7.0 → 1.9.0

package/src/assertions/model/index.ts

@@ -0,0 +1,247 @@
+/**
+ * The model side of the validator (issue #1025, step 4c of #380): the
+ * assertions that moved out of `src/validate.ts`, run over the model document
+ * and rigc's core instead of over what spine-core loaded.
+ *
+ * ⭐ **One body, two suppliers.** Every moved assertion is one function under
+ * `../bodies/`, written against a fact interface under `../facts/`.
+ * `validate()` supplies the facts from spine-core's loaded objects and calls
+ * 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`)
+ * 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.
+ *
+ * 🔸 **What the entry is given.** The document's text, the directory its
+ * pages resolve against, and the profile — and nothing read off a Spine file:
+ * a model-side verdict that read `skeleton.json` would be a second reading of
+ * the encoding, which is the round trip's subject and not the rig's. Since cut
+ * 4c-1 it is also given the rig info (as `validate()` is) and, in `given`, the
+ * two values a `rigc-compiled/2` or `/1` document does not hold — the stage and
+ * each page's `pma` (`./given.ts`). A `/3` document states both (issue #1026)
+ * and is read for them; `given` beside one is refused by name.
+ *
+ * ⛔ **Not wired into any command.** `build` keeps the round trip and its
+ * forty-nine lines; this entry is what the selftest and the instrument call
+ * until every moved assertion is on it (the card's design, point 7).
+ *
+ * Links nothing from the runtime, directly or through what it imports — held
+ * by the selftest's `VF` controls.
+ */
+import { ASSERTION_KIND, type AssertionProfile } from '../kinds.ts';
+import { verdictHarness, type VerdictHarness, type Verdicts, type VerdictLists } from '../harness.ts';
+import { SKIP_NO_ATLAS, SKIP_NO_MODEL } from '../reasons.ts';
+import { a03RegionWidthHeightFinite } from '../bodies/a03.ts';
+import { a11NoClippingAttachments } from '../bodies/a11.ts';
+import { a17AtlasPageFilesExist } from '../bodies/a17.ts';
+import { a45SeparableColorTimelinesOwnTheirChannelsAndPoseAsWritten } from '../bodies/a45.ts';
+import { A00_MODEL_READ, A00_MODEL_REGIONS_ON_PAGES, MODEL_PARSE_KIND, modelRead, modelRegionsOnPages, SKIP_NO_MODEL_DOCUMENT, SKIP_NO_MODEL_PAGES, type ReadDocument } from './parse.ts';
+import { modelSkinEntries } from './skin_entries.ts';
+import { modelAtlasPages } from './atlas_pages.ts';
+import { modelSlotColour } from './slot_colour.ts';
+import type { SkinEntryFacts } from '../facts/skin_entries.ts';
+import type { AtlasPageFacts } from '../facts/atlas_pages.ts';
+import type { SlotColourFacts } from '../facts/slot_colour.ts';
+import type { RigInfo } from '../../types.ts';
+import type { ModelGiven } from './given.ts';
+import { a08RegionNamesMatchAttachments } from '../bodies/a08.ts';
+import { a13MeshBudget } from '../bodies/a13.ts';
+import { a14NoFullFrameMesh } from '../bodies/a14.ts';
+import { a15IdleNoMeshBoneKeys } from '../bodies/a15.ts';
+import { a22MeshUvsInUnitRange } from '../bodies/a22.ts';
+import { a38SkinMembersAreSkinRequired } from '../bodies/a38.ts';
+import { a06AtlasPageSizeMatchesPng } from '../bodies/a06.ts';
+import { a19OverlayPngsHaveAlpha } from '../bodies/a19.ts';
+import { a27RegionNameMatchesPageFilename } from '../bodies/a27.ts';
+import { modelSkinMeshes } from './skin_meshes.ts';
+import { modelAnimatedBones } from './animated_bones.ts';
+import { modelSkinMembers } from './skin_members.ts';
+import { modelRegionJoins } from './region_joins.ts';
+import { modelAtlasRegions } from './atlas_regions.ts';
+import { modelStage } from './stage.ts';
+import type { SkinMeshFacts } from '../facts/skin_meshes.ts';
+import type { AnimatedBoneFacts } from '../facts/animated_bones.ts';
+import type { SkinMemberFacts } from '../facts/skin_members.ts';
+import type { RegionJoinFacts } from '../facts/region_joins.ts';
+import type { AtlasRegionFacts } from '../facts/atlas_regions.ts';
+import type { StageFacts } from '../facts/stage.ts';
+import { a04MeshTrianglesAndEncoding } from '../bodies/a04.ts';
+import { a20MeshWeightsCoherent } from '../bodies/a20.ts';
+import { a21MeshRimPinned } from '../bodies/a21.ts';
+import { a23PhysicsConstraintEffective } from '../bodies/a23.ts';
+import { a28RibbonRowsShareWeights } from '../bodies/a28.ts';
+import { a33VertexAttachmentGeometry } from '../bodies/a33.ts';
+import { a36PathConstraintEffective } from '../bodies/a36.ts';
+import { a37SliderConstraintEffective } from '../bodies/a37.ts';
+import { a41PhysicsSurvivesEditorRoundTrip } from '../bodies/a41.ts';
+import { a42DrivenConstraintsUpdateAfterTheirDriver } from '../bodies/a42.ts';
+import { a44LinkedMeshStatesNoGeometryOfItsOwn } from '../bodies/a44.ts';
+import { a47IkConstraintNotMutedThroughout } from '../bodies/a47.ts';
+import { a48TransformConstraintNotMutedThroughout } from '../bodies/a48.ts';
+import { modelMeshFacts } from './mesh_attachments.ts';
+import { modelPolygonFacts } from './vertex_polygons.ts';
+import { modelLinkFacts } from './linked_meshes.ts';
+import { modelConstraintFacts } from './constraints.ts';
+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';
+
+/** What the model side is given. */
+export interface ModelValidateInput {
+  /** The document `build` writes beside the Spine pair (`skeleton.model.json`). */
+  modelText: string;
+  /** 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. */
+  rig?: RigInfo;
+  /**
+   * The stage and the pages' `pma`, for a `rigc-compiled/2` or `/1` document,
+   * which does not hold them (`./given.ts`). A06, A14 and A19 read them; a
+   * caller that gives none there has those three refuse by name rather than
+   * read a value nobody stated. A `/3` document states both (issue #1026), and
+   * `given` beside it is refused by name.
+   */
+  given?: ModelGiven;
+}
+
+/** The model side's report: `validate()`'s shape, over the moved assertions and the two parse rules. */
+export interface ModelReport extends VerdictLists {
+  profile: AssertionProfile;
+}
+
+/**
+ * The fact families, composed: one supplier per family under `./`, each a
+ * function of the read document. A body names the family it reads, so a later
+ * cut that moves an assertion over an existing family adds a body file and a
+ * row below, and one over a new family adds a facts file, a supplier file and
+ * a field here.
+ */
+export interface ModelSupply {
+  skinEntries: (read: ReadDocument) => SkinEntryFacts;
+  atlasPages: (read: ReadDocument) => AtlasPageFacts;
+  slotColour: (read: ReadDocument) => SlotColourFacts;
+  skinMeshes: (read: ReadDocument) => SkinMeshFacts;
+  animatedBones: (read: ReadDocument) => AnimatedBoneFacts;
+  skinMembers: (read: ReadDocument) => SkinMemberFacts;
+  regionJoins: (read: ReadDocument) => RegionJoinFacts;
+  atlasRegions: (read: ReadDocument, input: ModelValidateInput) => AtlasRegionFacts;
+  stage: (read: ReadDocument, input: ModelValidateInput) => StageFacts;
+  meshes: (read: ReadDocument) => MeshFacts;
+  polygons: (read: ReadDocument) => PolygonFacts;
+  links: (read: ReadDocument) => LinkFacts;
+  constraints: (read: ReadDocument) => ConstraintFacts;
+}
+
+/** The suppliers the model side runs on. */
+export const MODEL_SUPPLY: ModelSupply = {
+  skinEntries: modelSkinEntries,
+  atlasPages: modelAtlasPages,
+  slotColour: modelSlotColour,
+  skinMeshes: modelSkinMeshes,
+  animatedBones: modelAnimatedBones,
+  skinMembers: modelSkinMembers,
+  regionJoins: modelRegionJoins,
+  atlasRegions: (read, input) => modelAtlasRegions(read, input.given),
+  stage: (read, input) => modelStage(read, input.given),
+  meshes: modelMeshFacts,
+  polygons: modelPolygonFacts,
+  links: modelLinkFacts,
+  constraints: modelConstraintFacts,
+};
+
+/**
+ * One moved assertion: its code, and how the model side runs its body once the
+ * document is read. The list is the registry of what has moved — each later
+ * cut appends its rows — and the selftest reads it for the codes it compares.
+ */
+export interface MovedAssertion {
+  code: string;
+  /** The body, over the document. Not called when the model side read no document. */
+  run: (verdicts: Verdicts, read: ReadDocument, input: ModelValidateInput, supply: ModelSupply) => void;
+  /** What the body SKIPs with when there is no document — the model side's counterpart of the reason `validate()` gives when the round trip produced nothing. */
+  unread: string;
+  /**
+   * The body runs behind the reader alone, not behind the region rule — the
+   * 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.
+   */
+  beforeTheParse?: boolean;
+}
+
+/**
+ * The moved assertions, in `validate()`'s report order (the order its `check`
+ * calls stand in; the selftest and the instrument compare per code). `SKIP_NO_ATLAS` for
+ * A17 rather than `SKIP_NO_MODEL` because that is what A17 says over a missing
+ * atlas on either side: its body reads only the pages, and on this side no
+ * document means no pages.
+ */
+export const MOVED_ASSERTIONS: readonly MovedAssertion[] = [
+  { code: 'A08_REGION_NAMES_MATCH_ATTACHMENTS', run: (v, read, _input, supply) => (read.doc.pages === null ? v.skip('A08_REGION_NAMES_MATCH_ATTACHMENTS', SKIP_NO_MODEL_PAGES) : a08RegionNamesMatchAttachments(v, supply.regionJoins(read), new Set<string>())), unread: SKIP_NO_MODEL, beforeTheParse: true },
+  { code: 'A03_REGION_WIDTH_HEIGHT_FINITE', run: (v, read, _input, supply) => a03RegionWidthHeightFinite(v, supply.skinEntries(read)), unread: SKIP_NO_MODEL },
+  { code: 'A04_MESH_TRIANGLES_AND_ENCODING', run: (v, read, _input, supply) => a04MeshTrianglesAndEncoding(v, supply.meshes(read)), unread: SKIP_NO_MODEL },
+  { code: 'A33_VERTEX_ATTACHMENT_GEOMETRY', run: (v, read, _input, supply) => a33VertexAttachmentGeometry(v, supply.polygons(read)), unread: SKIP_NO_MODEL },
+  { code: 'A11_NO_CLIPPING_ATTACHMENTS', run: (v, read, _input, supply) => a11NoClippingAttachments(v, supply.skinEntries(read)), unread: SKIP_NO_MODEL },
+  { code: 'A13_MESH_BUDGET', run: (v, read, input, supply) => a13MeshBudget(v, supply.skinMeshes(read), input), unread: SKIP_NO_MODEL },
+  { code: 'A14_NO_FULL_FRAME_MESH', run: (v, read, input, supply) => a14NoFullFrameMesh(v, supply.skinMeshes(read), supply.stage(read, input)), unread: SKIP_NO_MODEL },
+  { code: 'A15_IDLE_NO_MESH_BONE_KEYS', run: (v, read, input, supply) => a15IdleNoMeshBoneKeys(v, supply.skinMeshes(read), supply.animatedBones(read), input), unread: SKIP_NO_MODEL },
+  { code: 'A20_MESH_WEIGHTS_COHERENT', run: (v, read, input, supply) => a20MeshWeightsCoherent(v, supply.meshes(read), input.profile === 'spine-html', input.rig), unread: SKIP_NO_MODEL },
+  { code: 'A21_MESH_RIM_PINNED', run: (v, read, input, supply) => a21MeshRimPinned(v, supply.meshes(read), input.rig), unread: SKIP_NO_MODEL },
+  { code: 'A22_MESH_UVS_IN_UNIT_RANGE', run: (v, read, _input, supply) => a22MeshUvsInUnitRange(v, supply.skinMeshes(read)), unread: SKIP_NO_MODEL },
+  { code: 'A23_PHYSICS_CONSTRAINT_EFFECTIVE', run: (v, read, _input, supply) => a23PhysicsConstraintEffective(v, supply.constraints(read), supply.meshes(read)), unread: SKIP_NO_MODEL },
+  { code: 'A41_PHYSICS_SURVIVES_EDITOR_ROUND_TRIP', run: (v, read, input, supply) => a41PhysicsSurvivesEditorRoundTrip(v, supply.constraints(read), input.rig), unread: SKIP_NO_MODEL },
+  { code: 'A36_PATH_CONSTRAINT_EFFECTIVE', run: (v, read, _input, supply) => a36PathConstraintEffective(v, supply.constraints(read)), unread: SKIP_NO_MODEL },
+  { code: 'A37_SLIDER_CONSTRAINT_EFFECTIVE', run: (v, read, _input, supply) => a37SliderConstraintEffective(v, supply.constraints(read)), unread: SKIP_NO_MODEL },
+  { code: 'A47_IK_CONSTRAINT_NOT_MUTED_THROUGHOUT', run: (v, read, input, supply) => a47IkConstraintNotMutedThroughout(v, supply.constraints(read), input.rig), unread: SKIP_NO_MODEL },
+  { code: 'A48_TRANSFORM_CONSTRAINT_NOT_MUTED_THROUGHOUT', run: (v, read, input, supply) => a48TransformConstraintNotMutedThroughout(v, supply.constraints(read), input.rig), unread: SKIP_NO_MODEL },
+  { code: 'A42_DRIVEN_CONSTRAINTS_UPDATE_AFTER_THEIR_DRIVER', run: (v, read, _input, supply) => a42DrivenConstraintsUpdateAfterTheirDriver(v, supply.constraints(read)), unread: SKIP_NO_MODEL },
+  { code: 'A38_SKIN_MEMBERS_ARE_SKIN_REQUIRED', run: (v, read, _input, supply) => a38SkinMembersAreSkinRequired(v, supply.skinMembers(read)), unread: SKIP_NO_MODEL },
+  { code: 'A45_SEPARABLE_COLOR_TIMELINES_OWN_THEIR_CHANNELS_AND_POSE_AS_WRITTEN', run: (v, read, _input, supply) => a45SeparableColorTimelinesOwnTheirChannelsAndPoseAsWritten(v, supply.slotColour(read)), unread: SKIP_NO_MODEL },
+  { code: 'A44_LINKED_MESH_STATES_NO_GEOMETRY_OF_ITS_OWN', run: (v, read, _input, supply) => a44LinkedMeshStatesNoGeometryOfItsOwn(v, supply.links(read)), unread: SKIP_NO_MODEL },
+  { code: 'A17_ATLAS_PAGE_FILES_EXIST', run: (v, read, input, supply) => a17AtlasPageFilesExist(v, supply.atlasPages(read), input), unread: SKIP_NO_ATLAS },
+  { code: 'A06_ATLAS_PAGE_SIZE_MATCHES_PNG', run: (v, read, input, supply) => a06AtlasPageSizeMatchesPng(v, supply.atlasRegions(read, input), input, input.profile === 'spine-html'), unread: SKIP_NO_ATLAS },
+  { 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 },
+];
+
+/** The codes the model side prints: its two parse rules, then the moved assertions. */
+export const MODEL_SIDE_CODES: readonly string[] = [A00_MODEL_READ, A00_MODEL_REGIONS_ON_PAGES, ...MOVED_ASSERTIONS.map((m) => m.code)];
+
+/**
+ * The parse: the reader, then the region rule. Returns what the reader read
+ * (`null` when it refused) and whether the region rule held too — a
+ * `beforeTheParse` body needs only the first.
+ */
+function parse(h: VerdictHarness, modelText: string): { read: ReadDocument | null; held: boolean } {
+  const read = h.check(A00_MODEL_READ, () => modelRead(h.verdicts, modelText)) ?? null;
+  if (read === null) {
+    h.check(A00_MODEL_REGIONS_ON_PAGES, () => h.skip(A00_MODEL_REGIONS_ON_PAGES, SKIP_NO_MODEL_DOCUMENT));
+    return { read: null, held: false };
+  }
+  return { read, held: h.check(A00_MODEL_REGIONS_ON_PAGES, () => modelRegionsOnPages(h.verdicts, read)) === true };
+}
+
+/**
+ * Run the model side: the parse, then every moved assertion — each over the
+ * document, or skipped naming the parse when there is none — and return the
+ * report in `validate()`'s shape, which `reportLines` in `src/validate.ts`
+ * prints. `plant` replaces a family's supplier; only the selftest's plants
+ * pass one.
+ */
+export function validateModel(input: ModelValidateInput, plant: Partial<ModelSupply> = {}): ModelReport {
+  const supply: ModelSupply = { ...MODEL_SUPPLY, ...plant };
+  const h = verdictHarness(input.profile, { ...ASSERTION_KIND, ...MODEL_PARSE_KIND }, 'the model side');
+  const { read, held } = parse(h, input.modelText);
+  for (const moved of MOVED_ASSERTIONS) {
+    const doc = read !== null && (held || moved.beforeTheParse === true) ? read : null;
+    h.check(moved.code, () => (doc === null ? h.skip(moved.code, moved.unread) : moved.run(h.verdicts, doc, input, supply)));
+  }
+  const { failures, passed, skipped, profileSkipped, stats } = h;
+  return { failures, passed, skipped, profileSkipped, stats, profile: input.profile };
+}
+

package/src/assertions/model/linked_meshes.ts

@@ -0,0 +1,24 @@
+/**
+ * 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
+ * (`fileSpelledEntries`, `./vertex_polygons.ts`).
+ *
+ * `encoding` is empty on every link: a link record has no geometry field, so
+ * the geometry keys A44 refuses cannot be spelled here (`../facts/linked_meshes.ts`'s 🔒).
+ *
+ * Links nothing from the runtime.
+ */
+import type { LinkEntry, LinkFacts } from '../facts/linked_meshes.ts';
+import { fileSpelledEntries } from './vertex_polygons.ts';
+import type { ReadDocument } from './parse.ts';
+
+export function modelLinkFacts(read: ReadDocument): LinkFacts {
+  const links: LinkEntry[] = [];
+  for (const { skin, slot, placeholder, record } of fileSpelledEntries(read)) {
+    if (record.kind !== 'linkedmesh' || typeof record.source !== 'string') continue;
+    links.push({ skin, slot, placeholder, source: record.source, encoding: [] });
+  }
+  return { links };
+}

package/src/assertions/model/mesh_attachments.ts

@@ -0,0 +1,90 @@
+/**
+ * The model side's supply of `MeshFacts` (issue #1025, step 4c of #380): the
+ * document's mesh and linked-mesh records, in the file's walk order, with the
+ * geometry and the weights the runtime holds after its parse.
+ *
+ * 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`.
+ * - **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`,
+ *   `src/model.ts`'s 🔸).
+ * - **A link's geometry is its source's**: its vertices are the core's
+ *   `sourceOfDoc`, its `uvs` and triangles the core's `drawWalkOf(...).meshOf`
+ *   — the two lookups the core poses a linked mesh through — and its hull
+ *   the source record's, read where those two read it.
+ * - **The counts the parser derives**: `worldVerticesLength` is the length
+ *   of `uvs` (the length the parser hands its vertex reader for a mesh), and
+ *   `hullLength` twice the record's `hull`, which the parser reads at the
+ *   mesh row's default of the parser-default table when the key is absent
+ *   (`PARSER_DEFAULTS` in `src/keyorder.ts`, which the selftest holds to the
+ *   parser row by row).
+ *
+ * `encoding` is empty on every entry: the document states the weighted form
+ * outright and names bones, so the clauses about the flat run have no subject
+ * here (`../facts/mesh_attachments.ts`'s 🔒).
+ *
+ * Links nothing from the runtime.
+ */
+import { boneIndexOf } from '../../emit_spine.ts';
+import { drawWalkOf, shownRow, sourceOfDoc } from '../../core/index.ts';
+import { PARSER_DEFAULTS } from '../../keyorder.ts';
+import type { ModelVertices } from '../../model.ts';
+import type { MeshBinding, MeshEntry, MeshFacts } from '../facts/mesh_attachments.ts';
+import { fileOrderedEntries } from './skin_entries.ts';
+import type { ReadDocument } from './parse.ts';
+
+/** The parser's reading of a mesh with no `hull` key, off the parser-default table. */
+function hullDefault(): number {
+  const stated = PARSER_DEFAULTS['mesh attachment']?.hull;
+  if (typeof stated !== 'number') throw new Error('internal: the parser-default table has no number for a mesh attachment\'s hull');
+  return stated;
+}
+
+export function modelMeshFacts(read: ReadDocument): MeshFacts {
+  const { doc } = read;
+  const indexOf = boneIndexOf(doc.bones);
+  const sourceVertices = sourceOfDoc(doc);
+  const walk = drawWalkOf(doc, []);
+  const slotBone = new Map(doc.slots.map((s) => [s.name, s.bone]));
+  const meshes: MeshEntry[] = [];
+  for (const entry of fileOrderedEntries(read)) {
+    const g = entry.record.geometry;
+    if (g === undefined || (g.kind !== 'mesh' && g.kind !== 'linkedmesh')) continue;
+    const where = `skin "${entry.skin}" slot "${entry.slot}" placeholder "${entry.placeholder}"`;
+    let vertices: ModelVertices;
+    let uvs: readonly number[];
+    let triangles: readonly number[];
+    let hull: number | undefined;
+    if (g.kind === 'mesh') {
+      ({ vertices, uvs, triangles, hull } = g);
+    } else {
+      // `readModel` resolves every link to a mesh or refuses the document, so a miss here is this module's defect.
+      const found = sourceVertices(g.skin, g.slot, g.source);
+      const drawn = walk.meshOf(g.skin, g.slot, g.source);
+      if (typeof found === 'string' || drawn === undefined) throw new Error(`internal: ${where} is a link the reader returned without a source mesh: ${typeof found === 'string' ? found : 'no uvs'}`);
+      vertices = found;
+      ({ uvs, triangles } = drawn);
+      const source = doc.skins.find((k) => k.name === g.skin)?.attachments[g.slot]?.[g.source]?.geometry;
+      hull = source?.kind === 'mesh' ? source.hull : undefined;
+    }
+    const weights: MeshBinding[][] | null = vertices.weighted ? vertices.bindings.map((influences) => influences.map((b) => ({ bone: indexOf(b.bone), weight: Math.fround(b.weight) }))) : null;
+    meshes.push({
+      name: shownRow(entry).name,
+      skin: entry.skin,
+      slot: entry.slot,
+      slotBone: slotBone.get(entry.slot) ?? '',
+      placeholder: entry.placeholder,
+      link: g.kind === 'linkedmesh' ? { source: g.source } : null,
+      triangles,
+      worldVerticesLength: uvs.length,
+      regionUVs: uvs,
+      hullLength: 2 * (hull ?? hullDefault()),
+      weights,
+      encoding: [],
+    });
+  }
+  return { bones: doc.bones.map((b) => b.name), meshes };
+}

package/src/assertions/model/parse.ts

@@ -0,0 +1,138 @@
+/**
+ * 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 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;
+  }
+  return { doc, json: JSON.parse(modelText) as Record<string, unknown> };
+}
+
+/**
+ * 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,59 @@
+/**
+ * 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
+ *   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
+ *   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 { editorSkinOrder, editorSlotKeyOrder } 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 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 {
+  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)) {
+    if (!isObj(skin.attachments)) continue;
+    for (const [slot, table] of Object.entries(slotKeys(skin.attachments))) {
+      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/skin_entries.ts

@@ -0,0 +1,59 @@
+/**
+ * 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
+ * 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
+ * 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 { editorSkinOrder } 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`). */
+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] }> {
+  const out: ReturnType<typeof fileOrderedEntries> = [];
+  for (const skin of 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 = editorSkinOrder): 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 };
+}