spine-rigc 1.6.2 → 1.8.0

package/src/assertions/bodies/a11.ts

@@ -0,0 +1,15 @@
+/**
+ * A11, the body (issue #1025, step 4c of #380): no clipping attachment — the
+ * renderer skips them silently. A `renderer` rule, so `spine` never runs it.
+ *
+ * Moved out of `src/validate.ts` unchanged but for what it reads: the count is
+ * a fact (`../facts/skin_entries.ts`).
+ */
+import type { Verdicts } from '../harness.ts';
+import type { SkinEntryFacts } from '../facts/skin_entries.ts';
+
+export function a11NoClippingAttachments({ fail }: Verdicts, { clippingCount }: SkinEntryFacts): void {
+  if (clippingCount > 0) {
+    fail('A11_NO_CLIPPING_ATTACHMENTS', `${clippingCount} clipping attachment(s); the renderer skips them silently`);
+  }
+}

package/src/assertions/bodies/a17.ts

@@ -0,0 +1,26 @@
+/**
+ * A17, the body (issue #1025, step 4c of #380): every page the atlas names is
+ * a file on disk, resolved against the directory the atlas sits in.
+ *
+ * Moved out of `src/validate.ts` unchanged but for what it reads: the pages are
+ * a fact (`../facts/atlas_pages.ts`), and the directory is the caller's. Why
+ * the guard is a SKIP and never a bare `return` (issues #568, #608) is argued
+ * above the `check` call in `validate()`, which stays there with A06 and A19.
+ */
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import type { Verdicts } from '../harness.ts';
+import type { AtlasPageFacts } from '../facts/atlas_pages.ts';
+import { SKIP_NO_ATLAS, SKIP_NO_ATLAS_PAGE } from '../reasons.ts';
+
+export function a17AtlasPageFilesExist({ fail, skip }: Verdicts, { atlas }: AtlasPageFacts, input: { atlasDir: string }): void {
+  if (!atlas) return skip('A17_ATLAS_PAGE_FILES_EXIST', SKIP_NO_ATLAS);
+  // The other absence, one ring in (#580): the atlas LOADED and declares no
+  // page, so there is no file to find missing. `!atlas` and "zero pages" print
+  // different reasons because they are different facts about the artifact.
+  if (atlas.pages.length === 0) return skip('A17_ATLAS_PAGE_FILES_EXIST', SKIP_NO_ATLAS_PAGE);
+  for (const page of atlas.pages) {
+    const abs = resolve(input.atlasDir, page.name);
+    if (!existsSync(abs)) fail('A17_ATLAS_PAGE_FILES_EXIST', `page "${page.name}" is not on disk at ${abs}`);
+  }
+}

package/src/assertions/bodies/a45.ts

@@ -0,0 +1,172 @@
+/**
+ * A45, the body (issue #1025, step 4c of #380): the separable colour timelines
+ * own their channels and pose as written.
+ *
+ * Moved out of `src/validate.ts` unchanged but for what it reads, which is
+ * three facts (`../facts/slot_colour.ts`) where it read the skeleton JSON and
+ * the loaded skeleton: the animations' slot timelines in the file's order, as
+ * the file spells them; whether an animation exists; and a slot's colour posed
+ * at a time on a fresh track, which `validate()` takes from spine-core and the
+ * model side from rigc's core. The `check` call stays in `validate()`.
+ */
+import type { Verdicts } from '../harness.ts';
+import type { SlotColourFacts } from '../facts/slot_colour.ts';
+import { SKIP_NO_SEPARABLE_COLOR } from '../reasons.ts';
+import { atStoredKey, isObj } from '../values.ts';
+import { SLOT_COLOR_CHANNELS } from '../../timelines.ts';
+
+// ⭐ **Why this is its own rule and not a clause on `A43`.** `rgb` and
+// `alpha` pose no dark colour, so under A43's name a failure would be a
+// verdict saying "two-colour tint" about a file that states one colour —
+// the name would say something other than what it decides (the rule #712
+// applied to A43 itself, against a clause on A10). And the SKIP is the
+// sharper half: a rig with a `dark` and no separable timeline has A43's
+// subject present, so a clause there could only PASS on it, which is a pass
+// for an absent subject.
+//
+// 🚨 **What it decides is what makes `rgb` + `alpha` not `rgba`**, and both
+// clauses are about the file against the runtime:
+//
+//   1. **One channel, one timeline.** Each colour timeline poses its
+//      channels at EVERY time — before its first key it writes the setup
+//      value — so when two of one slot share a channel, the one applied
+//      later (the one the file states later) overwrites the other
+//      everywhere and the first one's keys on it are read by nothing
+//      (`SLOT_COLOR_CHANNELS`). It is the shape a converter that writes a
+//      separable `rgb` as `rgba` leaves beside the `alpha` it kept, and it
+//      loads without a word.
+//   2. **Posed as written.** Stepped to each key's own time, the channels
+//      the timeline writes are the key's: a colour that is not six hex
+//      digits loads as NaN, and a key whose time another key repeats is
+//      read by nothing, and both parse in silence.
+//
+// ⚠️ An `rgb` timeline alone that a converter wrote as `rgba` with the
+// setup alpha is NOT this rule's to see, and nothing that reads only the
+// file can see it: the result is a correct `rgba`, which is also what an
+// author keying the light colour and holding its alpha would write. What
+// differs is what happens UNDER another track that moves the alpha, which
+// is the consumer's composing rather than the object (CLAUDE.md). That
+// file SKIPs here — it keys no `rgb` or `alpha` — and says so.
+//
+// ⚠️ The required values are parsed HERE, as A43's are, and the channel
+// table is `timelines.ts`'s rather than the loaded timelines' property ids:
+// a check that asked the parser what a timeline writes would agree with it
+// whatever it did. A selftest control holds that table to the runtime's ids.
+export function a45SeparableColorTimelinesOwnTheirChannelsAndPoseAsWritten({ fail, skip, stats }: Verdicts, facts: SlotColourFacts): void {
+  const NAME = 'A45_SEPARABLE_COLOR_TIMELINES_OWN_THEIR_CHANNELS_AND_POSE_AS_WRITTEN';
+  /** `rrggbb`, or `rrggbbaa` whose alpha an `rgb` key cannot pose. Null for anything else. */
+  const readRgbHex = (hex: unknown): [number, number, number] | null => {
+    if (typeof hex !== 'string') return null;
+    const body = hex.startsWith('#') ? hex.slice(1) : hex;
+    if (!/^[\da-fA-F]{6}([\da-fA-F]{2})?$/.test(body)) return null;
+    return [0, 2, 4].map((i) => Number.parseInt(body.slice(i, i + 2), 16) / 255) as [number, number, number];
+  };
+  /** Half a byte step for a hex channel; a stored `Float32` for an alpha `value`. */
+  const HEX_STEP = 1 / 510;
+  const FLOAT_STEP = 1e-6;
+  const off = (found: number, want: number, step: number): boolean => !Number.isFinite(found) || Math.abs(found - want) > step;
+  const show = (c: readonly number[]): string => c.map((n) => (Number.isFinite(n) ? n.toFixed(4) : 'NaN')).join(', ');
+
+  // -- the subjects, read off the FILE ---------------------------------
+  const subjects: Array<{ anim: string; slot: string; timelines: Record<string, unknown> }> = [];
+  for (const { animation: animName, slot: slotName, timelines } of facts.slotTimelines) {
+    if (Array.isArray(timelines.rgb) || Array.isArray(timelines.alpha)) {
+      subjects.push({ anim: animName, slot: slotName, timelines });
+    }
+  }
+  if (subjects.length === 0) return skip(NAME, SKIP_NO_SEPARABLE_COLOR);
+  stats.separableColorTimelines = subjects.reduce(
+    (n, s) => n + (Array.isArray(s.timelines.rgb) ? 1 : 0) + (Array.isArray(s.timelines.alpha) ? 1 : 0),
+    0,
+  );
+
+  for (const { anim: animName, slot: slotName, timelines } of subjects) {
+    const at = `animation "${animName}" slot "${slotName}"`;
+    // In FILE order, which is the order `readAnimation` pushes them and so
+    // the order they apply in.
+    const colour = Object.keys(timelines).filter((name) => name in SLOT_COLOR_CHANNELS && Array.isArray(timelines[name]));
+
+    // -- clause 1: one channel, one timeline ---------------------------
+    let shared = false;
+    for (const channel of ['rgb', 'alpha', 'dark'] as const) {
+      const writers = colour.filter((name) => SLOT_COLOR_CHANNELS[name].includes(channel));
+      if (writers.length < 2 || !writers.some((name) => name === 'rgb' || name === 'alpha')) continue;
+      shared = true;
+      const last = writers[writers.length - 1];
+      fail(
+        NAME,
+        `${at}: ${writers.map((name) => `"${name}"`).join(' and ')} ${writers.length === 2 ? 'both' : 'all'} key the ${channel === 'rgb' ? 'light rgb' : channel === 'alpha' ? 'alpha' : 'dark colour'} ` +
+          `— each poses it at every time, its setup value before its first key included, so "${last}", which the ` +
+          `file states last, overwrites ${writers.length === 2 ? `"${writers[0]}"` : 'the others'} everywhere and ` +
+          'those keys are read by nothing. Key each channel once: "rgb" and "alpha" on their own key times, or one "rgba"',
+      );
+    }
+    if (shared) continue;
+
+    // -- clause 2: posed as written ------------------------------------
+    //
+    // ⚠️ Two things this does NOT do, both measured rather than skipped:
+    // it does not read the loaded timeline's CLASS back, and it does not
+    // hold a channel the timeline leaves alone to the setup pose. Against
+    // the linked parser neither can fail — every `rgb` / `alpha` array that
+    // loads at all loads as an `RGBTimeline` / `AlphaTimeline`, and the
+    // three other outcomes (an empty array, a slot the skeleton lacks, a
+    // name outside the switch) throw at `A00` — so either would be a clause
+    // nobody can see fire. The selftest reads both off spine-core directly
+    // (`S82`–`S84`), where they are measurements of the runtime rather than
+    // checks on a file.
+    if (!facts.hasAnimation(animName)) {
+      fail(NAME, `${at}: the loaded skeleton has no animation "${animName}"`);
+      continue;
+    }
+    for (const name of ['rgb', 'alpha'] as const) {
+      const keys = timelines[name];
+      if (!Array.isArray(keys)) continue;
+      const where = `${at} ${name}`;
+      for (const rawKey of keys) {
+        if (!isObj(rawKey)) continue;
+        const time = typeof rawKey.time === 'number' ? rawKey.time : 0;
+        // At the key as the runtime stores it, not one float step before
+        // it — see `atStoredKey` (issue #771).
+        const posed = facts.posedSlot(animName, slotName, atStoredKey(time));
+        if (!posed) {
+          fail(NAME, `${where} (t=${time}): the posed skeleton has no slot "${slotName}" to read`);
+          continue;
+        }
+        const light = [posed.color.r, posed.color.g, posed.color.b, posed.color.a];
+        if (name === 'rgb') {
+          const stated = readRgbHex(rawKey.color);
+          if (stated === null) {
+            fail(
+              NAME,
+              `${where} (t=${time}): the key states color ${JSON.stringify(rawKey.color)} — an rgb key is six hex ` +
+                `digits — and the runtime poses (${show(light.slice(0, 3))})`,
+            );
+          } else if (light.slice(0, 3).some((n, i) => off(n, stated[i], HEX_STEP))) {
+            fail(
+              NAME,
+              `${where} (t=${time}): rgb posed (${show(light.slice(0, 3))}), the key states ` +
+                `${JSON.stringify(rawKey.color)} = (${show(stated)})`,
+            );
+          }
+        } else {
+          // `readTimeline1(…, 0, 1)`: an absent `value` IS 0, and an editor
+          // omits it there, so absence is read the parser's way rather than
+          // as a malformed key.
+          const stated = rawKey.value === undefined ? 0 : rawKey.value;
+          if (typeof stated !== 'number' || off(light[3], stated, FLOAT_STEP)) {
+            fail(
+              NAME,
+              `${where} (t=${time}): alpha posed ${show([light[3]])}, the key states value ${JSON.stringify(rawKey.value)}` +
+                (typeof stated !== 'number'
+                  ? ' — an alpha key\'s value is a number'
+                  : stated < 0 || stated > 1
+                    ? ' — the runtime clamps a posed alpha to 0..1'
+                    : ''),
+            );
+          }
+        }
+      }
+    }
+  }
+}

package/src/assertions/facts/atlas_pages.ts

@@ -0,0 +1,19 @@
+/**
+ * The atlas's pages, as the bodies that read them see them (issue #1025, step
+ * 4c of #380) — the census's F20, without `pma`, which the model document does
+ * not hold and a later cut supplies from the caller.
+ *
+ * Links nothing from the runtime: a spine-core `TextureAtlas` satisfies the
+ * shape structurally, which is how `validate()` supplies it, and the model
+ * side supplies the document's `pages` section (`../model/atlas_pages.ts`).
+ */
+
+/** One page: its name, a path relative to the directory the atlas sits in. */
+export interface AtlasPage {
+  readonly name: string;
+}
+
+/** The atlas, or `null` when there is none to read — the round trip refused it, or the model side read no document. */
+export interface AtlasPageFacts {
+  readonly atlas: { readonly pages: readonly AtlasPage[] } | null;
+}

package/src/assertions/facts/skin_entries.ts

@@ -0,0 +1,35 @@
+/**
+ * The skin entries, as the bodies that walk them read them (issue #1025, step
+ * 4c of #380) — the census's F03, F05 and F06: every skin's attachments, of
+ * which kind each is, and a region's name and size.
+ *
+ * ⭐ **The order is a fact, and it is the file's.** A body that prints one
+ * line per offending entry prints them in the order this list holds them, so a
+ * supplier that walked another order would print the same findings in another
+ * order — a different report about the same rig. The order is the one
+ * spine-core's loaded skins list their entries in: the skins in the file's
+ * order (`default` first, the rest in the editor's order the emitter writes —
+ * `editorSkinOrder` in `src/compile.ts`), and within a skin the entries slot by
+ * slot in the skeleton's slot order, each slot's in the order its table states
+ * them. The model side produces it by calling the emitter's own order, never
+ * by restating it (`../model/skin_entries.ts`); the selftest measures the two
+ * walks equal on every multi-skin build it makes.
+ *
+ * Links nothing from the runtime: a spine-core `RegionAttachment` satisfies
+ * the entry shape structurally, which is how `validate()` supplies it.
+ */
+
+/** One region attachment: the name it loaded under (its `name`, else its placeholder) and its size. */
+export interface RegionEntry {
+  readonly name: string;
+  readonly width: number;
+  readonly height: number;
+}
+
+/** What the skins hold, for A03 and A11. */
+export interface SkinEntryFacts {
+  /** Every region attachment of every skin, in the file's walk order (the header's ⭐). */
+  readonly regionAttachments: readonly RegionEntry[];
+  /** How many clipping attachments the skins hold, every skin counted. */
+  readonly clippingCount: number;
+}

package/src/assertions/facts/slot_colour.ts

@@ -0,0 +1,43 @@
+/**
+ * Slot colour timelines and the colour a slot poses at (issue #1025, step 4c
+ * of #380) — the census's F18 and R4: the animations and the slot timelines
+ * they key, and one slot's light colour posed by the runtime's rule.
+ *
+ * ⭐ **The file's order, and the file's spelling.** A45's first clause names
+ * the timeline "which the file states last" as the one that wins, so the order
+ * of a slot's timelines is a value and not a presentation; and its findings
+ * print a key's `time`, `color` and `value` as the file states them. So the
+ * list holds, for every animation in the order the file keys them and every
+ * slot in the order the animation keys them, that slot's timelines in the
+ * file's order, each key as the file spells it. `validate()` reads it off the
+ * skeleton JSON; the model side produces it from the document by calling the
+ * emitter's own order and its own parser-default and key-order passes
+ * (`../model/slot_colour.ts`), so a key the emitter would write without a field
+ * reads without it here too.
+ */
+
+/** One animation's timelines on one slot: timeline name -> keys, as the file states them. */
+export interface SlotTimelines {
+  readonly animation: string;
+  readonly slot: string;
+  readonly timelines: Readonly<Record<string, unknown>>;
+}
+
+/** A slot's light colour as posed: four channels, NaN where the pose read no number. */
+export interface PosedSlotColour {
+  readonly color: { readonly r: number; readonly g: number; readonly b: number; readonly a: number };
+}
+
+/** What A45 reads. */
+export interface SlotColourFacts {
+  /** Every (animation, slot) pair whose timelines the file keys, in the header's order. */
+  readonly slotTimelines: readonly SlotTimelines[];
+  /** Whether the skeleton holds an animation of this name. */
+  hasAnimation(name: string): boolean;
+  /**
+   * The slot's colour with the animation applied at `time` on a fresh,
+   * non-looping track from the setup pose, no skin set — or `undefined` for a
+   * slot the skeleton does not have.
+   */
+  posedSlot(animation: string, slot: string, time: number): PosedSlotColour | undefined;
+}

package/src/assertions/harness.ts

@@ -0,0 +1,109 @@
+/**
+ * The harness an assertion body runs in, and the report it fills (issue
+ * #1025, step 4c of #380).
+ *
+ * One harness for both sides. `validate()` runs a body over the facts it reads
+ * off what spine-core loaded; the model side (`./model/index.ts`) runs the same
+ * body over the facts it reads off the model document and the core. What makes
+ * a line the same line on both sides is that the body is one function and the
+ * harness deciding PASS, SKIP, FAIL and PROF around it is one function too — a
+ * second copy of `check` would be a second place a verdict could be decided
+ * differently.
+ *
+ * Moved here from `validate()`, the rule unchanged: an assertion is recorded
+ * as passed only when its body neither failed nor skipped, a body that throws
+ * is a FAIL whose detail is `threw: <message>`, and a rule the profile does not
+ * carry is not run at all and is recorded as out of profile.
+ *
+ * This module links nothing from the runtime, directly or through what it
+ * imports — the condition for the model side to use it, held by the selftest.
+ */
+import { kindRunsUnder, type AssertionKind, type AssertionProfile } from './kinds.ts';
+
+/** One failure: the assertion's code and the sentence naming the object, the value found and the value required. */
+export interface Failure {
+  assertion: string;
+  detail: string;
+}
+
+/** What a body is handed: how to fail, how to declare it had nothing to measure, and the stats line it may add to. */
+export interface Verdicts {
+  fail: (assertion: string, detail: string) => void;
+  skip: (assertion: string, reason: string) => void;
+  stats: Record<string, number | string>;
+}
+
+/** The four lists and the stats a run of bodies leaves — the shape `validate()` returns, less the profile. */
+export interface VerdictLists {
+  failures: Failure[];
+  /** Assertions that ran and passed, in order. */
+  passed: string[];
+  /** Assertions that had nothing to run against, with the reason. */
+  skipped: Array<{ assertion: string; reason: string }>;
+  /** Assertions the profile does not apply, with their kind. */
+  profileSkipped: Array<{ assertion: string; kind: 'renderer' | 'archetype' }>;
+  stats: Record<string, number | string>;
+}
+
+/** A harness: the lists it fills, the two calls a body makes, and `check`, which runs a body. */
+export interface VerdictHarness extends VerdictLists {
+  fail: Verdicts['fail'];
+  skip: Verdicts['skip'];
+  /**
+   * Run one assertion; record it as passed only if it neither failed nor skipped,
+   * and do not run it at all when the profile does not carry that kind of rule.
+   *
+   * The unknown-assertion throw is deliberate: an assertion with no entry in
+   * the kind table would otherwise pick a profile by accident, and picking
+   * wrong means either a rule that never runs or a rule that fires on
+   * everybody's data.
+   *
+   * The body's return value is handed back — `undefined` when the assertion did
+   * not run or threw. `validate()`'s A00 uses it so that the loaded atlas and
+   * skeleton can be `const`: assigning them from inside this callback leaves
+   * the type checker unable to see that they were ever set, and every later read
+   * of `atlas.pages` or `data.bones` becomes a property of `never`.
+   */
+  check: <T>(assertion: string, body: () => T) => T | undefined;
+  /** `fail`, `skip` and `stats`, as one value to hand a body. */
+  verdicts: Verdicts;
+}
+
+/**
+ * A fresh harness for one run under `profile`. `kinds` is the kind table the
+ * run's codes are looked up in, and `who` names the run in the throw for a code
+ * the table lacks — `validate` for the gate, so its message is the one it was.
+ */
+export function verdictHarness(profile: AssertionProfile, kinds: Readonly<Record<string, AssertionKind>>, who: string): VerdictHarness {
+  const failures: Failure[] = [];
+  const passed: string[] = [];
+  const skipped: VerdictLists['skipped'] = [];
+  const profileSkipped: VerdictLists['profileSkipped'] = [];
+  const stats: Record<string, number | string> = {};
+  const fail = (assertion: string, detail: string): void => {
+    failures.push({ assertion, detail });
+  };
+  /** Declare that an assertion had nothing to check, and why. */
+  const skip = (assertion: string, reason: string): void => {
+    skipped.push({ assertion, reason });
+  };
+  const check = <T>(assertion: string, body: () => T): T | undefined => {
+    const kind = kinds[assertion];
+    if (!kind) throw new Error(`${who}: assertion "${assertion}" has no ASSERTION_KIND entry`);
+    if (!kindRunsUnder(kind, profile)) {
+      profileSkipped.push({ assertion, kind: kind === 'renderer' ? 'renderer' : 'archetype' });
+      return undefined;
+    }
+    const before = failures.length;
+    const skippedBefore = skipped.length;
+    let result: T | undefined;
+    try {
+      result = body();
+    } catch (err) {
+      fail(assertion, `threw: ${(err as Error).message}`);
+    }
+    if (failures.length === before && skipped.length === skippedBefore) passed.push(assertion);
+    return result;
+  };
+  return { failures, passed, skipped, profileSkipped, stats, fail, skip, check, verdicts: { fail, skip, stats } };
+}

package/src/assertions/kinds.ts

@@ -0,0 +1,102 @@
+/**
+ * What kind of rule each assertion is, and which profile runs which kind
+ * (issue #1025, step 4c of #380).
+ *
+ * The table lives here rather than in `src/validate.ts` because two harnesses
+ * read it now: `validate()`'s `check`, which runs an assertion over what
+ * spine-core loaded, and the model side's (`./harness.ts`), which runs the
+ * same body over the model document and the core. A profile has to exclude
+ * the same rules on both sides, and two copies of the table is how one of
+ * them would come to exclude a rule the other runs. This module links nothing
+ * from the runtime, which is the condition for the model side to read it.
+ */
+
+/** The two rulebooks — `ValidateProfile` in `src/validate.ts`, where the choice between them is argued. */
+export type AssertionProfile = 'spine' | 'spine-html';
+
+/** The three kinds a rule can be; the table's own comment says what each means. */
+export type AssertionKind = 'validity' | 'renderer' | 'archetype';
+
+/**
+ * What kind of rule each assertion is. Every assertion has an entry, and
+ * `check()` throws on a name that has none — a new assertion must state its kind
+ * rather than defaulting into one, because the default would decide, silently,
+ * whether it runs on foreign data.
+ *
+ *   validity  — the file is wrong for any consumer. Runs under every profile.
+ *   renderer  — valid Spine that this project's renderer or frame budget refuses.
+ *   archetype — a structural rule about rigc's own formations, meaningless to a
+ *               skeleton rigc did not compile.
+ *
+ * Two assertions are MIXED and are marked `validity` here because their
+ * validity half must never stop running; their policy clauses are gated inside
+ * the assertion body against `profile`, and each such clause says so where it
+ * lives. They are A06 (size-vs-PNG and every region's rectangle inside the page
+ * it names are validity; pma / rotation / two regions over the same texels are
+ * policy — the rectangle moved across that line in issue #694, and the reason
+ * is stated where it now sits) and A20 (weight coherence is validity; requiring
+ * a mesh to be weighted at all is policy).
+ *
+ * A08 was the third until issue #574 retired its policy clause. It required a
+ * skin entry's placeholder to be spelled like the region it resolves to, under
+ * a renderer that resolves art by `path` and has never read a placeholder — so
+ * restating it as the renderer's own join made it a tautology over the validity
+ * half. The argument, with the renderer lines it is measured against, sits above
+ * `check('A08_…')`.
+ */
+export const ASSERTION_KIND: Readonly<Record<string, AssertionKind>> = {
+  A00_ROUNDTRIP_PARSE: 'validity',
+  A01_NO_LEGACY_TOPLEVEL_CONSTRAINT_ARRAYS: 'validity',
+  A02_NO_BONE_TRANSFORM_KEY: 'validity',
+  A03_REGION_WIDTH_HEIGHT_FINITE: 'validity',
+  A04_MESH_TRIANGLES_AND_ENCODING: 'validity',
+  A05_CURVE_ARRAY_LENGTH: 'validity',
+  A06_ATLAS_PAGE_SIZE_MATCHES_PNG: 'validity', // mixed — see above
+  A07_ATLAS_TEXT_SHAPE: 'validity',
+  A08_REGION_NAMES_MATCH_ATTACHMENTS: 'validity', // no longer mixed — see above (#574)
+  A09_ANIMATION_DURATION_MATCHES_SPEC: 'validity',
+  A10_NO_NAN_AFTER_STEPPING: 'validity',
+  A11_NO_CLIPPING_ATTACHMENTS: 'renderer',
+  A12_NO_DARK_COLOR: 'renderer',
+  A13_MESH_BUDGET: 'renderer',
+  A14_NO_FULL_FRAME_MESH: 'renderer',
+  A15_IDLE_NO_MESH_BONE_KEYS: 'renderer',
+  A16_SKELETON_VERSION_4_3: 'validity',
+  A17_ATLAS_PAGE_FILES_EXIST: 'validity',
+  A18_DETERMINISTIC_EMIT: 'validity',
+  A19_OVERLAY_PNGS_HAVE_ALPHA: 'renderer',
+  A20_MESH_WEIGHTS_COHERENT: 'validity', // mixed — see above
+  A21_MESH_RIM_PINNED: 'archetype',
+  A22_MESH_UVS_IN_UNIT_RANGE: 'validity',
+  A23_PHYSICS_CONSTRAINT_EFFECTIVE: 'validity',
+  A24_AXIS_SPACE_STROKE: 'archetype',
+  A25_DETACHED_BONE_PARENTAGE: 'archetype',
+  A26_SLOT_DRAW_ORDER: 'archetype',
+  A27_REGION_NAME_MATCHES_PAGE_FILENAME: 'renderer',
+  A28_RIBBON_ROWS_SHARE_WEIGHTS: 'archetype',
+  A29_STROKE_WITHIN_CONTACT_DEPTH: 'archetype',
+  A30_STROKE_WITHIN_CAP_CONTAINMENT: 'archetype',
+  A31_DRAW_ORDER_OFFSETS_RESOLVE: 'validity',
+  A32_EVENT_KEYS_RESOLVE: 'validity',
+  A33_VERTEX_ATTACHMENT_GEOMETRY: 'validity',
+  A34_CONSTRAINT_TIMELINE_TARGETS: 'validity',
+  A35_DEFORM_KEYS_FIT_THE_ATTACHMENT: 'validity',
+  A36_PATH_CONSTRAINT_EFFECTIVE: 'validity',
+  A37_SLIDER_CONSTRAINT_EFFECTIVE: 'validity',
+  A38_SKIN_MEMBERS_ARE_SKIN_REQUIRED: 'validity',
+  A39_DEFORM_KEEPS_TRIANGLE_WINDING: 'archetype',
+  A40_SLIDERS_COMPOSE_ON_A_SHARED_TARGET: 'validity',
+  A41_PHYSICS_SURVIVES_EDITOR_ROUND_TRIP: 'validity',
+  A42_DRIVEN_CONSTRAINTS_UPDATE_AFTER_THEIR_DRIVER: 'validity',
+  A43_TWO_COLOR_TINT_LOADS_AND_POSES_AS_WRITTEN: 'validity',
+  A44_LINKED_MESH_STATES_NO_GEOMETRY_OF_ITS_OWN: 'validity',
+  A45_SEPARABLE_COLOR_TIMELINES_OWN_THEIR_CHANNELS_AND_POSE_AS_WRITTEN: 'validity',
+  A46_SEQUENCE_ATTACHMENTS_SHOW_THE_FRAME_THE_FILE_STATES: 'validity',
+  A47_IK_CONSTRAINT_NOT_MUTED_THROUGHOUT: 'validity',
+  A48_TRANSFORM_CONSTRAINT_NOT_MUTED_THROUGHOUT: 'validity',
+};
+
+/** Whether `profile` runs a rule of `kind`: `spine` runs validity alone, `spine-html` every kind. */
+export function kindRunsUnder(kind: AssertionKind, profile: AssertionProfile): boolean {
+  return kind === 'validity' || profile === 'spine-html';
+}

package/src/assertions/model/atlas_pages.ts

@@ -0,0 +1,15 @@
+/**
+ * The model side's supply of `AtlasPageFacts` (issue #1025, step 4c of #380):
+ * the document's `pages` section, which `build` spells from the atlas text it
+ * writes (`pagesOfAtlas` in `src/model.ts`), so the page names are the ones
+ * the written atlas names, in its order and trimmed as the parser trims them.
+ * A `rigc-compiled/1` document states no pages, and reads as no atlas.
+ *
+ * Links nothing from the runtime.
+ */
+import type { AtlasPageFacts } from '../facts/atlas_pages.ts';
+import type { ReadDocument } from './parse.ts';
+
+export function modelAtlasPages(read: ReadDocument): AtlasPageFacts {
+  return { atlas: read.doc.pages === null ? null : { pages: read.doc.pages.map((page) => ({ name: page.name })) } };
+}