rig-c 0.0.0-stage → 2.20.4

package/src/assertions/bodies/a26.ts

@@ -0,0 +1,61 @@
+/**
+ * A26, the body (issue #1025, cut 4c-4 of #380): the slots array IS the rig's
+ * slot table — nothing out of order and nothing missing.
+ *
+ * Moved out of `src/validate.ts` unchanged but for what it reads: the slots'
+ * names are a fact (`../facts/skeleton_roster.ts`) rather than the raw JSON's
+ * `slots`, and the rig info is the caller's. Why the second half exists (issue
+ * #575) stays above the `check` call in `validate()`.
+ */
+import type { Verdicts } from '../harness.ts';
+import type { SkeletonRosterFacts } from '../facts/skeleton_roster.ts';
+import type { RigInfo } from '../../types.ts';
+
+export function a26SlotDrawOrder({ fail, skip }: Verdicts, { slots }: SkeletonRosterFacts, input: { rig?: RigInfo }): void {
+  if (!input.rig) return skip('A26_SLOT_DRAW_ORDER', 'no rig info (validating a bare directory)');
+  const order = input.rig.slotOrder;
+  if (!order) {
+    return skip(
+      'A26_SLOT_DRAW_ORDER',
+      `the rig "${input.rig.archetype}" declares no canonical slot order, so the emitted order has nothing to disagree with`,
+    );
+  }
+  const names = slots.map((s) => s.name);
+  // ⛔ **No empty-subject SKIP here, and #575 is the whole reason** (#580). The
+  // empty sequence is a subsequence of every table, so before #575 a skeleton
+  // with no slot reported its draw order held and this rule wanted the same
+  // guard its neighbours got. It no longer does: the completeness clause below
+  // reads zero emitted slots against a declared table as EVERY slot lost,
+  // which is the maximal case of exactly the defect #575 filed — so the honest
+  // verdict is a FAIL naming them, and a SKIP here would suppress it. Measured:
+  // with the guard in place a rig declaring one slot beside an artifact
+  // carrying none reported SKIP; with it gone, `"block" is declared and not
+  // emitted`. A26 therefore has no vacuous pass left to convert, the way
+  // `A07_ATLAS_TEXT_SHAPE` has none.
+  let at = 0;
+  for (const name of names) {
+    const found = order.indexOf(name, at);
+    if (found < 0) {
+      const known = order.indexOf(name);
+      fail(
+        'A26_SLOT_DRAW_ORDER',
+        known < 0
+          ? `slot "${name}" is not in the archetype's slot table`
+          : `slot "${name}" is drawn out of order (table position ${known}, after a slot at ${at})`,
+      );
+      return;
+    }
+    at = found + 1;
+  }
+  const emitted = new Set(names);
+  const missing = order.filter((name) => !emitted.has(name));
+  if (missing.length > 0) {
+    fail(
+      'A26_SLOT_DRAW_ORDER',
+      `the rig "${input.rig.archetype}" declares ${order.length} slot(s) and the skeleton has ${names.length}: ` +
+        `${missing.map((name) => `"${name}"`).join(', ')} ${missing.length === 1 ? 'is' : 'are'} declared and ` +
+        'not emitted. A slot nothing fills is emitted with no setup attachment, not dropped — dropping one ' +
+        'moves every slot below it up one index',
+    );
+  }
+}

package/src/assertions/bodies/a27.ts

@@ -0,0 +1,33 @@
+/**
+ * A27, the body (issue #1025, step 4c of #380): the only region on a page is
+ * named for the page's file.
+ *
+ * Moved out of `src/validate.ts` unchanged but for what it reads: the regions
+ * are a fact (`../facts/atlas_regions.ts`). Why the second link of the
+ * attachment -> region -> file chain needs holding stays above the `check`
+ * call in `validate()`.
+ */
+import { basename } from 'node:path';
+import type { Verdicts } from '../harness.ts';
+import type { AtlasRegionFacts } from '../facts/atlas_regions.ts';
+import { SKIP_NO_ATLAS, SKIP_NO_ATLAS_REGION } from '../reasons.ts';
+
+export function a27RegionNameMatchesPageFilename({ fail, skip }: Verdicts, { atlas }: AtlasRegionFacts): void {
+  if (!atlas) return skip('A27_REGION_NAME_MATCHES_PAGE_FILENAME', SKIP_NO_ATLAS);
+  if (atlas.regions.length === 0) return skip('A27_REGION_NAME_MATCHES_PAGE_FILENAME', SKIP_NO_ATLAS_REGION);
+  const perPage = new Map<string, number>();
+  for (const region of atlas.regions) perPage.set(region.page.name, (perPage.get(region.page.name) ?? 0) + 1);
+  for (const region of atlas.regions) {
+    // A real packer puts many regions on one page and the names stop matching
+    // filenames by design. Then this check has nothing to say, so it says
+    // nothing rather than something wrong.
+    if ((perPage.get(region.page.name) ?? 0) !== 1) continue;
+    const expected = basename(region.page.name).replace(/\.png$/i, '');
+    if (region.name !== expected) {
+      fail(
+        'A27_REGION_NAME_MATCHES_PAGE_FILENAME',
+        `region "${region.name}" is the only region on page "${region.page.name}", whose basename is "${expected}"`,
+      );
+    }
+  }
+}

package/src/assertions/bodies/a28.ts

@@ -0,0 +1,70 @@
+/**
+ * A28, the body (issue #1025, step 4c of #380): a ribbon's rows share their
+ * weights. An `archetype` rule.
+ *
+ * This is what makes "length without width" a property of the file rather than
+ * a hope. Both vertices of a row carry the same bones at the same weights, so
+ * whatever the chain does to one it does to the other and their separation can
+ * only rotate — the strip curves and stretches, and never gets fatter. Give one
+ * side a different weight and the strip develops a taper that grows with its
+ * travel, which is the sort of thing that reads as bad art rather than as a bug.
+ *
+ * Moved out of `src/validate.ts` whole: both clauses are about the rig — a
+ * document's ribbon states every vertex's bindings — and the row's shape is
+ * printed as the file holds it, each bone by its index in the roster and each
+ * weight as the runtime's float32. The guard on a skeleton the round trip did
+ * not load stays in `validate()`, which has no facts to hand over then.
+ */
+import type { Verdicts } from '../harness.ts';
+import type { MeshFacts } from '../facts/mesh_attachments.ts';
+import type { RigInfo } from '../../types.ts';
+
+export function a28RibbonRowsShareWeights({ fail, skip }: Verdicts, facts: MeshFacts | null, rig: RigInfo | undefined): void {
+  if (facts === null) return skip('A28_RIBBON_ROWS_SHARE_WEIGHTS', 'the skeleton did not load (A00 owns that failure)');
+  if (!rig) return skip('A28_RIBBON_ROWS_SHARE_WEIGHTS', 'no rig info (validating a bare directory), so no mesh is known to be a ribbon');
+  const kinds = rig.meshKinds;
+  if (!Object.values(kinds).includes('ribbon')) {
+    // Say WHICH kind of "no ribbon" this is. "declares no ribbon" is true of a
+    // cut with no mesh at all, of one whose meshes are authored geometry, and
+    // of one whose meshes are contours — and the last two are cases where a
+    // reader should know that a mesh went unmeasured on purpose.
+    const unpaired = Object.entries(kinds)
+      .filter(([, kind]) => kind === 'authored' || kind === 'contour' || kind === 'segments')
+      .map(([slot, kind]) => `"${slot}" (${kind})`);
+    return skip(
+      'A28_RIBBON_ROWS_SHARE_WEIGHTS',
+      unpaired.length
+        ? `the rig "${rig.archetype}" declares no ribbon mesh on this cut — its mesh slot(s) ${unpaired.join(', ')} have no rows to pair: authored geometry is somebody else's topology, a contour is one silhouette loop, and a segments lattice has cells rather than cross rows`
+        : `the rig "${rig.archetype}" declares no ribbon mesh on this cut`,
+    );
+  }
+  for (const mesh of facts.meshes) {
+    if (!mesh.weights) continue;
+    // 🔗 A LINKED mesh's rows are its source's and are paired there. Skipped
+    // for A21's reason and with A21's failure mode behind it: this reads
+    // `meshKinds` at the LINK's slot, which says nothing about the geometry
+    // the link borrowed, so a link sitting in a ribbon's slot from another
+    // skin would be measured twice and a link to a NON-ribbon in a ribbon's
+    // slot would be measured as a strip it was never built as (issue #691).
+    if (mesh.link !== null) continue;
+    if (rig.meshKinds[mesh.slot] !== 'ribbon') continue;
+    const perVertex = mesh.weights;
+    if (perVertex.length % 2 !== 0) {
+      fail('A28_RIBBON_ROWS_SHARE_WEIGHTS', `ribbon "${mesh.name}" has ${perVertex.length} vertices; a strip has an even count`);
+      continue;
+    }
+    // Perimeter order: left row i is index i, right row i is its mirror.
+    const rows = perVertex.length / 2;
+    for (let i = 0; i < rows; i++) {
+      const left = perVertex[i];
+      const right = perVertex[perVertex.length - 1 - i];
+      const shape = (v: typeof left) => v.map((w) => `${w.bone}:${w.weight.toFixed(6)}`).join(',');
+      if (shape(left) !== shape(right)) {
+        fail(
+          'A28_RIBBON_ROWS_SHARE_WEIGHTS',
+          `ribbon "${mesh.name}" row ${i} has [${shape(left)}] on one side and [${shape(right)}] on the other; its width would change with the chain`,
+        );
+      }
+    }
+  }
+}

package/src/assertions/bodies/a29.ts

@@ -0,0 +1,34 @@
+/**
+ * A29, the body (issue #1025, cut 4c-4 of #380): inward travel stops where the
+ * two masses meet — the measured `stroke.contact_depth`.
+ *
+ * Moved out of `src/validate.ts` unchanged but for what it reads: the travel
+ * is measured over the bone timelines as a fact (`../inward_advance.ts` over
+ * `../facts/bone_timelines.ts`) rather than over the raw JSON, and the rig
+ * info is the caller's. Why the ceiling is a measured fact about the art stays
+ * above the `check` call in `validate()`.
+ */
+import type { Verdicts } from '../harness.ts';
+import type { BoneTimelineFacts } from '../facts/bone_timelines.ts';
+import type { RigInfo } from '../../types.ts';
+import { deepestInwardAdvance } from '../inward_advance.ts';
+
+export function a29StrokeWithinContactDepth({ fail, skip, stats }: Verdicts, facts: BoneTimelineFacts, input: { rig?: RigInfo }): void {
+  const rig = input.rig;
+  if (!rig) return skip('A29_STROKE_WITHIN_CONTACT_DEPTH', 'no rig info (validating a bare directory)');
+  if (!rig.contactDepth) {
+    return skip(
+      'A29_STROKE_WITHIN_CONTACT_DEPTH',
+      'the manifest declares no `stroke.contact_depth`, so this cut has no measured contact ceiling to hold the stroke to',
+    );
+  }
+  const deep = deepestInwardAdvance(facts, rig);
+  stats.contactDepth = rig.contactDepth;
+  stats.deepestAdvance = Math.round(deep.total * 1000) / 1000;
+  if (deep.total > rig.contactDepth + 1e-6) {
+    fail(
+      'A29_STROKE_WITHIN_CONTACT_DEPTH',
+      `${deep.describe()} but the masses meet at ${rig.contactDepth}px — the two plates would interpenetrate`,
+    );
+  }
+}

package/src/assertions/bodies/a30.ts

@@ -0,0 +1,50 @@
+/**
+ * A30, the body (issue #1025, cut 4c-4 of #380): inward travel stops where the
+ * drawn cover runs out — the measured `stroke.cap_containment_ceiling` — and
+ * no bone under the axis scales while that ceiling is declared.
+ *
+ * Moved out of `src/validate.ts` unchanged but for what it reads: the travel
+ * and the scale timelines are read off the bone timelines as a fact
+ * (`../facts/bone_timelines.ts`, through `../inward_advance.ts`) rather than
+ * off the raw JSON, and the rig info is the caller's. Why this is not a
+ * restatement of A29, and why a scale key is refused rather than measured,
+ * stay above the `check` call in `validate()`.
+ */
+import type { Verdicts } from '../harness.ts';
+import type { BoneTimelineFacts } from '../facts/bone_timelines.ts';
+import type { RigInfo } from '../../types.ts';
+import { deepestInwardAdvance } from '../inward_advance.ts';
+import { isObj } from '../values.ts';
+
+export function a30StrokeWithinCapContainment({ fail, skip, stats }: Verdicts, facts: BoneTimelineFacts, input: { rig?: RigInfo }): void {
+  const rig = input.rig;
+  if (!rig) return skip('A30_STROKE_WITHIN_CAP_CONTAINMENT', 'no rig info (validating a bare directory)');
+  if (!rig.capContainmentCeiling) {
+    return skip(
+      'A30_STROKE_WITHIN_CAP_CONTAINMENT',
+      'the manifest declares no `stroke.cap_containment_ceiling`, so this cut has no measured containment ceiling',
+    );
+  }
+  const deep = deepestInwardAdvance(facts, rig);
+  stats.capCeiling = rig.capContainmentCeiling;
+  stats.deepestAdvance = Math.round(deep.total * 1000) / 1000;
+  if (deep.total > rig.capContainmentCeiling + 1e-6) {
+    fail(
+      'A30_STROKE_WITHIN_CAP_CONTAINMENT',
+      `${deep.describe()} but the leading contour leaves the occluder's opaque footprint at ` +
+        `${rig.capContainmentCeiling}px — the part would be drawn where it should be covered`,
+    );
+  }
+  const subtree = new Set(rig.axisSubtree);
+  for (const { animation: animName, bone: boneName, timelines } of facts.boneTimelines) {
+    if (!subtree.has(boneName) || !isObj(timelines)) continue;
+    for (const name of Object.keys(timelines)) {
+      if (name !== 'scale' && name !== 'scalex' && name !== 'scaley') continue;
+      fail(
+        'A30_STROKE_WITHIN_CAP_CONTAINMENT',
+        `"${animName}" gives "${boneName}" a ${name} timeline while a cap-containment ceiling is declared; ` +
+          'the ceiling was measured on the undeformed contour, so a scaled plate is outside its evidence',
+      );
+    }
+  }
+}

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

@@ -0,0 +1,44 @@
+/**
+ * A32, the body (issue #1025, cut 4c-4 of #380): an event key that sets
+ * `volume` or `balance` fires an event that declares an audio path — and the
+ * clauses that stay with the round trip, printed where they always printed.
+ *
+ * Split per clause (`../facts/event_keys.ts`). The rig's clause moved here: a
+ * readable document can state a key's `volume` on an event with no `audio`,
+ * and the file the emitter writes from it is the file this clause refuses. The
+ * other four — no string `name`, an undeclared event, a time that is not a
+ * finite number, a time before the key before it — are states the model
+ * document's reader refuses by name, so no readable document reaches them;
+ * `validate()` runs them over the skeleton JSON and hands their findings in
+ * (`kept`), and this body prints them at their place, in their order, before
+ * the moved clause and instead of it where one ended the key's reading. The
+ * three failure modes and why the rule reads the raw JSON stay above the
+ * `check` call in `validate()`.
+ */
+import type { Verdicts } from '../harness.ts';
+import type { EventKeyFacts } from '../facts/event_keys.ts';
+
+/** Where a key is, as every A32 line names it — the kept clauses in `src/validate.ts` name it this way too. */
+export function eventKeyAt(animation: string, index: number): string {
+  return `animation "${animation}" event key ${index}`;
+}
+
+export function a32EventKeysResolve({ fail, skip }: Verdicts, facts: EventKeyFacts): void {
+  if (!facts.parsed) return skip('A32_EVENT_KEYS_RESOLVE', 'the skeleton JSON did not parse (A00 owns that failure)');
+  if (!facts.animations) return skip('A32_EVENT_KEYS_RESOLVE', 'the skeleton declares no animations');
+  for (const key of facts.keys) {
+    for (const finding of key.kept) fail('A32_EVENT_KEYS_RESOLVE', finding);
+    if (key.stopped) continue;
+    const at = eventKeyAt(key.animation, key.index);
+    for (const field of ['volume', 'balance'] as const) {
+      if (key.sets[field] && !key.audio) {
+        fail(
+          'A32_EVENT_KEYS_RESOLVE',
+          `${at}: "${key.name}" sets ${field}, but the event declares no audio path — the parser reads ` +
+            `${field} only for an event that has one, so it is dropped in silence`,
+        );
+      }
+    }
+  }
+  if (facts.timelines === 0) return skip('A32_EVENT_KEYS_RESOLVE', 'no animation carries an event timeline');
+}

package/src/assertions/bodies/a33.ts

@@ -0,0 +1,110 @@
+/**
+ * A33, the body (issue #1025, step 4c of #380): bounding boxes, clipping
+ * polygons and paths hold a real polygon, a path's curve lengths strictly
+ * increase, and a clip ends at a slot of the skeleton.
+ *
+ * These types are the same shape — a polygon and nothing else — and they
+ * fail the same ways, all silent:
+ *
+ *   1. **A missing or wrong `vertexCount`.** The parser reads
+ *      `map.vertexCount << 1` and hands it to `readVertices` as the length to
+ *      expect (`:552`, `:632`). `undefined << 1` is 0, so an omission makes
+ *      the coordinate array read as a WEIGHTED run: it decodes numbers as
+ *      bone counts and weights, and the attachment ends up with no vertices
+ *      at all. Nothing throws, and neither type draws a pixel, so nothing
+ *      downstream notices either.
+ *   2. **A weighted run that does not decode to that many vertices.** Same
+ *      trap as a mesh's (A04), minus the uvs that would have caught it.
+ *   3. **A clipping `end` naming a slot that is not there.**
+ *      `skeletonData.findSlot` returns null on a miss and `:626-627` assigns
+ *      the null, so the clip does not end where it was told to — it runs to
+ *      the bottom of the draw order and takes every slot below it with it.
+ *      Checked on what the file states, because a null `endSlot` and an `end`
+ *      that was never written are the same loaded object.
+ *
+ * Moved out of `src/validate.ts` clause by clause. The path clauses, the
+ * clip's end and a polygon's vertex count are about the rig — a document's
+ * polygon states its count and its vertices, a path its `closed` and
+ * `lengths`, a clip its `end` — and moved. The decode of a weighted run and
+ * the length of an unweighted array (the second failure above) are about the
+ * encoding: the document states the weighted form outright and names bones.
+ * They stay with the round trip, which hands their findings in as each
+ * polygon's `encoding`, printed where the body always printed them.
+ */
+import type { Verdicts } from '../harness.ts';
+import type { PolygonFacts } from '../facts/vertex_polygons.ts';
+
+export function a33VertexAttachmentGeometry({ fail, skip }: Verdicts, { polygons, clipEnds, slots }: PolygonFacts): void {
+  const paths = polygons.filter((p) => p.path !== null);
+  for (const path of paths) {
+    const what = path.what;
+    const vertexCount = path.worldVerticesLength / 2;
+    if (vertexCount % 3 !== 0) {
+      fail(
+        'A33_VERTEX_ATTACHMENT_GEOMETRY',
+        `${what} has ${vertexCount} vertices, which is not a multiple of 3 — a path is knots and Bezier ` +
+          'handles read in groups of three, and `Utils.newArray(vertexCount / 3, 0)` accepts the fractional ' +
+          'size without a word, so the curves straddle the knots',
+      );
+      continue;
+    }
+    // Curves: 3K + 1 chain points. An open path drops the first and last
+    // vertex (the end knots' outer handles), a closed one repeats the first.
+    const curves = path.path?.closed ? vertexCount / 3 : vertexCount / 3 - 1;
+    if (curves < 1) {
+      fail('A33_VERTEX_ATTACHMENT_GEOMETRY', `${what} has ${vertexCount} vertices, which is not one whole curve`);
+      continue;
+    }
+    // `lengths` is what a `constantSpeed: false` traversal measures with:
+    // `lengths[curve]` bounds each curve and the last entry IS the path
+    // length. The parser sizes the array from `vertexCount / 3` and copies
+    // whatever the file gave, so a short array leaves trailing zeros — and a
+    // zero-length curve makes the parser divide the position by it.
+    const lengths = path.path?.lengths ?? [];
+    let previous = 0;
+    for (let c = 0; c < curves; c++) {
+      const value = lengths[c];
+      if (!Number.isFinite(value) || value <= previous) {
+        fail(
+          'A33_VERTEX_ATTACHMENT_GEOMETRY',
+          `${what} lengths[${c}] is ${String(value)}, and the entry before it was ${previous}. The array is the ` +
+            'CUMULATIVE arc length at the end of each of the ' +
+            `${curves} curve(s), so it strictly increases; a value that does not means either a zero-length ` +
+            'curve (the position is divided by it) or an array shorter than the geometry (the tail reads as 0)',
+        );
+        break;
+      }
+      previous = value;
+    }
+  }
+  const slotNames = new Set(slots);
+  let endsChecked = 0;
+  for (const { placeholder, slot: slotName, end } of clipEnds) {
+    endsChecked++;
+    if (typeof end !== 'string' || !slotNames.has(end)) {
+      fail(
+        'A33_VERTEX_ATTACHMENT_GEOMETRY',
+        `clipping attachment "${placeholder}" on slot "${slotName}" ends at ${JSON.stringify(end)}, ` +
+          'which is not a slot of this skeleton — the clip would run to the bottom of the draw order',
+      );
+    }
+  }
+  if (polygons.length === 0 && endsChecked === 0) {
+    return skip(
+      'A33_VERTEX_ATTACHMENT_GEOMETRY',
+      'the skeleton carries no bounding box, clipping attachment or path',
+    );
+  }
+  for (const { what, worldVerticesLength: length, encoding } of polygons) {
+    if (!Number.isInteger(length) || length < 6 || length % 2 !== 0) {
+      fail(
+        'A33_VERTEX_ATTACHMENT_GEOMETRY',
+        `${what} loaded worldVerticesLength ${length}; a polygon is an even count of at least 6 (3 vertices). ` +
+          'A missing "vertexCount" reads as 0 and takes the polygon with it',
+      );
+      continue;
+    }
+    // The vertex run's own coherence is the encoding's, kept with the round trip (the header).
+    for (const detail of encoding) fail('A33_VERTEX_ATTACHMENT_GEOMETRY', detail);
+  }
+}

package/src/assertions/bodies/a34.ts

@@ -0,0 +1,133 @@
+/**
+ * A34, the body (issue #1025, cut 4c-5 of step 4c of #380): a constraint
+ * timeline aims at a constraint of that type.
+ *
+ * The argument — the two shapes, the lookup by name AND type, the empty key
+ * array the parser skips in silence, the physics group that names no
+ * constraint — stands above the `check` call in `validate()`.
+ *
+ * Moved out of `src/validate.ts` whole, every clause with it (cut 4c-4
+ * deferred it whole because its one rig clause shares this walk with the
+ * physics branch): which constraint an entry names, what it holds and whom a
+ * physics timeline naming none reaches are the rig's, and a document's records
+ * state each — except what no readable document can carry, which only the
+ * Spine text holds (a name the skeleton lacks, a name of another type, an
+ * empty key array, a bare key array where named timelines go): the model
+ * side's walk never meets those, and the reader refuses the document that
+ * would state them.
+ */
+import type { Verdicts } from '../harness.ts';
+import type { ConstraintTargetFacts, TargetKeyArray } from '../facts/constraint_targets.ts';
+import { CHANNELS_BY_KIND } from '../../timelines.ts';
+
+export function a34ConstraintTimelineTargets({ fail, skip }: Verdicts, facts: ConstraintTargetFacts): void {
+  if (facts.groupsByAnimation === null) return skip('A34_CONSTRAINT_TIMELINE_TARGETS', 'the skeleton declares no animations');
+  // name -> the KINDS declared under it, because that is the namespace the
+  // lookup this assertion is about resolves in: `findConstraint(name, type)`
+  // tests the type first, so a skeleton may carry `leg` as an ik constraint
+  // AND as a transform one and each group finds its own (issue #692). A map
+  // keyed by the name alone let the second of a pair overwrite the first, and
+  // this assertion then reported a correct file as a type mismatch.
+  const kindsOf = new Map<string, string[]>();
+  for (const entry of facts.constraints) {
+    if (entry.name !== null) kindsOf.set(entry.name, [...(kindsOf.get(entry.name) ?? []), entry.type]);
+  }
+  /** The file's physics constraints, which the unnamed physics group is read against. */
+  const rawPhysics = facts.constraints.filter((entry) => entry.type === 'physics');
+  let sawATimeline = false;
+  /** One target of one group: the name resolves, the type matches, keys exist. */
+  const checkTarget = (at: string, group: string, name: string, keyArrays: readonly TargetKeyArray[]): void => {
+    sawATimeline = true;
+    const declared = kindsOf.get(name) ?? [];
+    if (declared.length === 0) {
+      const known = [...kindsOf.entries()].filter(([, kinds]) => kinds.includes(group)).map(([n]) => n);
+      fail(
+        'A34_CONSTRAINT_TIMELINE_TARGETS',
+        `${at}: the skeleton's constraints array has no "${name}"` +
+          (known.length ? ` (${group} constraints: ${known.join(', ')})` : `, and no ${group} constraint at all`),
+      );
+      return;
+    }
+    if (!declared.includes(group)) {
+      fail(
+        'A34_CONSTRAINT_TIMELINE_TARGETS',
+        `${at}: "${name}" is declared as a "${declared.join('"/"')}" constraint, so the ${group} lookup misses it and the loader throws`,
+      );
+      return;
+    }
+    checkKeys(at, keyArrays);
+  };
+  /** The key arrays of one group entry that resolved: each one is walked, so each has to hold a key. */
+  const checkKeys = (at: string, keyArrays: readonly TargetKeyArray[]): void => {
+    if (keyArrays.length === 0) {
+      fail(
+        'A34_CONSTRAINT_TIMELINE_TARGETS',
+        `${at}: the constraint is named and carries no timeline at all; the group is walked and nothing happens`,
+      );
+      return;
+    }
+    for (const { timeline, keys } of keyArrays) {
+      if ('count' in keys && keys.count > 0) continue;
+      fail(
+        'A34_CONSTRAINT_TIMELINE_TARGETS',
+        `${at}${timeline ? ` timeline "${timeline}"` : ''}: the key array is ` +
+          `${'count' in keys ? 'empty' : keys.spelled}; the parser reads key 0, finds nothing and ` +
+          'skips the whole timeline without a word',
+      );
+    }
+  };
+  for (const { name: animName, groups } of facts.groupsByAnimation) {
+    for (const { group, entries } of groups) {
+      for (const { name, bare, keyArrays } of entries) {
+        // group.<constraint> = keys[]
+        if (group === 'ik' || group === 'transform') {
+          checkTarget(`animation "${animName}" ${group} timeline "${name}"`, group, name, keyArrays);
+          continue;
+        }
+        // group.<constraint>.<timeline> = keys[]
+        const at = `animation "${animName}" ${group} constraint "${name}"`;
+        if (bare !== null) {
+          sawATimeline = true;
+          fail(
+            'A34_CONSTRAINT_TIMELINE_TARGETS',
+            `${at}: this group maps a constraint to NAMED timelines ` +
+              `(${Object.keys(CHANNELS_BY_KIND[group]).join('/')}), and this one holds ${bare} — ` +
+              'a bare key array here is the ik/transform shape and is walked as an object',
+          );
+          continue;
+        }
+        // The empty name is not a miss: it is the physics group's global form,
+        // which `SkeletonJson` loads as `constraintIndex -1` rather than looking
+        // anything up, and which writes every physics constraint that declares
+        // the timeline's property global (issue #726). Refusing it as "no
+        // constraint called ''" was a sentence that is false about the file.
+        // What CAN be wrong with it is that it reaches nobody: the parser
+        // accepts it, the runtime walks every constraint, and none of them
+        // takes the key.
+        if (group === 'physics' && name === '') {
+          sawATimeline = true;
+          for (const { timeline: timelineName } of keyArrays) {
+            const reach = facts.reach(timelineName);
+            // A name the parser skips is skipped here too: no timeline exists
+            // to reach anybody, and whether the NAME is right is not a target
+            // question.
+            if (reach === null || reach.reached.length > 0) continue;
+            fail(
+              'A34_CONSTRAINT_TIMELINE_TARGETS',
+              `${at} timeline "${timelineName}": a physics group that names no constraint writes every physics ` +
+                `constraint ${reach.resets ? 'the skeleton has' : `declaring "${timelineName}Global": true`}, and ` +
+                (rawPhysics.length === 0 ? 'the skeleton has no physics constraint' : `none of ${rawPhysics.map((one) => `"${one.spelled}"`).join(', ')} does`) +
+                ' — the parser loads it, the runtime walks every constraint, and no constraint takes the key',
+            );
+          }
+          checkKeys(at, keyArrays);
+          continue;
+        }
+        checkTarget(at, group, name, keyArrays);
+      }
+    }
+  }
+  if (!sawATimeline) {
+    return skip('A34_CONSTRAINT_TIMELINE_TARGETS', 'no animation carries a constraint timeline');
+  }
+}