spine-rigc 1.9.0 → 1.9.2

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

package/src/assertions/bodies/a39.ts

@@ -0,0 +1,303 @@
+/**
+ * A39, the body (issue #1025, cut 4c-3 of step 4c of #380): a deform keeps
+ * every triangle's winding.
+ *
+ * Moved out of `src/validate.ts` unchanged but for what it reads: the deform
+ * survey as a fact (`../facts/deform_survey.ts`), where it called
+ * `surveyDeformKeys` on the loaded skeleton itself, and the rig info as an
+ * argument. The four sentences it prints a dial, a tie and a frame with moved
+ * with it, unchanged. The argument for the rule — the frame, why `archetype`,
+ * the keys it reads no winding off, the spans — is above its `check` call,
+ * which stays in `validate()`.
+ */
+import type { Verdicts } from '../harness.ts';
+import type { DeformSurveyFacts } from '../facts/deform_survey.ts';
+import type { RigInfo } from '../../types.ts';
+import { unreachableWhy, type DeformDialDispute, type DeformDialTie, type DeformReach, type DialSpan } from '../../deformsurvey.ts';
+
+/**
+ * The clause A39 puts after an animation's name when the frame it measured is
+ * not the track (issue #407).
+ *
+ * Empty on the track, which is what every animation no slider applies gets — so
+ * a message about a rig with no sliders in it reads exactly as it always has.
+ */
+function frameClause(reach: DeformReach): string {
+  return reach.kind === 'slider' ? ` (applied by slider "${reach.slider}", not played on a track)` : '';
+}
+
+/**
+ * A dial's reach as A39's stats line spells it, or `none` when it can select no
+ * part of its animation at all.
+ *
+ * Six decimals because a key time has six: a reach whose end is printed coarser
+ * than the times it is compared against cannot be read against them.
+ */
+function dialSpanText(span: DialSpan | null): string {
+  return span === null ? 'none' : `${span.lo.toFixed(6)}..${span.hi.toFixed(6)}s`;
+}
+
+/**
+ * One disputed dial on A39's stats line — both answers, both reaches, and the
+ * frames the artifact's answer could not have posed (issue #427).
+ *
+ * ⭐ **`outside:` is always there, `none` included.** The comparison it reports is
+ * what decides whether a disagreement changed anything the survey measured, and a
+ * comparison that came out equal must not look like one nobody made. It is the
+ * difference between "both answers pose the same frames, so the disagreement is a
+ * fact about rigc and not about this rig" and "these key times were surveyed
+ * through a field the skeleton does not name and no settable value of the one it
+ * does reaches them".
+ *
+ * ⚠️ No spaces anywhere in it: the stats line is `k=v` pairs joined by spaces, and
+ * a value with a space in it turns one reading into two.
+ */
+function dialDisputeText(dispute: DeformDialDispute): string {
+  const stated = dispute.statedResponse === null ? 'unmeasured' : dispute.statedResponse.toExponential(3);
+  return (
+    `${dispute.slider}|artifact:${dispute.bone}.${dispute.stated}@${stated}` +
+    `|reaches:${dialSpanText(dispute.statedReach)}` +
+    `|probe:${dispute.bone}.${dispute.drive}@${dispute.driveResponse.toExponential(3)}` +
+    `|reaches:${dialSpanText(dispute.driveReach)}` +
+    `|outside:${dispute.outside.length === 0 ? 'none' : dispute.outside.map((t) => `${t.toFixed(6)}s`).join('+')}`
+  );
+}
+
+/** One tied dial on the same line, in the shape that cannot be read as a dispute. */
+function dialTieText(tie: DeformDialTie): string {
+  const rivals = tie.rivals.map((r) => `${tie.bone}.${r.field}@${r.response.toExponential(3)}`).join('+');
+  return `${tie.slider}|artifact:${tie.bone}.${tie.drive}@${tie.driveResponse.toExponential(3)}|tied:${rivals}`;
+}
+
+export function a39DeformKeepsTriangleWinding({ fail, skip, stats }: Verdicts, facts: DeformSurveyFacts, rig: RigInfo | undefined): void {
+  if (!rig) {
+    return skip(
+      'A39_DEFORM_KEEPS_TRIANGLE_WINDING',
+      'no rig info (validating a bare directory), so the rig cannot say which slots fold on purpose',
+    );
+  }
+  const survey = facts.survey(new Set(rig.deformMayFold));
+  // 🚨 Which dial was turned, when rigc's two halves did not simply agree
+  // about that — and BEFORE any of the returns below, because every one of
+  // them is a run that posed frames through this dial (issue #427).
+  //
+  // The verdict used to live in `DeformReach.label`, which `explain` prints
+  // and nothing else does, so a `build`-only run — the normal loop, and the
+  // one an agent that cannot see the rig actually runs — never learned that
+  // the artifact and the probe named different fields.
+  //
+  // ⛔ Not a refusal, and the measurement rather than taste is why (#427).
+  // The frames this survey posed were each checked against `SliderPose.time`
+  // by the runtime itself, so a disagreement cannot make it pose one that
+  // does not happen; and the field it drives is the largest response the
+  // probe found, so it cannot make it miss one that does. What a
+  // disagreement CAN do is leave the rig naming a property no settable value
+  // of turns far enough — which is what `outside` measures and what an
+  // author can act on. A refusal would refuse a rig spine-core poses
+  // correctly at every key, with no edit that would make it green.
+  //
+  // 🔒 A tie is not a disagreement and gets a line that cannot be read as
+  // one: there the probe named no field, the artifact broke the tie, and the
+  // parent-45° geometry that reaches it is legitimate.
+  if (survey.dialTies.length) {
+    stats.deformDialsTied = survey.dialTies.length;
+    stats.deformDialTied = survey.dialTies.map(dialTieText).join(',');
+  }
+  if (survey.dialDisputes.length) {
+    stats.deformDialsDisagreed = survey.dialDisputes.length;
+    stats.deformDialDisagreed = survey.dialDisputes.map(dialDisputeText).join(',');
+  }
+  /** A key this rule is refusing, by the triple that identifies it. */
+  const refusedKey = new Set<string>();
+  for (const key of survey.keys) {
+    // ⭐ The one thing this rule cannot say about a key that draws nothing.
+    // Its own message below states the harm as "draws its texture
+    // backwards", and that sentence is false when no pixel of the mesh
+    // lands at this time — the slot has faded to alpha 0, or shows another
+    // attachment. So the key is measured, reported and not gated (issue
+    // #401). Per key and per time: the SAME slot folding at full alpha in
+    // another animation, or at another key, is refused as before, which is
+    // what makes this a measurement rather than a second `deformMayFold`.
+    if (key.draw.blank !== null) continue;
+    // And the one thing it cannot say about a key at a time no dial selects
+    // (issue #407): the frame posed is not this key's, so its geometry
+    // belongs to some other time and a winding read off it would be a
+    // measurement of the wrong thing. Named below, on the stats line.
+    if (key.dial?.unreachable === true) continue;
+    if (key.reversed.length === 0) continue;
+    refusedKey.add(`${key.animation} ${key.slot} ${key.attachment} ${key.key}`);
+    const shown = key.reversed
+      .slice(0, 4)
+      .map((r) => `${r.triangle} [${r.ids.join(',')}] ${r.before.toFixed(3)} -> ${r.after.toFixed(3)}px²`);
+    const more = key.reversed.length > shown.length ? `, and ${key.reversed.length - shown.length} more` : '';
+    fail(
+      'A39_DEFORM_KEEPS_TRIANGLE_WINDING',
+      // ⚠️ The frame is in the message whenever it is not the track, because
+      // the same key can be refused in one frame and passed over in another
+      // — two sliders applying one animation are two frames — and a message
+      // that named only the key would be ambiguous about which (issue #407).
+      `animation "${key.animation}"${frameClause(key.reach)} deform ${key.slot}/${key.attachment} ` +
+        `key ${key.key} (t=${key.time}s): ` +
+        `${key.reversed.length} of ${key.triangles} triangle(s) reverse winding — triangle ${shown.join('; triangle ')}` +
+        `${more}. The mesh has turned inside out there and draws its texture backwards` +
+        // The alpha is in the message whenever it is not full, because the
+        // one thing that would make this key exempt is alpha exactly 0 and
+        // an author who has already faded the part half out needs to be
+        // told that half is not none (issue #401).
+        (key.draw.alpha === 1
+          ? ''
+          : ` at alpha ${key.draw.alpha.toFixed(4)} — visible at that strength, and only alpha exactly 0 draws ` +
+            'no pixels at all') +
+        '. Fix the key\'s ' +
+        'offsets in the motion spec\'s deform timeline (a projection past its fold angle is the usual ' +
+        'cause — docs/FACE.md §4.2 has the closed form), or, if this slot folds on purpose, declare it ' +
+        `in the rig spec as invariants.deformMayFold: [{ "slot": "${key.slot}", "why": … }]`,
+    );
+  }
+  // --- and the folds no key lands on (issue #403) ------------------------
+  let spanFolds = 0;
+  for (const span of survey.spans) {
+    if (span.fold === null) continue;
+    // Suppressed when a bounding key already says it: one defect, one
+    // message. The span check is here for what the keys cannot see.
+    const bounded = `${span.animation} ${span.slot} ${span.attachment} `;
+    if (refusedKey.has(bounded + span.fromKey) || refusedKey.has(bounded + span.toKey)) continue;
+    spanFolds++;
+    const at = span.fold;
+    const shown = at.measure.reversed
+      .slice(0, 4)
+      .map((r) => `${r.triangle} [${r.ids.join(',')}] ${r.before.toFixed(3)} -> ${r.after.toFixed(3)}px²`);
+    const more =
+      at.measure.reversed.length > shown.length ? `, and ${at.measure.reversed.length - shown.length} more` : '';
+    // A stepped segment interpolates NOTHING — it holds the earlier key's
+    // geometry across the whole span — so saying "the runtime interpolates"
+    // there would be telling the author to look for a defect in the wrong
+    // place. What changed across a stepped span is what the slot DRAWS.
+    const held = span.curve === 'stepped';
+    fail(
+      'A39_DEFORM_KEEPS_TRIANGLE_WINDING',
+      `animation "${span.animation}"${frameClause(span.reach)} deform ${span.slot}/${span.attachment} ` +
+        `BETWEEN key ${span.fromKey} ` +
+        `(t=${span.fromTime}s) and key ${span.toKey} (t=${span.toTime}s), at t=${at.time.toFixed(6)}s` +
+        (held ? ' (a stepped segment)' : ` — ${(at.percent * 100).toFixed(1)}% of the way from one to the other`) +
+        `: ${at.measure.reversed.length} of ${at.measure.triangles} triangle(s) reverse winding — ` +
+        `triangle ${shown.join('; triangle ')}${more}. NO KEY LANDS THERE: ` +
+        (held
+          ? `a stepped segment interpolates nothing, it HOLDS key ${span.fromKey}'s geometry across the whole ` +
+            'span — so the fold is that key\'s and what changes here is what the slot draws'
+          : 'the runtime interpolates between the two keys, and the mesh is inside out for part of the way') +
+        ', drawing its texture backwards' +
+        (at.measure.draw.alpha === 1
+          ? ''
+          : ` at alpha ${at.measure.draw.alpha.toFixed(4)} — visible at that strength, and only alpha exactly 0 ` +
+            'draws no pixels at all') +
+        '. ' +
+        (held
+          ? `Fix key ${span.fromKey}'s offsets, or keep the slot drawing nothing for as long as it holds them`
+          : 'Add a key inside the span so the geometry the runtime passes through is geometry you wrote, or ' +
+            "move the two keys' offsets closer together (a projection past its fold angle is the usual cause " +
+            '— docs/FACE.md §4.2 has the closed form)') +
+        (at.measure.draw.alpha === 1
+          ? ''
+          : '; if the part is being faded out over this turn, land the alpha-0 key BEFORE the folding key ' +
+            'rather than on it, so every frame that folds is a frame that draws nothing (docs/FACE.md §9.2)') +
+        `, or, if this slot folds on purpose, declare it in the rig spec as invariants.deformMayFold: ` +
+        `[{ "slot": "${span.slot}", "why": … }]`,
+    );
+  }
+  if (survey.timelines === 0) {
+    return skip('A39_DEFORM_KEEPS_TRIANGLE_WINDING', 'no animation carries a deform timeline');
+  }
+  if (survey.keys.length === 0) {
+    const why = [
+      survey.exempted.length ? `the rig declares ${survey.exempted.join(', ')} as deformMayFold` : '',
+      survey.notAMesh.length ? `${survey.notAMesh.join(', ')} deform an attachment with no triangles` : '',
+    ].filter(Boolean);
+    return skip(
+      'A39_DEFORM_KEEPS_TRIANGLE_WINDING',
+      `no deform timeline here has a winding to keep: ${why.join('; ') || 'every mesh keyed has no triangles'}`,
+    );
+  }
+  // ⚠️ Silence is not a pass. A key passed over because nothing of it is
+  // drawn has to be visible on a green run too — this is the only surface
+  // `validate` has, and `explain`'s DEFORM block prints the whole sentence
+  // beside the key's own figures.
+  // ⚠️ Unreachable first and `blank` second, in the survey's own order, so
+  // the two counts partition the ungated keys instead of double-counting a
+  // key that is both.
+  const unreachable = survey.keys.filter((k) => k.dial?.unreachable === true);
+  const blank = survey.keys.filter((k) => k.dial?.unreachable !== true && k.draw.blank !== null);
+  const ungated = blank.length + unreachable.length;
+  const name = (k: (typeof survey.keys)[number]): string =>
+    `${k.animation}/${k.slot}/${k.attachment}#${k.key}:${k.draw.showsThisMesh ? 'alpha0' : 'notShown'}`;
+  // ⚠️ `&& spanFolds === 0` because a rig whose every key draws nothing can
+  // still fold at a time between two of them that DOES draw — that is issue
+  // #403's own case, and a SKIP printed over a refusal would be this rule
+  // reporting "nothing to measure" about the thing it just measured.
+  if (ungated === survey.keys.length && spanFolds === 0) {
+    const first = blank[0] ?? unreachable[0];
+    return skip(
+      'A39_DEFORM_KEEPS_TRIANGLE_WINDING',
+      `no deform key here is measurable in the frame its animation is reached in — ` +
+        `${first.animation} ${first.slot}/${first.attachment} key ${first.key}: ` +
+        `${first.draw.blank ?? unreachableWhy(first)}` +
+        (survey.keys.length > 1 ? `, and ${survey.keys.length - 1} more key(s) like it` : '') +
+        (unreachable.length
+          ? `. ${unreachable.length} of them at a time no dial selects, which is a rig defect this rule does ` +
+            'not refuse and does not pass over in silence either'
+          : '') +
+        (survey.spans.length
+          ? `. The ${survey.spans.length} span(s) between them were scanned too and none folds where anything ` +
+            'is drawn'
+          : ''),
+    );
+  }
+  stats.deformKeysMeasured = survey.keys.length - ungated;
+  stats.deformTrianglesMeasured = survey.trianglesMeasured;
+  stats.deformTrianglesCollapsed = survey.collapsed;
+  // Which frame each animation was posed in (issue #407) — printed only when
+  // a slider chose one, because on every other rig it says "a track" about
+  // every animation and a stats line that never varies is not a reading.
+  const frames = [...new Map(survey.keys.map((k) => [`${k.animation}/${k.reach.slider ?? 'track'}`, k])).values()];
+  if (frames.some((k) => k.reach.kind === 'slider')) {
+    stats.deformFrames = frames
+      .map((k) => `${k.animation}:${k.reach.kind === 'slider' ? `slider/${k.reach.slider}` : 'track'}`)
+      .join(',');
+  }
+  if (blank.length) {
+    stats.deformKeysNotDrawn = blank.length;
+    stats.deformNotDrawn = blank.map(name).join(',');
+    if (survey.notDrawnReversed) stats.deformNotDrawnReversed = survey.notDrawnReversed;
+  }
+  // 🚨 A key at a time no dial can select is NOT a pass and NOT a refusal —
+  // it is a rig whose slider cannot reach its own animation's key, named
+  // here so a green run cannot be read as having measured it (issue #407).
+  if (unreachable.length) {
+    stats.deformKeysUnreachable = unreachable.length;
+    stats.deformUnreachable = unreachable
+      .map((k) => `${k.animation}/${k.slot}/${k.attachment}#${k.key}@${k.dial?.applied.toFixed(6) ?? '?'}`)
+      .join(',');
+    if (survey.notReachableReversed) stats.deformUnreachableReversed = survey.notReachableReversed;
+  }
+  if (survey.exempted.length) stats.deformFoldExempt = survey.exempted.join(',');
+  // ⚠️ The between-keys scan on the stats line, on a GREEN run too (issue
+  // #403). `deformSpansScanned` is the positive control an agent can read —
+  // a scan that ran and found nothing has to be distinguishable from a scan
+  // that never ran — and `deformSpanProbes` is what it cost: 0 on a rig the
+  // closed form flags nothing in, one posed measurement per flagged window
+  // otherwise.
+  stats.deformSpansScanned = survey.spans.length;
+  // ⚠️ And the ones it could NOT scan, for the same reason the line above
+  // exists: a span bounded by a key at a time no dial selects would be
+  // solved over two poses of some other time, so it is skipped — and a skip
+  // nobody can see is the silence this whole surface is against (#407).
+  if (survey.spansNotScanned) stats.deformSpansNotScanned = survey.spansNotScanned;
+  if (survey.spanProbes) stats.deformSpanProbes = survey.spanProbes;
+  if (survey.spansNotDrawn) stats.deformSpansNotDrawn = survey.spansNotDrawn;
+  // A prediction nothing reproduced. Never a refusal — that would be the
+  // false red issues #44 and #262 already cost this file — and never a
+  // silence either: the one case that reaches it is a weighted mesh whose
+  // bones move across the span, where the closed form's fixed-pose
+  // assumption is the thing that did not hold.
+  if (survey.spansUnconfirmed) stats.deformSpansUnconfirmed = survey.spansUnconfirmed;
+}

package/src/assertions/bodies/a40.ts

@@ -0,0 +1,128 @@
+/**
+ * A40, the body (issue #1025, cut 4c-5 of step 4c of #380): two sliders on
+ * one property, and the later one erases the other.
+ *
+ * The argument — why this is `validity`, the three shapes excluded
+ * structurally (authority below 1, a skin switch, different properties), the
+ * second clause and the events clause removed — stands above the `check` call
+ * in `validate()`. What a timeline does with `add` is the one fact here that
+ * is behaviour rather than a record: it is posed, and the body asks for it
+ * (`behaviour`) only for the later timeline of a shared property, once per
+ * timeline.
+ *
+ * Moved out of `src/validate.ts` whole: the sliders, their setup mix, their
+ * `additive` flag, the skins that list them, the animations they apply and the
+ * properties those animations' timelines register are the rig's, and a
+ * document's records state each; the class a timeline's additive application
+ * falls in is the core's computation over the document
+ * (`src/core/additive.ts`), held to the runtime's probe by the core suite's
+ * `CO27`. The words the sentences print are the facts' own: the runtime class
+ * a timeline loads as, the property's name, the target as the sentence names
+ * it.
+ */
+import type { Verdicts } from '../harness.ts';
+import type { ConstraintFacts } from '../facts/constraints.ts';
+import type { AddBehaviour, SliderCompositionFacts, SliderFact, SliderTimelineFact } from '../facts/slider_composition.ts';
+import { switchedOn } from '../constraint_words.ts';
+
+export function a40SlidersComposeOnASharedTarget({ fail, skip, stats }: Verdicts, facts: SliderCompositionFacts, constraints: ConstraintFacts): void {
+  const sliders = facts.sliders;
+  if (sliders.length < 2) {
+    return skip(
+      'A40_SLIDERS_COMPOSE_ON_A_SHARED_TARGET',
+      `the skeleton declares ${sliders.length} slider constraint${sliders.length === 1 ? '' : 's'}, and one slider has nothing to compose with`,
+    );
+  }
+  // Clause 1 of the "could this be correct?" list above the check.
+  // "Keyed at all" rather than "keyed live", and on purpose: this clause asks
+  // whether the mix can MOVE from its setup value, so any mix timeline
+  // disqualifies it — the question `keyedBy` answered here, through the one
+  // reading `switchedOn` gives (`../constraint_words.ts`, over the same facts
+  // the moved constraint bodies read — issue #1025), and unchanged by issue
+  // #752.
+  const mixKeyed = switchedOn(constraints, (timeline) => timeline.kind === 'slider' && timeline.word === 'mix', 1, () => true);
+  const authoritative = sliders.filter((s) => s.mix >= 1 && !mixKeyed.has(s.index));
+  if (authoritative.length < 2) {
+    return skip(
+      'A40_SLIDERS_COMPOSE_ON_A_SHARED_TARGET',
+      `${authoritative.length} of the ${sliders.length} slider constraints apply at full authority; below mix 1 an ` +
+        'apply is a lerp from the current pose rather than an overwrite, so what the others do to a shared property is a weighting',
+    );
+  }
+  /** Which skins switch a slider on, or null when it is active under every skin. */
+  const skinsOf = new Map<SliderFact, Set<string> | null>();
+  for (const slider of authoritative) skinsOf.set(slider, slider.skinRequired ? new Set(slider.skins) : null);
+  /** Clause 2: can these two ever run in the same frame? */
+  const canOverlap = (a: SliderFact, b: SliderFact): boolean => {
+    const skinsA = skinsOf.get(a) ?? null;
+    const skinsB = skinsOf.get(b) ?? null;
+    if (!skinsA || !skinsB) return true;
+    for (const name of skinsA) {
+      if (skinsB.has(name)) return true;
+    }
+    return false;
+  };
+  type User = { slider: SliderFact; timeline: SliderTimelineFact; animation: string; at: number; property: string; names: string };
+  /** property id -> the sliders whose animation keys it, in constraints-array order. */
+  const byProperty = new Map<string, User[]>();
+  for (const slider of authoritative) {
+    const seen = new Set<string>();
+    const animation = slider.animation;
+    if (animation === null) continue;
+    animation.timelines.forEach((timeline, at) => {
+      for (const { id, property, names } of timeline.properties) {
+        if (seen.has(id)) continue;
+        seen.add(id);
+        byProperty.set(id, [...(byProperty.get(id) ?? []), { slider, timeline, animation: animation.name, at, property, names }]);
+      }
+    });
+  }
+  /** Posed once per timeline, because the answer is the class's and the rigs that reach here share timelines. */
+  const behaviour = new Map<string, AddBehaviour>();
+  const addBehaviourOf = (user: User): AddBehaviour => {
+    const key = `${user.animation}\u0000${user.at}`;
+    const known = behaviour.get(key);
+    if (known !== undefined) return known;
+    const measured = facts.behaviour(user.animation, user.at);
+    behaviour.set(key, measured);
+    return measured;
+  };
+  let shared = 0;
+  for (const [, users] of byProperty) {
+    if (users.length < 2) continue;
+    shared++;
+    const at = (slider: SliderFact): string => `"${slider.name}" (constraints[${slider.index}], additive: ${String(slider.additive)})`;
+    const chain = users.map((u) => at(u.slider)).join(', ');
+    for (let j = 1; j < users.length; j++) {
+      const later = users[j];
+      const composes = addBehaviourOf(later);
+      if (composes === 'accumulates' && later.slider.additive) continue;
+      // Nothing a second slider could take away: applied with the arguments
+      // a slider passes — `firedEvents` null among them — this timeline
+      // moves no pose at all.
+      if (composes === 'inert') continue;
+      const erased = users.slice(0, j).filter((e) => canOverlap(e.slider, later.slider));
+      if (!erased.length) continue;
+      const erasedNames = `${erased.map((e) => `"${e.slider.name}"`).join(', ')} contribute${erased.length === 1 ? 's' : ''}`;
+      const why =
+        composes === 'accumulates'
+          ? `slider "${later.slider.name}" applies animation "${later.slider.animation?.name}" with additive false, and at ` +
+            'mix 1 a non-additive apply writes the value outright (`getRelativeValue` returns `setup + value`, ' +
+            '`getAbsoluteValue` returns `value`) rather than adding to the pose it found. Set `"additive": true` on ' +
+            `slider "${later.slider.name}" in the rig spec — rigc will not choose that flag for you — or key this ` +
+            `property from one slider only. [measured] \`${later.timeline.runtimeClass}.apply\` posed twice with ` +
+            '`add` set accumulates, so that flag is the repair here'
+          : `the ${later.property} timeline they share writes its value outright whatever the ` +
+            `flags say — [measured] \`${later.timeline.runtimeClass}.apply\` posed twice with \`add\` set left the ` +
+            'same value there rather than adding to it — so `"additive": true` would NOT compose these. Key this ' +
+            'property from one slider only, or move both edits into the one animation a single slider applies';
+      fail(
+        'A40_SLIDERS_COMPOSE_ON_A_SHARED_TARGET',
+        `${later.names} is keyed by the animations of ${users.length} sliders — ${chain} — and every ` +
+          `one of them applies at mix 1. Today ${at(later.slider)} wins that property and ${erasedNames} ` +
+          `nothing to it: ${why}.`,
+      );
+    }
+  }
+  stats.sliderSharedTargets = shared;
+}