spine-rigc 1.9.4 → 2.0.0

package/src/assertions/bodies/a05.ts

@@ -0,0 +1,56 @@
+/**
+ * A05, restated over the emitted text (issue #1060): the clause
+ * `validate()` runs in `src/validate.ts`, word for word, over the skeleton JSON — the
+ * text rigc wrote, read by rigc's own reader rather than by spine-core's. The
+ * round trip's copy is unchanged and runs in `cli.ts build`; this one runs in
+ * the gate of the entry that links none of the runtime
+ * (`../emitted/index.ts`), and the selftest's `RC28` holds the two to the
+ * same lines on every recipe and on this assertion's mutants.
+ */
+import type { Verdicts } from '../harness.ts';
+import { SKIP_NO_TIMELINE } from '../reasons.ts';
+import { CHANNELS_BY_KIND, walkTimelines } from '../../timelines.ts';
+import { isObj, type Json } from '../values.ts';
+
+export function a05CurveArrayLength({ fail, skip }: Verdicts, raw: Json | null): void {
+  // Two clauses, so the SKIP needs both to be empty (#580). The vocabulary
+  // clause below measures every timeline it is handed — an unchecked name is a
+  // finding whether or not any key on it carries a curve — so a skeleton with
+  // timelines and no curve at all has still been measured. What measures
+  // nothing is a skeleton `walkTimelines` never calls back on.
+  let timelines = 0;
+  walkTimelines(raw, (path, kind, name, keys) => {
+    timelines++;
+    const table = CHANNELS_BY_KIND[kind];
+    if (!(name in table)) {
+      fail('A05_CURVE_ARRAY_LENGTH', `${path}: unchecked ${kind} timeline "${name}" — extend the validator`);
+      return;
+    }
+    const channels = table[name];
+    for (const key of keys) {
+      if (!isObj(key) || !('curve' in key)) continue;
+      const curve = key.curve;
+      if (channels === null) {
+        fail('A05_CURVE_ARRAY_LENGTH', `${path}: timeline "${name}" cannot carry a curve`);
+        continue;
+      }
+      if (curve === 'stepped') continue;
+      if (!Array.isArray(curve)) {
+        fail('A05_CURVE_ARRAY_LENGTH', `${path}: curve is ${JSON.stringify(curve)}, expected "stepped" or an array`);
+        continue;
+      }
+      if (curve.length !== channels * 4) {
+        fail(
+          'A05_CURVE_ARRAY_LENGTH',
+          `${path} (t=${String(key.time ?? 0)}): curve has ${curve.length} numbers, "${name}" needs ${channels} channels x 4 = ${channels * 4}`,
+        );
+      }
+      for (const n of curve) {
+        if (typeof n !== 'number' || !Number.isFinite(n)) {
+          fail('A05_CURVE_ARRAY_LENGTH', `${path}: curve holds a non-finite value ${JSON.stringify(n)}`);
+        }
+      }
+    }
+  });
+  if (timelines === 0) return skip('A05_CURVE_ARRAY_LENGTH', SKIP_NO_TIMELINE);
+}

package/src/assertions/bodies/a07.ts

@@ -0,0 +1,68 @@
+/**
+ * A07, restated over the emitted text (issue #1060): the clause
+ * `validate()` runs in `src/validate.ts`, word for word, over the atlas text — the
+ * text rigc wrote, read by rigc's own reader rather than by spine-core's. The
+ * round trip's copy is unchanged and runs in `cli.ts build`; this one runs in
+ * the gate of the entry that links none of the runtime
+ * (`../emitted/index.ts`), and the selftest's `RC28` holds the two to the
+ * same lines on every recipe and on this assertion's mutants.
+ */
+import type { Verdicts } from '../harness.ts';
+import { SKIP_NO_ATLAS_PAGE } from '../reasons.ts';
+
+export function a07AtlasTextShape({ fail, skip }: Verdicts, atlasText: string): void {
+  const atlasLines = atlasText.replace(/\n$/, '').split('\n');
+  const atlasPageLines = atlasLines.filter((line) => line.trim().length > 0).length;
+  if (atlasPageLines === 0) {
+    // One of the exported reason constants, not a sentence of its own: the
+    // static-rig suite's arithmetic (S50, #580) counts a rule as skipped
+    // for want of a SUBJECT only when its reason is one of those constants.
+    return skip('A07_ATLAS_TEXT_SHAPE', SKIP_NO_ATLAS_PAGE);
+  }
+  // A blank line at either END of the file is named as that end (issues #803,
+  // #810), and a run of them is one finding stating its length. They are taken
+  // off both ends before the walk below, so the walk sees the page blocks and
+  // the blank lines between them and nothing else: a blank line after the last
+  // region is not a page block, and "consecutive blank lines" and "the last
+  // page block declares no region" are about blocks. `TextureAtlas` reads a
+  // blank at either end as nothing (`TextureAtlas.js:98-100` skips the leading
+  // run, `:116-118` ends a page block on each blank line), and rigc writes
+  // neither (`writeAtlasText`, and `--atlas-in` through `canonicalAtlasShape`),
+  // so a file that has one was written by something else and is refused.
+  let leading = 0;
+  while (leading < atlasLines.length && atlasLines[leading].trim().length === 0) leading++;
+  if (leading > 0) {
+    fail('A07_ATLAS_TEXT_SHAPE', `line 1: the file begins with ${leading === 1 ? 'a blank line' : `${leading} blank lines`}`);
+  }
+  let trailing = 0;
+  while (trailing < atlasLines.length - leading && atlasLines[atlasLines.length - 1 - trailing].trim().length === 0) trailing++;
+  const blockEnd = atlasLines.length - trailing;
+  let expectPage = true;
+  let sawRegionForPage = false;
+  for (let i = leading; i < blockEnd; i++) {
+    const line = atlasLines[i];
+    if (line.trim().length === 0) {
+      if (expectPage) fail('A07_ATLAS_TEXT_SHAPE', `line ${i + 1}: consecutive blank lines`);
+      else if (!sawRegionForPage) {
+        fail('A07_ATLAS_TEXT_SHAPE', `line ${i + 1}: blank line before this page had any region`);
+      }
+      expectPage = true;
+      sawRegionForPage = false;
+      continue;
+    }
+    if (expectPage) {
+      expectPage = false;
+      continue; // page name line
+    }
+    if (line.includes(':')) continue; // key: value line
+    // A bare non-key line is a region name, and it is used untrimmed.
+    if (line !== line.trim()) {
+      fail('A07_ATLAS_TEXT_SHAPE', `line ${i + 1}: region name has stray whitespace: ${JSON.stringify(line)}`);
+    }
+    sawRegionForPage = true;
+  }
+  if (!sawRegionForPage) fail('A07_ATLAS_TEXT_SHAPE', 'the last page block declares no region');
+  if (trailing > 0) {
+    fail('A07_ATLAS_TEXT_SHAPE', `line ${blockEnd + 1}: the file ends with ${trailing === 1 ? 'a blank line' : `${trailing} blank lines`}`);
+  }
+}

package/src/assertions/bodies/a16.ts

@@ -0,0 +1,24 @@
+/**
+ * A16, restated over the emitted text (issue #1060): the clause
+ * `validate()` runs in `src/validate.ts`, word for word, over the skeleton JSON — the
+ * text rigc wrote, read by rigc's own reader rather than by spine-core's. The
+ * round trip's copy is unchanged and runs in `cli.ts build`; this one runs in
+ * the gate of the entry that links none of the runtime
+ * (`../emitted/index.ts`), and the selftest's `RC28` holds the two to the
+ * same lines on every recipe and on this assertion's mutants.
+ */
+import type { Verdicts } from '../harness.ts';
+import { spineGeneration, type SpineGeneration } from '../../generation.ts';
+import { isObj, type Json } from '../values.ts';
+
+const SPINE_4_3: SpineGeneration = '4.3';
+
+export function a16SkeletonVersion43({ fail }: Verdicts, raw: Json | null): void {
+  const declared = isObj(raw?.skeleton) ? (raw.skeleton as Json).spine : undefined;
+  if (typeof declared !== 'string' || spineGeneration(declared) !== SPINE_4_3) {
+    fail(
+      'A16_SKELETON_VERSION_4_3',
+      `skeleton.spine is ${JSON.stringify(declared)}, expected 4.3, 4.3.<patch> or 4.3.<patch>-<suffix>`,
+    );
+  }
+}

package/src/assertions/bodies/a18.ts

@@ -0,0 +1,62 @@
+/**
+ * A18, the body (issue #1060, step 4e of #380): a second, independent compile
+ * writes the same model document, byte for byte.
+ *
+ * One body, two suppliers, as every moved assertion is — but split. The
+ * runtime's side (`validate()` in `src/validate.ts`) compares the second
+ * compile's Spine pair as well, `skeleton.json` and `skeleton.atlas`, and
+ * hands those findings over as `encoding`, in the order it always printed
+ * them; the model side (`../model/index.ts`) compares the document alone,
+ * which is all a build with no Spine pair writes (`cli_core.ts build`). So
+ * the model's clause is written once, here, and the two sides cannot spell it
+ * apart. When neither side was handed a second compile — a re-gate of files on
+ * disk — there is nothing determinate about a comparison that never ran, and
+ * it SKIPs with the reason the round trip always gave (the vacuous-pass trap
+ * `A09` is guarded against too).
+ *
+ * Moved out of `src/validate.ts` unchanged but for the seam; `firstDifferingLine`
+ * moved with it, the one reader of it.
+ */
+import type { Verdicts } from '../harness.ts';
+
+const A18 = 'A18_DETERMINISTIC_EMIT';
+
+/** What A18 reads: whether a second compile was handed over, the encoding's findings, and the two documents. */
+export interface DeterminismFacts {
+  /** Whether a second, independent compile was handed over — without one the assertion has nothing to compare. */
+  again: boolean;
+  /** The findings of the clauses only one side compares (the Spine pair, on the runtime's), each a detail, in the order they print. */
+  encoding: readonly string[];
+  /** The first compile's model document — `undefined` where the caller handed a second compile and no first document. */
+  first: string | undefined;
+  /** The second compile's model document; read only where `again`. */
+  second: string;
+}
+
+/**
+ * Where two texts first differ, as A18 names it: the 1-based line and each
+ * side's line, trimmed and cut to 120 characters.
+ */
+export function firstDifferingLine(first: string, second: string): string {
+  const a = first.split('\n');
+  const b = second.split('\n');
+  let i = 0;
+  while (i < a.length && i < b.length && a[i] === b[i]) i += 1;
+  const cut = (line: string | undefined): string => (line === undefined ? '(end of text)' : JSON.stringify(line.trim().slice(0, 120)));
+  return `${i + 1}: ${cut(a[i])} first, ${cut(b[i])} second`;
+}
+
+export function a18DeterministicEmit({ fail, skip }: Verdicts, facts: DeterminismFacts): void {
+  if (!facts.again) return skip(A18, 'no second compile to compare against (re-gating artifacts on disk)');
+  for (const detail of facts.encoding) fail(A18, detail);
+  // The model document is compared like the Spine pair (issue #922): it is
+  // written beside them, and a map iterated in an order nothing fixed would
+  // reach it before it reached either of them — the document writes every
+  // `Map` of the model as an array in the map's order. On a build with no
+  // Spine pair it is the only artifact there is to compare.
+  if (facts.first === undefined) {
+    fail(A18, 'a second compile was handed over with no first model document to compare its skeleton.model.json against');
+  } else if (facts.second !== facts.first) {
+    fail(A18, `recompiling produced a different skeleton.model.json (first differing line ${firstDifferingLine(facts.first, facts.second)})`);
+  }
+}

package/src/assertions/bodies/a31.ts

@@ -0,0 +1,61 @@
+/**
+ * A31, restated over the emitted text (issue #1060): the clause
+ * `validate()` runs in `src/validate.ts`, word for word, over the skeleton JSON — the
+ * text rigc wrote, read by rigc's own reader rather than by spine-core's. The
+ * round trip's copy is unchanged and runs in `cli.ts build`; this one runs in
+ * the gate of the entry that links none of the runtime
+ * (`../emitted/index.ts`), and the selftest's `RC28` holds the two to the
+ * same lines on every recipe and on this assertion's mutants.
+ */
+import type { Verdicts } from '../harness.ts';
+import { isObj, type Json } from '../values.ts';
+
+export function a31DrawOrderOffsetsResolve({ fail, skip }: Verdicts, raw: Json | null): void {
+  if (!raw) return skip('A31_DRAW_ORDER_OFFSETS_RESOLVE', 'the skeleton JSON did not parse (A00 owns that failure)');
+  if (!Array.isArray(raw.slots) || !isObj(raw.animations)) {
+    return skip('A31_DRAW_ORDER_OFFSETS_RESOLVE', 'the skeleton declares no slots or no animations');
+  }
+  const slotIndex = new Map<string, number>();
+  (raw.slots as unknown[]).forEach((slot, i) => {
+    if (isObj(slot) && typeof slot.name === 'string') slotIndex.set(slot.name, i);
+  });
+  const slotCount = (raw.slots as unknown[]).length;
+  let sawATimeline = false;
+  for (const [animName, anim] of Object.entries(raw.animations as Json)) {
+    if (!isObj(anim) || !Array.isArray(anim.drawOrder)) continue;
+    sawATimeline = true;
+    (anim.drawOrder as unknown[]).forEach((key, k) => {
+      const at = `animation "${animName}" drawOrder key ${k}`;
+      if (!isObj(key) || !Array.isArray(key.offsets)) return; // no offsets = setup order
+      let previous = -1;
+      for (const entry of key.offsets as unknown[]) {
+        if (!isObj(entry) || typeof entry.slot !== 'string' || typeof entry.offset !== 'number') {
+          fail('A31_DRAW_ORDER_OFFSETS_RESOLVE', `${at}: an offset is not { slot: string, offset: number }`);
+          continue;
+        }
+        const index = slotIndex.get(entry.slot);
+        if (index === undefined) {
+          fail('A31_DRAW_ORDER_OFFSETS_RESOLVE', `${at}: slot "${entry.slot}" is not in the skeleton`);
+          continue;
+        }
+        if (index <= previous) {
+          const detail =
+            `${at}: slot "${entry.slot}" is at index ${index}, after an entry at index ${previous} — ` +
+            'offsets must be in ascending slot order or the loader never finishes reading them';
+          fail('A31_DRAW_ORDER_OFFSETS_RESOLVE', detail);
+          continue;
+        }
+        previous = index;
+        const landing = index + entry.offset;
+        if (!Number.isInteger(entry.offset) || landing < 0 || landing >= slotCount) {
+          fail(
+            'A31_DRAW_ORDER_OFFSETS_RESOLVE',
+            `${at}: slot "${entry.slot}" is at index ${index} and offset ${entry.offset} puts it at ${landing}, ` +
+              `outside the ${slotCount} slots`,
+          );
+        }
+      }
+    });
+  }
+  if (!sawATimeline) return skip('A31_DRAW_ORDER_OFFSETS_RESOLVE', 'no animation carries a drawOrder timeline');
+}

package/src/assertions/bodies/a35.ts

@@ -0,0 +1,160 @@
+/**
+ * A35, restated over the emitted text (issue #1060): the clause
+ * `validate()` runs in `src/validate.ts`, word for word, over the skeleton JSON — the
+ * text rigc wrote, read by rigc's own reader rather than by spine-core's. The
+ * round trip's copy is unchanged and runs in `cli.ts build`; this one runs in
+ * the gate of the entry that links none of the runtime
+ * (`../emitted/index.ts`), and the selftest's `RC28` holds the two to the
+ * same lines on every recipe and on this assertion's mutants.
+ */
+import type { Verdicts } from '../harness.ts';
+import { isObj, type Json } from '../values.ts';
+
+/**
+ * How long the array a deform key edits is, read off one raw attachment — or
+ * `null` when the file does not say.
+ *
+ * The rule is `readVertices`' own: the attachment's `vertices` is coordinates
+ * when its length equals `worldVerticesLength`, and a weight run otherwise. A
+ * deform array is therefore one `x, y` pair per **vertex** in the first case and
+ * one per **bone influence** (`vertices.length / 3`) in the second — the same
+ * count with two different meanings, which is exactly why this measures rather
+ * than assumes.
+ *
+ * `null` for the two shapes that cannot be measured from this object alone: a
+ * type with no vertices at all (nothing to deform, and the parser throws on it),
+ * and a `linkedmesh`, whose geometry belongs to another attachment.
+ */
+function deformArrayLength(att: Json): number | null {
+  const type = typeof att.type === 'string' ? att.type : 'region';
+  let worldVerticesLength: number;
+  if (type === 'mesh') {
+    if (!Array.isArray(att.uvs)) return null;
+    worldVerticesLength = att.uvs.length;
+  } else if (type === 'boundingbox' || type === 'clipping' || type === 'path') {
+    if (typeof att.vertexCount !== 'number') return null;
+    worldVerticesLength = att.vertexCount * 2;
+  } else {
+    return null;
+  }
+  if (!Array.isArray(att.vertices)) return null;
+  const vertices = att.vertices as unknown[];
+  if (vertices.length === worldVerticesLength) return worldVerticesLength;
+  // ⚠️ Weighted, and the length is the INFLUENCE COUNT — which is the sum of the
+  // per-vertex bone counts, not a division of this array's length. The file
+  // holds `boneCount` followed by `boneIndex, x, y, weight` per influence, so a
+  // one-bone vertex is FIVE numbers; `readVertices` unpacks that into three
+  // numbers per influence, which is where the parser's own `/3*2` comes from and
+  // exactly why it cannot be applied to the raw form. Applied here it measured
+  // `gallery/flex`'s 77-vertex leaf at 256.667 against its true 154 and put
+  // A35's bar two thirds too wide on every weighted mesh — the silence A35
+  // exists to break, arriving inside A35.
+  //
+  // Derived here rather than shared with `src/compile.ts`'s own walk on purpose:
+  // the gate re-derives from the emitted file so that it is not checking the
+  // compiler's assumptions with the compiler's code. Both had this wrong, which
+  // is an argument for a control on each and not for one implementation.
+  let influences = 0;
+  for (let i = 0; i < vertices.length; ) {
+    const n = vertices[i++];
+    if (typeof n !== 'number' || !Number.isInteger(n) || n < 1) return null;
+    influences += n;
+    i += n * 4;
+    if (i > vertices.length) return null;
+  }
+  return influences * 2;
+}
+
+export function a35DeformKeysFitTheAttachment({ fail, skip }: Verdicts, raw: Json | null): void {
+  if (!raw) return skip('A35_DEFORM_KEYS_FIT_THE_ATTACHMENT', 'the skeleton JSON did not parse (A00 owns that failure)');
+  if (!isObj(raw.animations)) return skip('A35_DEFORM_KEYS_FIT_THE_ATTACHMENT', 'the skeleton declares no animations');
+  /** skin name -> slot -> attachment, straight off the raw JSON. */
+  const skins = new Map<string, Json>();
+  for (const skin of Array.isArray(raw.skins) ? (raw.skins as unknown[]) : []) {
+    if (isObj(skin) && typeof skin.name === 'string' && isObj(skin.attachments)) {
+      skins.set(skin.name, skin.attachments as Json);
+    }
+  }
+  let sawATimeline = false;
+  let measured = 0;
+  for (const [animName, anim] of Object.entries(raw.animations as Json)) {
+    if (!isObj(anim) || !isObj(anim.attachments)) continue;
+    for (const [skinName, slotMap] of Object.entries(anim.attachments as Json)) {
+      if (!isObj(slotMap)) continue;
+      for (const [slotName, attMap] of Object.entries(slotMap)) {
+        if (!isObj(attMap)) continue;
+        for (const [attName, timelines] of Object.entries(attMap)) {
+          if (!isObj(timelines) || !Array.isArray(timelines.deform)) continue;
+          sawATimeline = true;
+          const at = `animation "${animName}" deform ${skinName}/${slotName}/${attName}`;
+          const attachment = isObj(skins.get(skinName)?.[slotName])
+            ? ((skins.get(skinName)![slotName] as Json)[attName] as unknown)
+            : undefined;
+          if (!isObj(attachment)) {
+            fail(
+              'A35_DEFORM_KEYS_FIT_THE_ATTACHMENT',
+              `${at}: skin "${skinName}" has no attachment "${attName}" on slot "${slotName}"; the parser throws ` +
+                '`Timeline attachment not found`',
+            );
+            continue;
+          }
+          const length = deformArrayLength(attachment);
+          if (length === null) {
+            // A linked mesh takes its geometry from another attachment, so the
+            // raw file cannot state this one's length. Saying nothing beats
+            // inventing a bound: an assertion with a default is how "nothing to
+            // measure" becomes a measurement of the wrong thing.
+            continue;
+          }
+          measured++;
+          const keys = timelines.deform as unknown[];
+          if (keys.length === 0) {
+            fail('A35_DEFORM_KEYS_FIT_THE_ATTACHMENT', `${at}: the key array is empty; the parser skips the timeline in silence`);
+            continue;
+          }
+          keys.forEach((key, k) => {
+            if (!isObj(key)) {
+              fail('A35_DEFORM_KEYS_FIT_THE_ATTACHMENT', `${at} key ${k}: not an object`);
+              return;
+            }
+            const vertices = key.vertices;
+            if (vertices === undefined || vertices === null) return; // "back to setup" — nothing to fit
+            if (!Array.isArray(vertices)) {
+              fail('A35_DEFORM_KEYS_FIT_THE_ATTACHMENT', `${at} key ${k}: vertices is ${JSON.stringify(vertices)}, not an array`);
+              return;
+            }
+            const offset = key.offset === undefined ? 0 : key.offset;
+            if (typeof offset !== 'number' || !Number.isInteger(offset) || offset < 0) {
+              fail('A35_DEFORM_KEYS_FIT_THE_ATTACHMENT', `${at} key ${k}: offset is ${JSON.stringify(key.offset)}`);
+              return;
+            }
+            // ⛔ No parity clause here, and the header says why: an odd `offset`
+            // and an odd-length run are both what a trimmed editor export looks
+            // like, and the parser has no pair arithmetic to be misaligned
+            // against (#262).
+            if (offset + vertices.length > length) {
+              fail(
+                'A35_DEFORM_KEYS_FIT_THE_ATTACHMENT',
+                `${at} key ${k}: the run covers ${offset}..${offset + vertices.length} of a ${length}-long deform ` +
+                  'array; everything past the end is copied into a Float32Array and dropped without a word',
+              );
+            }
+            for (const n of vertices as unknown[]) {
+              if (typeof n !== 'number' || !Number.isFinite(n)) {
+                fail('A35_DEFORM_KEYS_FIT_THE_ATTACHMENT', `${at} key ${k}: the run holds a non-finite value ${JSON.stringify(n)}`);
+                break;
+              }
+            }
+          });
+        }
+      }
+    }
+  }
+  if (!sawATimeline) return skip('A35_DEFORM_KEYS_FIT_THE_ATTACHMENT', 'no animation carries a deform timeline');
+  if (measured === 0) {
+    return skip(
+      'A35_DEFORM_KEYS_FIT_THE_ATTACHMENT',
+      'every deform timeline here keys an attachment whose vertex count the raw file does not state (a linked mesh)',
+    );
+  }
+}

package/src/assertions/emitted/index.ts

@@ -0,0 +1,119 @@
+/**
+ * The round trip's rules, restated over the text rigc emitted (issue #1060,
+ * step 4e of #380) — the half of the gate the entry that links none of
+ * spine-core runs beside the model side (`../model/index.ts`).
+ *
+ * ⭐ **Every one of the 49 is accounted for, by name.** The model side runs
+ * the moved assertions (`MOVED_ASSERTIONS`) over the document. What is left —
+ * the complement, read off `ASSERTION_KIND` rather than listed — is the
+ * round trip's own: A00, A01, A02, A05, A07, A16, A18, A31, A35 at the time of
+ * writing. Each of those but one reads the raw text, not what spine-core
+ * loaded: the atlas's line layout (A07), the skeleton JSON's draw-order
+ * offsets, deform runs, version label, legacy arrays, legacy bone key and
+ * curve arrays (A31, A35, A16, A01, A02, A05), and A18's second compile. So
+ * each is restated here over the same text, by a body under `../bodies/` that
+ * is the round trip's clause word for word, and prints the round trip's line
+ * (`RC28` holds the two on every recipe and on each assertion's mutants).
+ * The one that cannot be is **A00**: it is spine-core's parser loading the
+ * pair, and there is no second reader of the format to stand in for it. It
+ * SKIPs, naming spine-core and where the round trip does run — never a PASS
+ * on nothing. A code the complement grows by that this file does not know is
+ * an internal error, so a new round-trip rule cannot go unrun here in silence.
+ *
+ * Links nothing from the runtime.
+ */
+import { ASSERTION_KIND, type AssertionProfile } from '../kinds.ts';
+import { verdictHarness, type VerdictLists } from '../harness.ts';
+import { MOVED_ASSERTIONS } from '../model/index.ts';
+import type { Verdicts } from '../harness.ts';
+import type { Json } from '../values.ts';
+import { a01NoLegacyToplevelConstraintArrays } from '../bodies/a01.ts';
+import { a02NoBoneTransformKey } from '../bodies/a02.ts';
+import { a05CurveArrayLength } from '../bodies/a05.ts';
+import { a07AtlasTextShape } from '../bodies/a07.ts';
+import { a16SkeletonVersion43 } from '../bodies/a16.ts';
+import { a18DeterministicEmit } from '../bodies/a18.ts';
+import { a31DrawOrderOffsetsResolve } from '../bodies/a31.ts';
+import { a35DeformKeysFitTheAttachment } from '../bodies/a35.ts';
+
+/** What the restated rules read: the emitted texts, the document written beside them, and a second compile's three. */
+export interface EmittedTextInput {
+  skeletonText: string;
+  atlasText: string;
+  /** The document `build` writes — A18 compares it with the second compile's. */
+  modelText: string;
+  /** A second, independent compile's texts; absent, A18 SKIPs as the round trip's does on a re-gate. */
+  reEmit?: { skeletonText: string; atlasText: string; modelText: string };
+  profile: AssertionProfile;
+}
+
+/** The emitted texts as the bodies read them: the skeleton JSON parsed, or `null` where it does not parse. */
+interface EmittedTexts {
+  raw: Json | null;
+  input: EmittedTextInput;
+}
+
+/** A00's SKIP here: what did not run, and where it does. */
+export const SKIP_NO_ROUND_TRIP =
+  "spine-core's parser is the subject of this rule and this entry links none of it — `bun cli.ts build` and `rigc validate` run the round trip, and the selftest and CI run it on every corpus build";
+
+/** The code this file SKIPs rather than restates. */
+const A00 = 'A00_ROUNDTRIP_PARSE';
+
+/**
+ * The restated rules, in `validate()`'s report order — A00's place among them
+ * (after A35, before A16) is the round trip's, so the report reads in the order
+ * the round trip's does.
+ */
+export const EMITTED_TEXT_RULES: ReadonlyArray<{ code: string; run: (v: Verdicts, texts: EmittedTexts) => void }> = [
+  { code: 'A07_ATLAS_TEXT_SHAPE', run: (v, t) => a07AtlasTextShape(v, t.input.atlasText) },
+  { code: 'A31_DRAW_ORDER_OFFSETS_RESOLVE', run: (v, t) => a31DrawOrderOffsetsResolve(v, t.raw) },
+  { code: 'A35_DEFORM_KEYS_FIT_THE_ATTACHMENT', run: (v, t) => a35DeformKeysFitTheAttachment(v, t.raw) },
+  { code: A00, run: (v) => v.skip(A00, SKIP_NO_ROUND_TRIP) },
+  { code: 'A16_SKELETON_VERSION_4_3', run: (v, t) => a16SkeletonVersion43(v, t.raw) },
+  { code: 'A01_NO_LEGACY_TOPLEVEL_CONSTRAINT_ARRAYS', run: (v, t) => a01NoLegacyToplevelConstraintArrays(v, t.raw) },
+  { code: 'A02_NO_BONE_TRANSFORM_KEY', run: (v, t) => a02NoBoneTransformKey(v, t.raw) },
+  { code: 'A05_CURVE_ARRAY_LENGTH', run: (v, t) => a05CurveArrayLength(v, t.raw) },
+  {
+    code: 'A18_DETERMINISTIC_EMIT',
+    run: (v, { input }) => {
+      const again = input.reEmit;
+      const encoding =
+        again === undefined
+          ? []
+          : [
+              ...(again.skeletonText !== input.skeletonText ? ['recompiling produced a different skeleton.json'] : []),
+              ...(again.atlasText !== input.atlasText ? ['recompiling produced a different skeleton.atlas'] : []),
+            ];
+      a18DeterministicEmit(v, { again: again !== undefined, encoding, first: input.modelText, second: again?.modelText ?? '' });
+    },
+  },
+];
+
+/** Every code the model side does not run, read off the registry — what this file must account for. */
+export function roundTripOnlyCodes(): string[] {
+  const moved = new Set(MOVED_ASSERTIONS.map((m) => m.code));
+  return Object.keys(ASSERTION_KIND).filter((code) => !moved.has(code));
+}
+
+/** The restated rules over one build's emitted texts, in `validate()`'s report shape. */
+export function validateEmittedText(input: EmittedTextInput): VerdictLists & { profile: AssertionProfile } {
+  const known = new Set(EMITTED_TEXT_RULES.map((r) => r.code));
+  const unrun = roundTripOnlyCodes().filter((code) => !known.has(code));
+  if (unrun.length > 0) {
+    throw new Error(`internal: ${unrun.join(', ')} runs on neither side here — the model side does not run it and src/assertions/emitted/index.ts neither restates nor SKIPs it`);
+  }
+  const h = verdictHarness(input.profile, ASSERTION_KIND, 'the emitted text');
+  let raw: Json | null = null;
+  try {
+    raw = JSON.parse(input.skeletonText) as Json;
+  } catch (err) {
+    h.fail(A00, `skeleton JSON is not parseable: ${(err as Error).message}`);
+  }
+  for (const rule of EMITTED_TEXT_RULES) {
+    if (rule.code === A00 && raw === null) continue;
+    h.check(rule.code, () => rule.run(h.verdicts, { raw, input }));
+  }
+  const { failures, passed, skipped, profileSkipped, stats } = h;
+  return { failures, passed, skipped, profileSkipped, stats, profile: input.profile };
+}

package/src/assertions/report.ts

@@ -0,0 +1,64 @@
+/**
+ * The profiles a gate judges under, the one the CLI uses when `--profile` is
+ * absent, and the printer of a gate's report — moved here unchanged from
+ * `src/validate.ts` (issue #1060), which re-exports all three: the entry that
+ * links none of spine-core gates a build on the model side
+ * (`./model/index.ts`) and prints its report with the same printer, and
+ * `src/validate.ts` links the runtime. Nothing here links it.
+ */
+import type { AssertionProfile } from './kinds.ts';
+import type { VerdictLists } from './harness.ts';
+
+export const VALIDATE_PROFILES: readonly AssertionProfile[] = ['spine', 'spine-html'];
+
+/**
+ * What the CLI uses when `--profile` is absent — and ONLY the CLI. This is not
+ * `validate()`'s default; that function has none (`ValidateProfile` in
+ * `src/validate.ts` says why).
+ *
+ * `spine` since issue #221. The published package's pitch is "the output imports
+ * into the Spine editor", which is exactly the question `spine` asks, and a
+ * stranger's first build was being judged instead against one renderer's policy
+ * and one project's canvas budget — 14 rules they have no stake in, with the
+ * escape hatch documented only in prose. Defaults beat prose. `spine-html` is
+ * still one flag away, and every report names the profile that judged it.
+ */
+export const CLI_DEFAULT_PROFILE: AssertionProfile = 'spine';
+
+export function reportLines(report: VerdictLists & { profile: AssertionProfile }): string[] {
+  const lines: string[] = [];
+  // The profile goes FIRST and names what it left out. A report that says
+  // "green" without saying which rulebook produced it is the one thing this
+  // switch could make worse than no switch: `--profile spine` green means
+  // "valid Spine", never "passes the renderer policy".
+  const renderer = report.profileSkipped.filter((p) => p.kind === 'renderer').length;
+  const archetype = report.profileSkipped.filter((p) => p.kind === 'archetype').length;
+  lines.push(
+    report.profileSkipped.length === 0
+      ? `  ..    profile ${report.profile} — every assertion applies`
+      : `  ..    profile ${report.profile} — ${renderer} renderer-policy and ${archetype} archetype assertion(s) do not apply`,
+  );
+  for (const name of report.passed) lines.push(`  PASS  ${name}`);
+  for (const s of report.skipped) lines.push(`  SKIP  ${s.assertion}: ${s.reason}`);
+  for (const p of report.profileSkipped) lines.push(`  PROF  ${p.assertion}: ${p.kind} rule, not in profile "${report.profile}"`);
+  for (const f of report.failures) lines.push(`  FAIL  ${f.assertion}: ${f.detail}`);
+  // How many of them MEASURED anything, which is the figure the rows above do
+  // not hand a reader (issue #568). Counting `PASS` lines answers a different
+  // question — before the sweep that closed #568 a run could print seven of
+  // them over a candidate on which five rules had not executed at all.
+  //
+  // ⚠️ Every figure here is a count of ASSERTIONS and not of rows, which is why
+  // the failed side is a Set: `fail()` is called once per finding, so one
+  // assertion can print six `FAIL` lines, and a line-count would report 47 of
+  // 42. The four buckets partition `ASSERTION_NAMES`, so the total is derived
+  // by adding them rather than stated — a `42` written here would be the one
+  // number in the report that no run could contradict.
+  const failed = new Set(report.failures.map((f) => f.assertion));
+  const measured = report.passed.length + failed.size;
+  const total = measured + report.skipped.length + report.profileSkipped.length;
+  lines.push(
+    `  ..    ${total} assertions: ${measured} measured (${report.passed.length} passed, ${failed.size} failed), ` +
+      `${report.skipped.length} skipped, ${report.profileSkipped.length} not in profile "${report.profile}"`,
+  );
+  return lines;
+}