rig-c 0.0.0-stage → 2.20.4

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

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