spine-rigc 1.7.0 → 1.9.0

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;
+}

package/src/assertions/bodies/a38.ts

@@ -0,0 +1,73 @@
+/**
+ * A38, the body (issue #1025, step 4c of #380): a skin's member list and its
+ * members' `skin: true` flag agree.
+ *
+ * Moved out of `src/validate.ts` unchanged but for what it reads: the bones,
+ * the constraints and the skins' lists are a fact (`../facts/skin_members.ts`)
+ * — which spine-core's loaded `SkeletonData` satisfies as it stands. Why both
+ * halves of the switch are dead data alone stays above the `check` call in
+ * `validate()`.
+ */
+import type { Verdicts } from '../harness.ts';
+import type { MemberBone, SkinMemberFacts } from '../facts/skin_members.ts';
+
+export function a38SkinMembersAreSkinRequired({ fail, skip, stats }: Verdicts, data: SkinMemberFacts): void {
+  /** Every bone a skin can switch on, including the ancestors it drags in. */
+  const activatable = new Set<string>();
+  // The constraint OBJECTS a skin lists, never their names: a name is not a
+  // constraint in this format, and two constraints of one name under two
+  // kinds are two objects a skin may list separately (issue #692). Keyed by
+  // name, a `transform` `leg` that no skin lists read as listed because an
+  // `ik` `leg` was — a skinRequired constraint that never runs, reported
+  // green by the one assertion that looks for exactly that.
+  const listedConstraints = new Set(data.skins.flatMap((skin) => skin.constraints));
+  let listed = 0;
+  for (const skin of data.skins) {
+    for (const bone of skin.bones) {
+      listed++;
+      for (let cursor: MemberBone | null = bone; cursor; cursor = cursor.parent) activatable.add(cursor.name);
+      if (!bone.skinRequired) {
+        fail(
+          'A38_SKIN_MEMBERS_ARE_SKIN_REQUIRED',
+          `skin "${skin.name}" activates bone "${bone.name}", which is not skinRequired — updateCache starts it ` +
+            'active anyway, so it poses under every skin and this list changes nothing',
+        );
+      }
+    }
+    for (const constraint of skin.constraints) {
+      listed++;
+      if (!constraint.skinRequired) {
+        fail(
+          'A38_SKIN_MEMBERS_ARE_SKIN_REQUIRED',
+          `skin "${skin.name}" activates constraint "${constraint.name}", which is not skinRequired — it runs ` +
+            'under every skin, so this list changes nothing',
+        );
+      }
+    }
+  }
+  const required = data.bones.filter((b) => b.skinRequired).length + data.constraints.filter((c) => c.skinRequired).length;
+  if (listed === 0 && required === 0) {
+    return skip(
+      'A38_SKIN_MEMBERS_ARE_SKIN_REQUIRED',
+      'no skin activates a bone or a constraint, and nothing declares itself skinRequired',
+    );
+  }
+  for (const bone of data.bones) {
+    if (bone.skinRequired && !activatable.has(bone.name)) {
+      fail(
+        'A38_SKIN_MEMBERS_ARE_SKIN_REQUIRED',
+        `bone "${bone.name}" is skinRequired and no skin's bones list reaches it, so it is never active — ` +
+          'it and its subtree hold the setup pose under every skin',
+      );
+    }
+  }
+  for (const constraint of data.constraints) {
+    if (constraint.skinRequired && !listedConstraints.has(constraint)) {
+      fail(
+        'A38_SKIN_MEMBERS_ARE_SKIN_REQUIRED',
+        `constraint "${constraint.name}" is skinRequired and no skin lists it, so it never runs`,
+      );
+    }
+  }
+  stats.skinMembers = listed;
+}

package/src/assertions/bodies/a41.ts

@@ -0,0 +1,83 @@
+/**
+ * A41, the body (issue #1025, step 4c of #380): a physics component the Spine
+ * editor cannot hold, refused on a rig declared for the editor.
+ *
+ * 🚨 The silence this converts is not in the artifact — it is one consumer
+ * downstream of it. An author builds a rig whose cowlick jiggles, opens it
+ * in the editor to move an eyebrow, saves, exports, and the hair has stopped
+ * moving. The returned file says nothing: the component is simply absent,
+ * and absent parses as 0. `gallery/look` is exactly that rig.
+ *
+ * 🔑 **rigc's output is correct, so the refusal is opt-in.** `rotate` on a
+ * physics constraint is valid Spine 4.3 that every runtime plays, and
+ * refusing it by default would be refusing correct data on behalf of a
+ * pipeline rigc was never told about. What rigc can see is the object; which
+ * consumers it is for is the rig's to say, and it says it with
+ * `invariants.editorRoundTrip` (`src/rig.ts`).
+ *
+ * ⚠️ **The SKIP is the other half of the product and is not a shrug.** A rig
+ * that declares nothing is not gated — but the reason names the constraint
+ * and the components a round trip would drop, so the one thing that must not
+ * happen (nobody finds out) does not happen either. That is why this reads
+ * the whole skeleton before it reads the declaration, rather than returning
+ * early on a rig that asked for nothing.
+ *
+ * 🔸 **Against A23, on the far side of the same trip.** A23 refuses a
+ * constraint driving NOTHING — which is what the editor hands back, after
+ * the loss — and it is what fires today on a round-tripped `look`. This
+ * refuses a constraint driving something the editor will not keep, before
+ * the trip. They cannot both fire on one constraint: A23's condition is an
+ * empty driven set and this one's is a non-empty one (see
+ * `PHYSICS_COMPONENTS`), so the two are disjoint by construction rather than
+ * by agreement.
+ *
+ * Moved out of `src/validate.ts` whole: the components are the document's
+ * physics records, the declaration the rig's.
+ */
+import type { Verdicts } from '../harness.ts';
+import type { ConstraintFacts } from '../facts/constraints.ts';
+import { EDITOR_PHYSICS_COMPONENTS, PHYSICS_COMPONENTS } from '../constraint_words.ts';
+import type { RigInfo } from '../../types.ts';
+
+export function a41PhysicsSurvivesEditorRoundTrip({ fail, skip }: Verdicts, facts: ConstraintFacts, rig: RigInfo | undefined): void {
+  // Counted here rather than read off `stats.physicsConstraints`: that entry
+  // is written by A23, and a rule whose SKIP depends on another rule having
+  // run is a rule that reports "nothing to measure" when its neighbour threw.
+  const physics = facts.constraints.flatMap((c) => (c.physics === undefined ? [] : [{ name: c.name, components: c.physics.components }]));
+  const dropped: string[] = [];
+  for (const constraint of physics) {
+    const lost = PHYSICS_COMPONENTS.filter((k) => constraint.components[k] > 0 && !EDITOR_PHYSICS_COMPONENTS.has(k));
+    if (lost.length) dropped.push(`physics "${constraint.name}" drives ${lost.join(', ')}`);
+  }
+  const editorKeeps = [...EDITOR_PHYSICS_COMPONENTS].join(' and ');
+  const found =
+    dropped.length === 0
+      ? 'no physics constraint here drives a component it would discard'
+      : `${dropped.join('; ')}, and the editor's physics model holds ${editorKeeps} only, so a round trip ` +
+        'returns that constraint driving nothing at all (issue #540)';
+  if (rig?.editorRoundTrip !== true) {
+    return skip(
+      'A41_PHYSICS_SURVIVES_EDITOR_ROUND_TRIP',
+      `${
+        rig
+          ? `the rig "${rig.archetype}" does not declare \`invariants.editorRoundTrip\``
+          : 'this is a bare directory, with no rig info to declare `invariants.editorRoundTrip`'
+      }, so nothing here is gated against the Spine editor. What is here: ${found}`,
+    );
+  }
+  if (physics.length === 0) {
+    return skip(
+      'A41_PHYSICS_SURVIVES_EDITOR_ROUND_TRIP',
+      `the rig "${rig.archetype}" is declared for the editor, but it carries no physics constraint — ` +
+        'there is nothing here whose components could be lost',
+    );
+  }
+  for (const one of dropped) {
+    fail(
+      'A41_PHYSICS_SURVIVES_EDITOR_ROUND_TRIP',
+      `${one}; the editor's physics model holds ${editorKeeps} only, and this ` +
+        'rig declares `invariants.editorRoundTrip` — drive it in x/y, or drop the declaration if this rig never ' +
+        'goes through the editor (issue #540)',
+    );
+  }
+}

package/src/assertions/bodies/a42.ts

@@ -0,0 +1,97 @@
+/**
+ * A42, the body (issue #1025, step 4c of #380): a constraint a slider's
+ * animation keys updates after that slider.
+ *
+ * `Skeleton.updateCache` walks the `constraints` array in order and each
+ * constraint's `sort` pushes itself as it is reached — `Slider.sort` included,
+ * which pushes bones and never a constraint — so the array IS the update order,
+ * for every kind. Every constraint then opens its `update` by reading its own
+ * applied pose, so a slider that keys any property of a constraint is read by
+ * that constraint only when it comes LATER in the array; written the other way
+ * round the value lands in a pose whose only reader has already run, and
+ * `Posed.resetConstrained` puts the pose back before the next frame (the
+ * argument and its measurements sit above the `check` call in `validate()`).
+ *
+ * Moved out of `src/validate.ts` whole: the array's order, the slider's
+ * animation and the constraint timelines it holds — which constraint each
+ * names, what it keys, and whom a physics timeline naming none reaches — are
+ * the rig's, and a document's records state each. The words the sentence
+ * prints are the facts' own: what a timeline keys (`word`, the motion spec's
+ * word for it) and the runtime class whose `update` reads it (`runtimeClass`).
+ */
+import type { Verdicts } from '../harness.ts';
+import type { ConstraintFacts } from '../facts/constraints.ts';
+
+export function a42DrivenConstraintsUpdateAfterTheirDriver({ 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('A42_DRIVEN_CONSTRAINTS_UPDATE_AFTER_THEIR_DRIVER', 'the skeleton declares no slider constraint');
+  }
+  let pairs = 0;
+  let resets = 0;
+  for (const driver of sliders) {
+    const driverIndex = driver.index;
+    const animationName = driver.slider.animation?.name;
+    for (const timeline of facts.timelines) {
+      if (animationName === undefined || timeline.animation !== animationName) continue;
+      if (timeline.kind === 'physics' && timeline.word === 'reset') {
+        resets++;
+        continue;
+      }
+      const word = timeline.word;
+      const everyPhysics = timeline.constraint < 0;
+      // A physics timeline whose animation names no constraint reaches every
+      // ACTIVE physics constraint whose own data declares that property
+      // global — the timeline's `reach`, the one reading of it A23 and A34
+      // share (issue #726).
+      for (const drivenIndex of timeline.reach) {
+        const driven = facts.constraints[drivenIndex];
+        if (driven === undefined) continue;
+        pairs++;
+        if (drivenIndex > driverIndex) continue;
+        const kind = { word: driven.kind, runtime: driven.runtimeClass };
+        const animation = `animation "${animationName}"`;
+        const reference = `\`${kind.word}.${driven.name}${word === kind.word ? '' : `.${word}`}\``;
+        fail(
+          'A42_DRIVEN_CONSTRAINTS_UPDATE_AFTER_THEIR_DRIVER',
+          drivenIndex === driverIndex
+            ? `slider "${driver.name}" (constraints[${driverIndex}]) keys its own \`${word}\` in ${animation}. ` +
+                '`Slider.update` reads `appliedPose.' +
+                `${word}\` as the ${word === 'mix' ? 'alpha it applies that animation with' : 'time it applies that animation at'}, ` +
+                'before the animation runs, so the key is written after its only reader and `Posed.resetConstrained` ' +
+                `puts the pose back before the next frame${
+                  word === 'mix'
+                    ? ' — and at `mix` 0 `update` returns before applying anything at all, so the key that would raise it is unreachable'
+                    : ''
+                }. Key ${reference} from a slider EARLIER in \`constraints\`, or state the ` +
+                `\`${word}\` this slider should start at in the rig spec`
+            : `slider "${driver.name}" (constraints[${driverIndex}]) keys ${
+                word === kind.word ? `the \`${word}\` timeline` : `\`${word}\``
+              } of ${kind.word} constraint ` +
+                `"${driven.name}" (constraints[${drivenIndex}]) in ${animation}${
+                  everyPhysics ? ' — the timeline names no constraint, which the runtime reads as every physics constraint declaring that property global —' : ''
+                }, and "${driven.name}" updates FIRST. The \`constraints\` array is the update order ` +
+                '(`Skeleton.updateCache` walks it and each constraint\'s `sort` pushes itself as it is reached) and ' +
+                `\`${kind.runtime}.update\` reads its own \`appliedPose\` before applying anything, so that key is ` +
+                'written after the only read of it and `Posed.resetConstrained` discards it before the next frame: ' +
+                `what "${driven.name}" drives is dead at every reading of "${driver.name}"'s dial, although its pose ` +
+                `still holds the number. Move "${driver.name}" before "${driven.name}" in \`constraints\`, or key ` +
+                `${reference} from a slider that already is`,
+        );
+      }
+    }
+  }
+  if (pairs === 0) {
+    return skip(
+      'A42_DRIVEN_CONSTRAINTS_UPDATE_AFTER_THEIR_DRIVER',
+      `no animation applied by one of the ${sliders.length} slider constraint${sliders.length === 1 ? '' : 's'} keys a ` +
+        `property of a constraint, so no slider here drives a constraint${
+          resets === 0
+            ? ''
+            : ` — the ${resets} \`physics\` \`reset\` key(s) they do carry are not a pose write, and [measured] a slider ` +
+              'applies its animation at one instant, so `PhysicsConstraintResetTimeline` never fires from one in either array order'
+        }`,
+    );
+  }
+  stats.sliderDrivenConstraints = pairs;
+}

package/src/assertions/bodies/a44.ts

@@ -0,0 +1,23 @@
+/**
+ * A44, the body (issue #1025, step 4c of #380): a linked mesh states no
+ * geometry of its own.
+ *
+ * Moved out of `src/validate.ts` by its subject only. Which links the file
+ * declares is the rig's — a document's `linkedmesh` record is one — so the
+ * roster moved, and a rig with no link SKIPs on both sides. What A44 refuses
+ * is the encoding's: a link record holds no geometry field, and `uvs`,
+ * `triangles`, `vertices`, `hull` and `edges` written on a link exist only in
+ * the Spine text (the census's row for A44). That clause, and the sentence it
+ * prints, stay with the round trip, which hands its finding about each link in
+ * as the link's `encoding`, printed in the order the body always printed it.
+ */
+import type { Verdicts } from '../harness.ts';
+import type { LinkFacts } from '../facts/linked_meshes.ts';
+import { SKIP_NO_LINKED_MESH } from '../reasons.ts';
+
+export function a44LinkedMeshStatesNoGeometryOfItsOwn({ fail, skip }: Verdicts, { links }: LinkFacts): void {
+  if (links.length === 0) return skip('A44_LINKED_MESH_STATES_NO_GEOMETRY_OF_ITS_OWN', SKIP_NO_LINKED_MESH);
+  for (const link of links) {
+    for (const detail of link.encoding) fail('A44_LINKED_MESH_STATES_NO_GEOMETRY_OF_ITS_OWN', detail);
+  }
+}