spine-rigc 1.9.3 → 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/a06.ts

@@ -18,12 +18,61 @@ import { SKIP_NO_ATLAS, SKIP_NO_ATLAS_PAGE } from '../reasons.ts';
 import { pageFootprint, pageGridSentence } from '../../atlas.ts';
 import { readPngHeader } from '../../png.ts';
 
-export function a06AtlasPageSizeMatchesPng({ fail, skip }: Verdicts, { atlas }: AtlasRegionFacts, input: { atlasDir: string }, policy: boolean): void {
+export function a06AtlasPageSizeMatchesPng({ fail: failed, skip }: Verdicts, { atlas }: AtlasRegionFacts, input: { atlasDir: string }, policy: boolean): void {
   if (!atlas) return skip('A06_ATLAS_PAGE_SIZE_MATCHES_PNG', SKIP_NO_ATLAS);
   if (atlas.pages.length === 0) return skip('A06_ATLAS_PAGE_SIZE_MATCHES_PNG', SKIP_NO_ATLAS_PAGE);
+  // Every sentence this body prints goes through here, so the end of the body
+  // can tell "nothing failed" from "something failed" (issue #1055, below).
+  let failures = 0;
+  const fail = (assertion: string, detail: string): void => {
+    failures++;
+    failed(assertion, detail);
+  };
+  // 🔒 **A page whose file is not on disk is a page whose size was not
+  // measured, and the body says so rather than passing** (issue #1055). Until
+  // this the loop below walked past such a page and the assertion came out
+  // PASS — on a build with every page file deleted, a PASS over a size clause
+  // that had opened nothing, measured on 33 of the 38 recipe-and-profile
+  // pairs of the tree's 19 recipes (the other five failed clauses that read
+  // only the atlas's numbers: overlap and rotation, under `spine-html`). What the body does instead is decided by what `A17` prints on
+  // the same input, so that one missing file is named once, by the rule whose
+  // subject it is: A17 FAILs naming every such file and its path, which keeps
+  // the report red; this body adds no FAIL of its own about the file (a
+  // second naming), and it does not PASS (a certificate over a size nobody
+  // read). It SKIPs with a reason that names the pages it did not read and
+  // points at A17 — `unreadSizes` below, at both of the body's exits.
+  //
+  // ⚠️ Only when nothing else here failed. `skip()` is per assertion, and a
+  // skip beside failures puts A06 in two of the report's buckets (the #705
+  // argument in `a19.ts`); and a FAIL certifies nothing, so the unread page
+  // is A17's alone there. ⚠️ Not the tree's other multi-clause rule either
+  // (`../reasons.ts`, #580: a multi-clause assertion SKIPs only when EVERY
+  // clause had nothing to measure). That rule is about a clause whose subject
+  // list is EMPTY — zero is a count, and a count was measured. A page the
+  // atlas declares is a member of the size clause's subject that is present
+  // and was not read, and the PASS this replaces claimed it was.
+  const unread: string[] = [];
+  const unreadSizes = (): void => {
+    if (failures > 0 || unread.length === 0) return;
+    const total = atlas.pages.length;
+    skip(
+      'A06_ATLAS_PAGE_SIZE_MATCHES_PNG',
+      unread.length === total
+        ? `no page's size was measured: none of the ${total} page file(s) the atlas declares is on disk, which ` +
+            "A17_ATLAS_PAGE_FILES_EXIST names file by file. The clauses that read only the atlas's own numbers found " +
+            "nothing to fail, and that is not a pass while every page's size is unread"
+        : `the size of ${unread.length} of the ${total} page(s) the atlas declares was not measured — ` +
+            `${unread.map((name) => JSON.stringify(name)).join(', ')} — because the file is not on disk, which ` +
+            `A17_ATLAS_PAGE_FILES_EXIST names. The ${total - unread.length} page(s) that were read, and the clauses ` +
+            "that read only the atlas's own numbers, found nothing to fail, and that is not a pass while a page's size is unread",
+    );
+  };
   for (const page of atlas.pages) {
     const abs = resolve(input.atlasDir, page.name);
-    if (!existsSync(abs)) continue; // A17 owns this
+    if (!existsSync(abs)) {
+      unread.push(page.name); // A17 names the file; this body says only that it did not read it
+      continue;
+    }
     // 🔒 **A page that is not a PNG is a named failure, not a throw** (issue
     // #732). The reader's throw used to reach this rule's catch and print as
     // `threw: not a PNG (bad signature)`: the verdict right, the sentence a
@@ -118,7 +167,7 @@ export function a06AtlasPageSizeMatchesPng({ fail, skip }: Verdicts, { atlas }:
       );
     }
   }
-  if (!policy) return;
+  if (!policy) return unreadSizes();
   // ⭐ **One part per page OR a tiling page** (issue #266, follow-up 2). This
   // clause used to be the first alternative alone — every region's UVs
   // `(0,0)-(1,1)` — which is rigc's *unpacked* convention and exactly what
@@ -192,4 +241,5 @@ export function a06AtlasPageSizeMatchesPng({ fail, skip }: Verdicts, { atlas }:
       );
     }
   }
+  unreadSizes();
 }

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/a19.ts

@@ -21,13 +21,20 @@ import { colourTypeName, readPngHeader } from '../../png.ts';
 import { readPlate } from '../../../tools/plate.ts';
 import type { RigInfo } from '../../types.ts';
 
-export function a19OverlayPngsHaveAlpha({ fail, skip }: Verdicts, { atlas }: AtlasRegionFacts, stage: StageFacts, { regionAttachments }: Pick<SkinEntryFacts, 'regionAttachments'>, input: { atlasDir: string; rig?: RigInfo }): void {
+export function a19OverlayPngsHaveAlpha({ fail: failed, skip }: Verdicts, { atlas }: AtlasRegionFacts, stage: StageFacts, { regionAttachments }: Pick<SkinEntryFacts, 'regionAttachments'>, input: { atlasDir: string; rig?: RigInfo }): void {
   // A SKIP for the same reason A06's is (#568). This one is invisible under
   // `spine`, where the profile excludes the rule before its body runs — and
   // that is exactly why it was worth finding: `--profile spine-html` reported
   // it, and A27 below, green on an atlas nothing had read.
   if (!atlas) return skip('A19_OVERLAY_PNGS_HAVE_ALPHA', SKIP_NO_ATLAS);
   if (atlas.pages.length === 0) return skip('A19_OVERLAY_PNGS_HAVE_ALPHA', SKIP_NO_ATLAS_PAGE);
+  // Every sentence this body prints goes through here, so its end can tell
+  // "nothing failed" from "something failed" (issue #1055, at the page loop).
+  let failures = 0;
+  const fail = (assertion: string, detail: string): void => {
+    failures++;
+    failed(assertion, detail);
+  };
   const stageW = stage.width ?? 0;
   const stageH = stage.height ?? 0;
   // 🔒 **Which image is the base plate is decided ONCE, and the rig's own
@@ -96,10 +103,34 @@ export function a19OverlayPngsHaveAlpha({ fail, skip }: Verdicts, { atlas }: Atl
     if (on) on.push(region);
     else sharedPages.set(region.page.name, [region]);
   }
+  // 🔒 **A page whose file is not on disk is a page whose parts were not
+  // read, and the body says so rather than passing** (issue #1055). Until
+  // this the loop walked past such a page, and on a build with every page
+  // file deleted the assertion printed PASS on all 19 of the tree's recipes
+  // under `spine-html` having opened nothing. The rule for what it prints
+  // instead is `a06.ts`'s, read off what `A17` prints on the same input: A17
+  // FAILs naming each missing file, so the report is already red and the file
+  // already named; a FAIL here would be the second naming and a PASS a
+  // certificate over alpha nobody read. So the body SKIPs, naming the pages it
+  // did not read and pointing at A17 — only when it failed nothing else,
+  // because `skip()` is per assertion (#705's argument, below) and a FAIL
+  // certifies nothing.
+  //
+  // ⚠️ A page counts only when it carries a part this rule judges, by the
+  // predicate the non-PNG branch below uses: a missing page holding nothing
+  // but the base plate had nothing for this rule to read either way, so it
+  // moves nothing here (the size it was not measured at is `A06`'s to say).
+  let pagesWithParts = 0;
+  const unread: string[] = [];
   for (const page of atlas.pages) {
     const abs = resolve(input.atlasDir, page.name);
-    if (!existsSync(abs)) continue;
     const on = sharedPages.get(page.name) ?? [];
+    const carriesPart = on.length > 1 ? on.some((region) => !baseRegions.has(region.name)) : !basePages.has(page.name);
+    if (carriesPart) pagesWithParts++;
+    if (!existsSync(abs)) {
+      if (carriesPart) unread.push(page.name); // A17 names the file; this body says only that it did not read it
+      continue;
+    }
     // 🔒 **A page that is not a PNG is a non-measurement for every part on
     // it** (issue #732), stated the way #705's and #715's are: a FAIL naming
     // what was not read, because `skip()` is per assertion and would delete
@@ -292,4 +323,15 @@ export function a19OverlayPngsHaveAlpha({ fail, skip }: Verdicts, { atlas }: Atl
         'spine does not run this check.',
     );
   }
+  if (failures > 0 || unread.length === 0) return;
+  skip(
+    'A19_OVERLAY_PNGS_HAVE_ALPHA',
+    unread.length === pagesWithParts
+      ? `no part's alpha was read: none of the ${pagesWithParts} page file(s) carrying a part is on disk, which ` +
+          'A17_ATLAS_PAGE_FILES_EXIST names file by file, and that is not a pass while every part is unread'
+      : `${unread.length} of the ${pagesWithParts} page(s) carrying a part were not read — ` +
+          `${unread.map((name) => JSON.stringify(name)).join(', ')} — because the file is not on disk, which ` +
+          `A17_ATLAS_PAGE_FILES_EXIST names. Every part on the ${pagesWithParts - unread.length} page(s) that were ` +
+          "read can draw a transparent pixel, and that is not a pass while a part's alpha is unread",
+  );
 }

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)',
+    );
+  }
+}