spine-rigc 1.8.0 → 1.9.0

package/src/assertions/bodies/a23.ts

@@ -0,0 +1,255 @@
+/**
+ * A23, the body (issue #1025, step 4c of #380): a physics constraint that
+ * does nothing, quietly — at its setup pose, and on every physics key.
+ *
+ * Moved out of `src/validate.ts` whole: every clause is about the rig — the
+ * components a constraint drives, its four bounded setup values, its `fps`,
+ * every value a physics timeline keys and what switches a muted constraint on
+ * — and a document's constraint and timeline records state each. Nothing it
+ * reads is the encoding's. The values are the ones the runtime holds after
+ * its parse, through the facts (`../facts/constraints.ts`): a field left out
+ * at the parser's value, `massInverse` = `1 / mass`, `step` = `1 / fps`, a
+ * key's time and value as float32, a key's value as the pose field it lands
+ * in (`posed`), and the constraints a timeline naming none reaches.
+ */
+import type { Verdicts } from '../harness.ts';
+import type { ConstraintFacts, PhysicsSetup } from '../facts/constraints.ts';
+import type { MeshFacts } from '../facts/mesh_attachments.ts';
+import { noneKeysItsMixAbove0, PHYSICS_COMPONENTS, REST_OR_KEY_ITS_MIX, switchedOn } from '../constraint_words.ts';
+import { SKIP_NO_PHYSICS_CONSTRAINT } from '../reasons.ts';
+import {
+  PHYSICS_POSE_RULES,
+  physicsBasisFor,
+  physicsBasisSays,
+  physicsKeyRefusal,
+  physicsOutsideSays,
+  physicsRuleFor,
+  type PhysicsPoseRule,
+} from '../../timelines.ts';
+
+/**
+ * What A23 says about a SETUP pose outside its bound, per property.
+ *
+ * The predicate lives in `PHYSICS_POSE_RULES` and the sentence lives here, and
+ * the split is deliberate: the predicate is the thing the compiler and this file
+ * must not disagree about, while the sentence names what happens to THIS rig —
+ * "it is muted", "nothing pulls it back" — which is what the author acts on and
+ * is worth nothing to a compiler refusing a key. `PHYSICS_POSE_RULES` is the
+ * index, so a rule added there with no sentence here fails to type-check rather
+ * than printing `undefined`.
+ *
+ * ⚠️ These are the SETUP pose's sentences and nothing else, which matters on the
+ * two rows whose keyed bound is wider than their resting one — `mix` since issue
+ * #610 and `strength` since #727. A key of 0 on either is accepted, so "it is
+ * muted" and "nothing pulls it back" are read here by a rig that states the
+ * number at rest, and what a key is refused with is the row's own `why`.
+ *
+ * `animations` is how many animations the skeleton declares, and only the `mix`
+ * sentence reads it: that bound is the one a key can satisfy instead of the
+ * setup pose (`inertAtSetup`, issue #743), so the refusal has to say that the
+ * other half was looked for and how wide the search was. A rig with no animation
+ * at all then says "none of the 0 animations" rather than implying somebody
+ * keyed something.
+ *
+ * `rule` is the row the value was judged by, and every sentence reads it: the
+ * reason each prints is the row's `basis` arm for the value (issue #798), the
+ * same object the key's sentence quotes, so what the setup pose and a key say
+ * about one number is one text — and whether that reason is the runtime's
+ * arithmetic or rigc's call is stated rather than implied.
+ */
+const SETUP_POSE_SAYS: Record<string, (pose: PhysicsSetup, animations: number, rule: PhysicsPoseRule) => string> = {
+  // Every reason below is the row's `basis` arm for the value (issue #798): an
+  // arithmetic arm names its expression, a behavioural one says refusing it is
+  // rigc's call and what the value does. ⚠️ Until then a setup mix BELOW 0 was
+  // told "it is muted", which it is not — [measured] it moves the bone by
+  // exactly −1× what +0.5 does — so the two ways out print two sentences.
+  mix: (pose, animations, rule) =>
+    `has mix ${pose.mix} and ${noneKeysItsMixAbove0(animations)}; ${setupBasisSays(rule, pose.mix)} — ${REST_OR_KEY_ITS_MIX}`,
+  mass: (pose, _animations, rule) => `has massInverse ${pose.massInverse}; mass must be ${rule.states} — ${setupBasisSays(rule, pose.massInverse)}`,
+  // Two arms, read off the row (issue #748): 0 is a constraint nothing pulls
+  // back and below 0 one that is pushed away, and the row's `why` — the key's
+  // sentence — quotes the second from the same object. The basis sentence ends
+  // on the arm's own words, which `T100` holds.
+  strength: (pose, _animations, rule) => `has strength ${pose.strength}; ${setupBasisSays(rule, pose.strength)}`,
+  // The bound is read off the row, so the setup pose and a key cannot state two
+  // intervals; the reason is the arm the value took, since the ends are inside (#794).
+  damping: (pose, _animations, rule) =>
+    `has damping ${pose.damping}; must be ${rule.states} — the per-step decay is \`damping ** (60 * step)\`, and ` +
+    setupBasisSays(rule, pose.damping),
+};
+
+/**
+ * The basis sentence for a setup value, or the bound itself where no arm holds
+ * — a pose value the parser handed over that none of the row's arms is about
+ * (a NaN, say), which has no reason to give and must not borrow another's.
+ */
+function setupBasisSays(rule: PhysicsPoseRule, poseValue: number): string {
+  const arm = physicsBasisFor(rule, poseValue);
+  return arm === undefined ? physicsOutsideSays(rule, poseValue) : physicsBasisSays(arm);
+}
+
+// Every failure mode here is silent. The five component fields default to
+// 0, so a constraint can drive nothing at all; `mix` 0 mutes it; `mass` 0
+// becomes an infinite massInverse; and `damping` above 1 never settles, which
+// on a mesh-driving bone means the canvas re-rasterises forever. 1 itself is
+// inside the bound since issue #794: it never decays, which is finite and a
+// choice, and what it costs a consumer's frame is the consumer's to judge.
+//
+// 🔑 **Two arms, one criterion.** The second arm below reads every physics
+// TIMELINE key, and it is written against `PHYSICS_POSE_RULES` — the table
+// this one is also written against, and the table `compileValueTrack`
+// refuses a spec's own out-of-range number with. Three readings of one rule
+// is how two of them come to disagree, so there is one (issue #610).
+export function a23PhysicsConstraintEffective({ fail, skip, stats }: Verdicts, facts: ConstraintFacts, meshFacts: MeshFacts): void {
+  // ⟨subject⟩_⟨property⟩, and its two siblings already read this way: A36
+  // skips on "the skeleton declares no path constraint" and A37 on "no
+  // slider constraint", while this one passed over an empty filter (#580).
+  // The stat is written before the guard so a reader of a SKIP still sees
+  // the count that produced it.
+  stats.physicsConstraints = facts.constraints.filter((c) => c.physics !== undefined).length;
+  if (stats.physicsConstraints === 0) return skip('A23_PHYSICS_CONSTRAINT_EFFECTIVE', SKIP_NO_PHYSICS_CONSTRAINT);
+  const meshBoneNames = new Set<string>();
+  for (const mesh of meshFacts.meshes) meshBoneNames.add(mesh.slotBone);
+  for (const mesh of meshFacts.meshes) {
+    if (!mesh.weights) continue;
+    for (const vertex of mesh.weights) {
+      for (const { bone: index } of vertex) {
+        const bone = meshFacts.bones[index];
+        if (bone !== undefined) meshBoneNames.add(bone);
+      }
+    }
+  }
+  // --- which constraints an animation switches ON (issue #743) ----------
+  //
+  // 🔑 The setup pose is the rig AT REST, and one of the four bounds is a
+  // state rather than a break there: `PHYSICS_POSE_RULES` marks `mix`
+  // `inertAtSetup`, because `update` opens with `if (mix === 0) return;`
+  // (`PhysicsConstraint.js:109-111`) and nothing else in the pose has such a
+  // branch. So a constraint that rests muted and is keyed above 0 by an
+  // animation is a rig the runtime plays as authored, and refusing it would
+  // refuse a design: physics off at rest, switched on by the animation that
+  // needs it.
+  //
+  // 📏 Measured on a generated physics fixture, 36 steps at 60 fps with the
+  // constraint's own bone swung by its parent: resting at `mix` 0 with an
+  // animation keying `mix` to 1 poses the bone IDENTICALLY to the same rig
+  // resting at 1 (max |dx| 0.000000) and up to 7.771177 away from the twin
+  // that keys nothing — which poses identically to one keyed to 0 only
+  // (max |dx| 0.000000). Two states, and the file says which.
+  //
+  // ⚠️ The escape is the rule's own field rather than the word "mix": a
+  // setup `mass` of 0 is `massInverse` Infinity BEFORE anything plays, and
+  // [measured] at rest it reads NaN on every frame although an animation
+  // keys `mass` to 1. A key cannot rescue a value that has already broken
+  // the rig it is resting in.
+  //
+  // The keys are read by `switchedOn`, the one reading A36 and A37 share
+  // (issue #752), through the runtime's own accessor: the pose field is
+  // where the integrator reads the number, and for `mass` that is not the
+  // number the key states. It counts the unnamed global form through the
+  // timeline's reach and a Bezier segment's samples as well as its keys.
+  const unmuted = new Map<number, Set<string>>();
+  for (const rule of PHYSICS_POSE_RULES) {
+    if (!rule.inertAtSetup) continue;
+    const reached = switchedOn(
+      facts,
+      (timeline) => timeline.kind === 'physics' && timeline.word === rule.timeline,
+      1,
+      (timeline, value) => rule.poseOk(timeline.posed === undefined ? value : timeline.posed(value)),
+    );
+    facts.constraints.forEach((one, index) => {
+      if (one.physics === undefined || !reached.has(index)) return;
+      const by = unmuted.get(index) ?? new Set<string>();
+      by.add(rule.timeline);
+      unmuted.set(index, by);
+    });
+  }
+  let mutedUntilKeyed = 0;
+  facts.constraints.forEach((constraint, index) => {
+    const physics = constraint.physics;
+    if (physics === undefined) return;
+    const where = `physics "${constraint.name}"`;
+    const components = PHYSICS_COMPONENTS.filter((k) => physics.components[k] > 0);
+    if (!components.length) {
+      fail('A23_PHYSICS_CONSTRAINT_EFFECTIVE', `${where} drives no component; it parses and does nothing`);
+    }
+    const pose = physics.setup;
+    // The four bounded fields, each judged by its `PHYSICS_POSE_RULES` row.
+    // The wording is per-field and stays so: "it is muted" and "nothing
+    // pulls it back" say what happens to THIS rig, which is what the author
+    // needs, and the shared table supplies the predicate rather than the
+    // sentence.
+    for (const rule of PHYSICS_POSE_RULES) {
+      if (rule.poseOk(pose[rule.field])) continue;
+      if (rule.inertAtSetup && unmuted.get(index)?.has(rule.timeline)) {
+        mutedUntilKeyed++;
+        continue;
+      }
+      const drivesAMesh = rule.timeline === 'damping' && meshBoneNames.has(physics.bone);
+      fail(
+        'A23_PHYSICS_CONSTRAINT_EFFECTIVE',
+        `${where} ${SETUP_POSE_SAYS[rule.timeline](pose, facts.animations, rule)}` +
+          (drivesAMesh ? ' — and this bone drives a mesh, so the canvas never rests' : ''),
+      );
+    }
+    if (physics.step <= 0 || !Number.isFinite(physics.step)) {
+      fail('A23_PHYSICS_CONSTRAINT_EFFECTIVE', `${where} has step ${physics.step} (fps must be > 0)`);
+    }
+  });
+  // What the PASS would otherwise not say: this rig rests with physics off
+  // on that many constraints and an animation is what switches them on. A
+  // pass carries no detail — `passed` is a list of names — so `stats` is the
+  // channel that exists, and a number is what belongs in a line printed as
+  // `k=v`: naming every such constraint and the animations that reach it
+  // would be a paragraph on one line, and the rig where nobody meant it is
+  // the rig where the NUMBER is the surprise. Absent rather than 0 when
+  // nothing rests muted, so it appears only where it says something.
+  if (mutedUntilKeyed) stats.physicsMutedUntilKeyed = mutedUntilKeyed;
+
+  // --- the same criterion, on every physics timeline key (issue #610) ----
+  //
+  // The arm above reads the setup pose and, until this one existed, nothing
+  // else — complete while a motion spec could key `mix` and `reset` only,
+  // and incomplete from #593 on, when it became able to key all seven.
+  //
+  // 📏 Measured on the tree before this landed, one keyed value at a time on
+  // a generated physics rig, 24 steps at 60 fps: `mass: 0` reached
+  // `massInverse` Infinity and every offset NaN — named by
+  // `A10_NO_NAN_AFTER_STEPPING`, from the BONE, with no word about the
+  // animation, the constraint, the timeline or the key; `damping: 2` ran the
+  // x offset to −26,634 and the velocity to −1.55e6 and still climbing, with
+  // **zero** gate failures; `strength: 0` drifted monotonically with zero gate
+  // failures; `mix: 1.5` produced zero gate failures and an integration
+  // identical to `mix: 1`, because mix multiplies the finished offset onto
+  // the bone and never enters the solve.
+  //
+  // ⭐ The value is judged where the runtime keeps it, not where the file
+  // writes it: `posed` is the number the runtime's own accessor writes, so a
+  // `mass` key lands as its reciprocal and is then held to exactly the
+  // predicate the setup arm holds `massInverse` to.
+  let keysRead = 0;
+  for (const timeline of facts.timelines) {
+    // A `reset` timeline keys no value, and was never one of the seven the pose holds.
+    if (timeline.kind !== 'physics' || timeline.word === 'reset') continue;
+    const name = timeline.word;
+    const rule = physicsRuleFor(name);
+    // -1 is the global form: the timeline drives every physics constraint
+    // whose matching `…Global` flag is set, so there is no one name to give.
+    const target =
+      timeline.constraint === -1
+        ? 'every physics constraint'
+        : `physics "${facts.constraints[timeline.constraint]?.name ?? `#${timeline.constraint}`}"`;
+    for (const frame of timeline.frames) {
+      keysRead++;
+      if (rule === undefined) continue;
+      const value = frame.value;
+      const refusal = physicsKeyRefusal(rule, value, timeline.posed === undefined ? undefined : timeline.posed(value));
+      if (refusal === null) continue;
+      fail(
+        'A23_PHYSICS_CONSTRAINT_EFFECTIVE',
+        `animation "${timeline.animation}" ${target} ${name} key at t=${frame.time.toFixed(6)}s is ${refusal}`,
+      );
+    }
+  }
+  stats.physicsTimelineKeys = keysRead;
+}

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

@@ -0,0 +1,81 @@
+/**
+ * A36, the body (issue #1025, step 4c of #380): a path constraint that
+ * follows nothing, quietly.
+ *
+ * 🚨 The first failure here is the quietest in the whole constraint half of
+ * the format. `PathConstraint.update` opens with
+ *
+ *   const attachment = this.slot.appliedPose.attachment;
+ *   if (!(attachment instanceof PathAttachment)) return;
+ *
+ * so a path constraint aimed at a slot that never shows a path loads
+ * perfectly, reports every mix it was given, appears in the update cache —
+ * and moves nothing, forever. Nothing in the file is wrong on its face: the
+ * slot exists, the constraint resolves, the mixes are 1.
+ *
+ * The rest are the same shape as A23's: a constraint that parses and does
+ * nothing. All three mixes at 0 is only a finding when no animation keys one
+ * of them above 0 (`switchedOn` over the `mix` timelines, judged by
+ * `mixLive`), and a chain with no bones on it is one whether or not anything
+ * is keyed.
+ *
+ * Moved out of `src/validate.ts` whole: the bones, the slot and the skins'
+ * paths, the setup mixes and the keyed ones are all the rig's, and a
+ * document's records state each.
+ */
+import type { Verdicts } from '../harness.ts';
+import type { ConstraintFacts } from '../facts/constraints.ts';
+import { mixLive, noneKeysItsMixAbove0, switchedOn } from '../constraint_words.ts';
+
+export function a36PathConstraintEffective({ fail, skip, stats }: Verdicts, facts: ConstraintFacts): void {
+  const constraints = facts.constraints.flatMap((c, index) => (c.path === undefined ? [] : [{ name: c.name, path: c.path, index }]));
+  if (!constraints.length) return skip('A36_PATH_CONSTRAINT_EFFECTIVE', 'the skeleton declares no path constraint');
+  /**
+   * Which path constraints an animation switches ON — `switchedOn` over their
+   * `mix` timelines, judged by `mixLive`, the predicate their setup pose is
+   * judged by below.
+   *
+   * ⭐ The reason this is needed: a constraint whose mixes are all 0 at setup
+   * is **the idiom**, not a defect — spineboy's aim rig is exactly that, and
+   * issue #88 landed the timelines that turn one on. So "muted" is only a
+   * finding when nothing turns it on, and that question lives in the
+   * animations rather than in the constraint.
+   *
+   * 🔑 "Turns it on" is a VALUE question, and until issue #752 this asked a
+   * weaker one than `A23` — whether a `mix` key array was non-empty — so a
+   * timeline keying 0 only was a rescue for a constraint it leaves exactly as
+   * muted as no timeline does. Now a path constraint is switched on by a key
+   * posing any of its three mixes above 0, which is the runtime's own
+   * condition: `PathConstraint.update` returns when `mixRotate`, `mixX` and
+   * `mixY` are all 0 (`PathConstraint.js:73-75`).
+   */
+  const pathSwitchedOn = switchedOn(facts, (timeline) => timeline.kind === 'path' && timeline.word === 'mix', 3, (_timeline, value) => mixLive(value));
+  /** The slots some skin gives a path attachment. */
+  const pathsBySlot = new Set(facts.pathSlots);
+  for (const { name, path: constraint, index } of constraints) {
+    const where = `path constraint "${name}"`;
+    if (!constraint.bones.length) {
+      fail('A36_PATH_CONSTRAINT_EFFECTIVE', `${where} constrains no bone; it parses and does nothing`);
+    }
+    const slot = constraint.slot;
+    if (!pathsBySlot.has(slot)) {
+      fail(
+        'A36_PATH_CONSTRAINT_EFFECTIVE',
+        `${where} follows slot "${slot}", and no skin gives that slot a path attachment — ` +
+          "PathConstraint.update returns immediately unless the slot's attachment is a path, so this " +
+          'constraint reports its mixes and moves nothing',
+      );
+    }
+    const pose = constraint.setup;
+    const muted = ![pose.mixRotate, pose.mixX, pose.mixY].some(mixLive);
+    if (muted && !pathSwitchedOn.has(index)) {
+      fail(
+        'A36_PATH_CONSTRAINT_EFFECTIVE',
+        `${where} has mixRotate ${pose.mixRotate}, mixX ${pose.mixX} and mixY ${pose.mixY} at setup and ` +
+          `${noneKeysItsMixAbove0(facts.animations)}; update() returns on all-zero mixes, so nothing ever ` +
+          'puts a bone on the path — rest one of the three above 0, or key its mix above 0 in an animation',
+      );
+    }
+  }
+  stats.pathConstraints = constraints.length;
+}

package/src/assertions/bodies/a37.ts

@@ -0,0 +1,77 @@
+/**
+ * A37, the body (issue #1025, step 4c of #380): a slider that applies
+ * nothing, quietly.
+ *
+ * A slider is the only constraint that applies an ANIMATION, so its failure
+ * modes are about that animation rather than about a transform:
+ *
+ *   1. **An animation with no timelines.** `animation.apply` walks an empty
+ *      array. The slider is in the update cache, its time moves, and the
+ *      skeleton never changes.
+ *   2. **`loop` on a zero-length animation.** `Slider.update` computes
+ *      `animation.duration + (p.time % animation.duration)` when looping, so
+ *      a duration of 0 makes the time **NaN** — and it then applies the
+ *      animation at NaN, which is a pose nobody can predict and no error.
+ *      Only reachable with a bone, because that is the branch the loop
+ *      arithmetic lives in.
+ *   3. **`scale` 0 with a bone.** `time = offset + (value - offset) * 0`, so
+ *      the dial turns and the slider holds one frame.
+ *   4. **`mix` 0** with nothing keying it — the same rule as A36's.
+ *
+ * Moved out of `src/validate.ts` whole: the animation it applies (its
+ * timeline count and duration), its dial, `loop`, `scale` and mix, and the
+ * keys that raise its mix are the rig's, and a document's records state each.
+ * ⚠️ `scale` is read behind `bone` only, and that is where the one known
+ * disagreement between the suppliers lives: on a bone-less slider spine-core
+ * leaves `scale` at 0 and the document states 1 (#1027). Clause 3 never reads
+ * a bone-less slider's scale, so no line can differ on it.
+ */
+import type { Verdicts } from '../harness.ts';
+import type { ConstraintFacts } from '../facts/constraints.ts';
+import { mixLive, noneKeysItsMixAbove0, REST_OR_KEY_ITS_MIX, switchedOn } from '../constraint_words.ts';
+
+export function a37SliderConstraintEffective({ fail, skip, stats }: Verdicts, facts: ConstraintFacts): void {
+  const sliders = facts.constraints.flatMap((c, index) => (c.slider === undefined ? [] : [{ name: c.name, slider: c.slider, index }]));
+  if (!sliders.length) return skip('A37_SLIDER_CONSTRAINT_EFFECTIVE', 'the skeleton declares no slider constraint');
+  /** Which sliders an animation switches ON — `switchedOn` over their `mix` timelines, judged by `mixLive` (A36's ⭐ and 🔑; `Slider.update` returns when `mix` is 0, `Slider.js:53-54`). */
+  const sliderSwitchedOn = switchedOn(facts, (timeline) => timeline.kind === 'slider' && timeline.word === 'mix', 1, (_timeline, value) => mixLive(value));
+  for (const { name, slider, index } of sliders) {
+    const where = `slider "${name}"`;
+    const animation = slider.animation;
+    if (!animation) {
+      // The parser's second pass throws on a miss, so this is only reachable
+      // on an artifact that never went through it.
+      fail('A37_SLIDER_CONSTRAINT_EFFECTIVE', `${where} applies no animation`);
+      continue;
+    }
+    if (animation.timelines === 0) {
+      fail(
+        'A37_SLIDER_CONSTRAINT_EFFECTIVE',
+        `${where} applies animation "${animation.name}", which carries no timeline at all; the slider runs and ` +
+          'the skeleton never changes',
+      );
+    }
+    if (slider.bone && slider.loop && !(animation.duration > 0)) {
+      fail(
+        'A37_SLIDER_CONSTRAINT_EFFECTIVE',
+        `${where} loops animation "${animation.name}", whose duration is ${animation.duration} — ` +
+          'Slider.update computes `duration + (time % duration)` when looping, so the applied time is NaN',
+      );
+    }
+    if (slider.bone && slider.scale === 0) {
+      fail(
+        'A37_SLIDER_CONSTRAINT_EFFECTIVE',
+        `${where} drives off bone "${slider.bone}" with scale 0, so the property cannot move the slider's time`,
+      );
+    }
+    const mix = slider.mix;
+    if (!mixLive(mix) && !sliderSwitchedOn.has(index)) {
+      fail(
+        'A37_SLIDER_CONSTRAINT_EFFECTIVE',
+        `${where} has mix ${mix} at setup and ${noneKeysItsMixAbove0(facts.animations)}; update() returns ` +
+          `on mix 0 — ${REST_OR_KEY_ITS_MIX}`,
+      );
+    }
+  }
+  stats.sliderConstraints = sliders.length;
+}