spine-rigc 0.30.0 → 0.32.0

package/src/validate.ts

@@ -23,7 +23,9 @@ import {
   BoundingBoxAttachment,
   ClippingAttachment,
   type ConstraintTimeline,
+  type CurveTimeline,
   DeformTimeline,
+  Inherit,
   isBoneTimeline,
   isConstraintTimeline,
   isSlotTimeline,
@@ -31,6 +33,7 @@ import {
   MixFrom,
   PathAttachment,
   PathConstraintData,
+  PathConstraintMixTimeline,
   Physics,
   PhysicsConstraintData,
   PhysicsConstraintPose,
@@ -41,6 +44,7 @@ import {
   Skeleton,
   SkeletonJson,
   SliderData,
+  SliderMixTimeline,
   TextureAtlas,
   type TextureAtlasRegion,
   type Timeline,
@@ -50,8 +54,10 @@ import {
 // A19 needs the DECODED page, not its header, to measure one region's own
 // rectangle on a shared page.
 import { readPlate } from '../tools/plate.ts';
-import { pageFootprint } from './atlas.ts';
+import { pageFootprint, pageGridSentence } from './atlas.ts';
 import {
+  BEZIER_POINTS,
+  curveStorage,
   surveyDeformKeys,
   unreachableWhy,
   type DeformDialDispute,
@@ -66,12 +72,16 @@ import {
   type SpineGeneration,
 } from './generation.ts';
 import { colourTypeName, readPngHeader } from './png.ts';
+import { BONE_INHERIT_KNOWN } from './rig.ts';
 import {
   CHANNELS_BY_KIND,
   KEY_TIME_EPSILON,
   PHYSICS_POSE_RULES,
   physicsKeyRefusal,
+  physicsOutsideSays,
   physicsRuleFor,
+  type PhysicsPoseRule,
+  SEQUENCE_MODES,
   SLOT_COLOR_CHANNELS,
   walkTimelines,
 } from './timelines.ts';
@@ -197,6 +207,7 @@ const ASSERTION_KIND: Record<string, 'validity' | 'renderer' | 'archetype'> = {
   A43_TWO_COLOR_TINT_LOADS_AND_POSES_AS_WRITTEN: 'validity',
   A44_LINKED_MESH_STATES_NO_GEOMETRY_OF_ITS_OWN: 'validity',
   A45_SEPARABLE_COLOR_TIMELINES_OWN_THEIR_CHANNELS_AND_POSE_AS_WRITTEN: 'validity',
+  A46_SEQUENCE_ATTACHMENTS_SHOW_THE_FRAME_THE_FILE_STATES: 'validity',
 };
 
 /**
@@ -303,6 +314,8 @@ export const SKIP_NO_TWO_COLOR_TINT =
 export const SKIP_NO_SEPARABLE_COLOR =
   'no animation keys an "rgb" or "alpha" timeline, so there is no separable slot colour to read back';
 export const SKIP_NO_LINKED_MESH = 'no attachment in this skeleton takes its geometry from another one';
+export const SKIP_NO_SEQUENCE =
+  'no attachment carries a "sequence" block and no animation keys a "sequence" timeline, so there is no numbered series to read back';
 /**
  * A09's, which predates this list and joins it rather than being rewritten: it
  * is the same fact about the same subject, and a control that compares against
@@ -458,6 +471,55 @@ const NAMED_TIMELINE_GROUPS = ['path', 'physics', 'slider'] as const;
 const PHYSICS_COMPONENTS = ['x', 'y', 'rotate', 'scaleX', 'shearX'] as const;
 const EDITOR_PHYSICS_COMPONENTS: ReadonlySet<(typeof PHYSICS_COMPONENTS)[number]> = new Set(['x', 'y'] as const);
 
+/**
+ * The half of a muted-at-rest refusal that says what was searched, and how
+ * widely — one text for `A23`, `A36` and `A37`, which ask one question of three
+ * constraint kinds (issues #743, #752). A rig with no animation at all says
+ * "none of the 0 animations" rather than implying somebody keyed something.
+ */
+function noneKeysItsMixAbove0(animations: number): string {
+  return `none of the ${animations} animation${animations === 1 ? '' : 's'} keys its mix above 0`;
+}
+
+/** The two repairs a muted-at-rest refusal names, since either one is a rig the runtime plays. */
+const REST_OR_KEY_ITS_MIX = 'rest it above 0, or key its mix above 0 in an animation';
+
+/**
+ * Every value one channel of a curve timeline can pose while it plays: each
+ * key's own value, and every sample of each Bezier segment the parser built
+ * between two keys (issue #752).
+ *
+ * ⚠️ The samples are the half a reading of the keys alone misses. The runtime
+ * interpolates a Bezier segment between the points `setBezier` stored
+ * (`Animation.js:257-298`), not between the two keys, so two keys of 0 joined
+ * by a curve whose handles lie above 0 pose values above 0 in between.
+ * [measured] on generated fixtures, a `mix` pair of 0 → 0 with its handles at
+ * 0.8 poses a path constraint's bone up to 32.69 away from the flat pair, a
+ * slider's by 0.54 and a physics constraint's by 3.81. Between two stored
+ * points the runtime is linear, so nothing it poses lies outside this list's
+ * range — which is what makes "is any of these above 0" the whole question.
+ *
+ * Channel `c` of frame `f` is `frames[f * entries + 1 + c]`. `curves[f]` is 0
+ * for linear, 1 for stepped and `2 + i` for a Bezier whose points start at `i`
+ * (`Animation.js:259-261`); `readCurve` stores one segment per channel in
+ * order, so channel `c`'s points start `2 * BEZIER_POINTS * c` further on, as
+ * `(time, value)` pairs. The storage is read through `curveStorage`, the one
+ * reach into that protected array, which `deformmeasure.ts` owns.
+ */
+function curveChannelValues(timeline: CurveTimeline, channel: number): number[] {
+  const entries = timeline.getFrameEntries();
+  const curves = curveStorage(timeline);
+  const values: number[] = [];
+  for (let i = 0, frame = 0; i < timeline.frames.length; i += entries, frame++) {
+    values.push(timeline.frames[i + 1 + channel]);
+    const code = curves[frame];
+    if (!(code >= 2)) continue;
+    const start = code - 2 + 2 * BEZIER_POINTS * channel;
+    for (let point = 0; point < BEZIER_POINTS; point++) values.push(curves[start + 2 * point + 1]);
+  }
+  return values;
+}
+
 /**
  * What A23 says about a SETUP pose outside its bound, per property.
  *
@@ -481,13 +543,21 @@ const EDITOR_PHYSICS_COMPONENTS: ReadonlySet<(typeof PHYSICS_COMPONENTS)[number]
  * other half was looked for and how wide the search was. A rig with no animation
  * at all then says "none of the 0 animations" rather than implying somebody
  * keyed something.
+ *
+ * `rule` is the row the value was judged by, and only the `strength` sentence
+ * reads it: its two arms live on the row (`outside`), beside the key's own
+ * sentence, so what the setup pose and a key say about one number is one text.
  */
-const SETUP_POSE_SAYS: Record<string, (pose: PhysicsConstraintPose, animations: number) => string> = {
-  mix: (pose, animations) =>
-    `has mix ${pose.mix} and none of the ${animations} animation${animations === 1 ? '' : 's'} keys its mix above 0; ` +
-    'it is muted — rest it above 0, or key its mix above 0 in an animation',
+const SETUP_POSE_SAYS: Record<
+  string,
+  (pose: PhysicsConstraintPose, animations: number, rule: PhysicsPoseRule) => string
+> = {
+  mix: (pose, animations) => `has mix ${pose.mix} and ${noneKeysItsMixAbove0(animations)}; it is muted — ${REST_OR_KEY_ITS_MIX}`,
   mass: (pose) => `has massInverse ${pose.massInverse} (mass must be > 0)`,
-  strength: (pose) => `has strength ${pose.strength}; nothing pulls it back`,
+  // Two arms, read off the row (issue #748): 0 is a constraint nothing pulls
+  // back and below 0 one that is pushed away, and the row's `why` — the key's
+  // sentence — quotes the second from the same object.
+  strength: (pose, _animations, rule) => `has strength ${pose.strength}; ${physicsOutsideSays(rule, pose.strength)}`,
   damping: (pose) => `has damping ${pose.damping}; outside (0,1) it never settles`,
 };
 
@@ -513,6 +583,53 @@ export const PHYSICS_TIMELINE_NAMES: Record<number, string> = {
   [Property.physicsConstraintMix]: 'mix',
 };
 
+/**
+ * Which physics constraints a physics timeline that names NO constraint writes
+ * into — the one reading of the unnamed form, for every rule that has to answer
+ * it (`A23`, `A34`, `A42`; issue #726).
+ *
+ * `SkeletonJson` gives a physics group keyed by the empty name `constraintIndex
+ * -1` (`SkeletonJson.js:1048-1054`), and the runtime reads that two ways. A
+ * value timeline writes every active physics constraint whose own data declares
+ * that property global — `PhysicsConstraintTimeline.apply` asks each subclass's
+ * `global` (`Animation.js:2067-2075`). `reset` resets every active one and asks
+ * no flag at all (`:2234-2238`). Activity is a skin question and is not asked
+ * here: a constraint a skin switches on is still one the timeline can reach.
+ *
+ * 🔑 `constraints` may be the FILE's objects rather than loaded data, and that
+ * is what makes this one reading rather than two: `SkeletonJson` copies each
+ * `…Global` field onto the data verbatim (`:313-319`), so the runtime's own
+ * `global`, asked of the raw object, reads exactly what it would read of the
+ * loaded one — a string `"false"` included, which is truthy to both. A rule that
+ * spelled `<property>Global` itself would be a second copy of the runtime's
+ * table, free to disagree with it.
+ */
+export function unnamedPhysicsReach<C extends object>(timeline: Timeline, constraints: readonly C[]): C[] {
+  if (timeline instanceof PhysicsConstraintResetTimeline) return [...constraints];
+  if (!(timeline instanceof PhysicsConstraintTimeline)) return [];
+  return constraints.filter((one) => Boolean(timeline.global(one as unknown as PhysicsConstraintData)));
+}
+
+/**
+ * The timeline the runtime builds for one physics timeline NAME, read by the
+ * runtime's own parser off a skeleton that holds nothing else — or null for a
+ * name its physics branch skips (`SkeletonJson.js:1094`).
+ *
+ * ⚠️ This is how a raw-JSON rule gets the runtime's class for a name without a
+ * table of the eight: a hand-kept map from `"strength"` to
+ * `PhysicsConstraintStrengthTimeline` is the copy this avoids, and the parser's
+ * `switch` is already that map. The probe skeleton declares no constraint, so
+ * the only group it can carry is the unnamed one, and one key is all
+ * `readTimeline1` needs to build the object.
+ */
+export function unnamedPhysicsTimeline(name: string): Timeline | null {
+  const probe = new SkeletonJson(new AtlasAttachmentLoader(new TextureAtlas(''))).readSkeletonData({
+    skeleton: {},
+    animations: { probe: { physics: { '': { [name]: [{}] } } } },
+  });
+  return probe.animations[0]?.timelines[0] ?? null;
+}
+
 /**
  * One step of the **float32** grid at `t`, which is the grid a loaded key time
  * actually sits on: `spine-core` reads every timeline's frames into a
@@ -960,127 +1077,6 @@ export function timelineAddBehaviour(data: ReturnType<SkeletonJson['readSkeleton
   return wrote ? 'overwrites' : 'inert';
 }
 
-/**
- * The one page rectangle every region on a page shares: the size the atlas
- * declares for it against the size of the file it names.
- *
- * ⭐ **What a size that disagrees with the file is and is not**, measured rather
- * than assumed (issue #715). `TextureAtlas` computes every region's UVs as a
- * fraction of the DECLARED size — `region.u = region.x / page.width`, spine-core
- * 4.3.13 `dist/TextureAtlas.js:162-171` — `MeshAttachment.computeUVs` takes its
- * `textureWidth` from the same field (`dist/attachments/MeshAttachment.js:125`),
- * `RegionAttachment.computeUVs` reads nothing but `u/v/u2/v2`
- * (`dist/attachments/RegionAttachment.js:152-167`), and `TextureAtlasPage.setTexture`
- * never writes `width`/`height`. So **nothing in the region mapping reads the
- * texture's own size**, and a page whose PNG is the declared page RESCALED is
- * addressed at the same fraction of the picture whatever size the file is:
- * measured on a coordinate-ramp page where every texel names its own position,
- * rigc's own rasteriser drew 116,480 pixels in both and 0 in exactly one at a
- * uniform 0.5.
- *
- * ⇒ That is why this is a clause about **texel** readers rather than about
- * drawing, and why it is nevertheless not renderer policy. Three readers address
- * the page at the coordinates the atlas states, and two of them are rigc's own:
- * `A19`'s alpha scan below, the region lift `partPlate` traces a mesh generator
- * over in [`src/compile.ts`](compile.ts), and `spine-html`'s region tier, which
- * cuts each part with `drawImage(image, x, y, w, h, …)` and says in its own
- * comment that it tests against the image rather than the `size:` line. Measured
- * on the same page: the lift returned 768 of 768 texels from somewhere else.
- *
- * 🔑 And the format already states coarser texels honestly — `scale:`, which
- * rigc reads (`AtlasPage.scale`) and `--atlas-in` divides by. The same art
- * declared that way builds green and renders identically, so this refusal names
- * a repair the format provides rather than one rigc invented.
- */
-interface PageGridReading {
-  /** file width / declared width, and the same for height. Both 1 when they agree. */
-  readonly x: number;
-  readonly y: number;
-  /** One ratio for both axes — the only relation a `scale:` line can state. */
-  readonly uniform: boolean;
-}
-
-/** `null` when the page declares no positive size for the ratios to divide by. */
-function pageGridReading(
-  declared: { width: number; height: number },
-  file: { width: number; height: number },
-): PageGridReading | null {
-  if (declared.width <= 0 || declared.height <= 0) return null;
-  return {
-    x: file.width / declared.width,
-    y: file.height / declared.height,
-    // Cross-multiplied rather than compared as two divisions: the question is
-    // whether one rational number describes both axes, and two floats that
-    // round to the same digits are not that.
-    uniform: file.width * declared.height === file.height * declared.width,
-  };
-}
-
-/** A ratio, printed the one way every message here prints one. */
-function gridRatio(n: number): string {
-  return n.toFixed(4);
-}
-
-/**
- * The first number on this page that a `scale:` re-declaration could not carry,
- * or `null` when every one of them lands on a whole texel of the file.
- *
- * Every number in a region block is in the page's own texel units — `bounds` and
- * `offsets` alike — so re-declaring the page at the file's size means scaling all
- * eight by the same ratio, and a region that then lands between texels is one no
- * reader could cut out. Stated as integer arithmetic (`n * file % declared`)
- * rather than as a float test, so the answer does not depend on how the ratio
- * rounded. ⚠️ One ratio for both axes, so this is the UNIFORM case's question
- * and is only ever asked there — a page whose two axes differ has no `scale:`
- * line to be re-declared with at all.
- */
-function firstNumberOffTheCoarseGrid(
-  regions: ReadonlyArray<{
-    name: string;
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    offsetX: number;
-    offsetY: number;
-    originalWidth: number;
-    originalHeight: number;
-  }>,
-  declared: number,
-  file: number,
-): string | null {
-  for (const region of regions) {
-    const numbers: Array<[string, number]> = [
-      ['bounds x', region.x],
-      ['bounds y', region.y],
-      ['bounds width', region.width],
-      ['bounds height', region.height],
-      ['offsets offsetX', region.offsetX],
-      ['offsets offsetY', region.offsetY],
-      ['offsets originalWidth', region.originalWidth],
-      ['offsets originalHeight', region.originalHeight],
-    ];
-    for (const [field, value] of numbers) {
-      if ((value * file) % declared === 0) continue;
-      return (
-        `region ${JSON.stringify(region.name.trim())}'s \`${field}\` of ${value} becomes ` +
-        `${((value * file) / declared).toFixed(4)} on the file's own grid, which is not a whole texel`
-      );
-    }
-  }
-  return null;
-}
-
-/** What every size-mismatch sentence says before it says what to do about it. */
-const PAGE_GRID_PREAMBLE =
-  'A runtime does not read the file\'s own size anywhere in the region mapping — `TextureAtlas` computes every ' +
-  "region's UVs as a fraction of the DECLARED size (`region.u = region.x / page.width`, spine-core " +
-  '`dist/TextureAtlas.js:162-171`) — so a page whose PNG is the declared page RESCALED draws the same picture at ' +
-  "the file's resolution, and one whose PNG is anything else draws whatever sits at those fractions. What a " +
-  'declared size that disagrees with the file breaks is every reader that addresses the page in TEXELS: this ' +
-  "validator's own `A19` alpha scan, the region lift rigc's mesh generators trace, and a canvas renderer that " +
-  'cuts each part out of the page by source rectangle.';
-
 export function validate(input: ValidateInput): ValidateReport {
   const failures: Failure[] = [];
   const passed: string[] = [];
@@ -1518,6 +1514,10 @@ export function validate(input: ValidateInput): ValidateReport {
         kindsOf.set(entry.name, [...(kindsOf.get(entry.name) ?? []), String(entry.type)]);
       }
     }
+    /** The file's physics constraints, which the unnamed physics group is read against. */
+    const rawPhysics = (Array.isArray(raw.constraints) ? (raw.constraints as unknown[]) : []).filter(
+      (entry): entry is Json => isObj(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: Array<[string, unknown]>): void => {
@@ -1539,6 +1539,10 @@ export function validate(input: ValidateInput): ValidateReport {
         );
         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: Array<[string, unknown]>): void => {
       if (keyArrays.length === 0) {
         fail(
           'A34_CONSTRAINT_TIMELINE_TARGETS',
@@ -1580,6 +1584,36 @@ export function validate(input: ValidateInput): ValidateReport {
             );
             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 (`:1048-1054`), 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 [timelineName] of Object.entries(timelines)) {
+              const timeline = unnamedPhysicsTimeline(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 (timeline === null || unnamedPhysicsReach(timeline, rawPhysics).length > 0) continue;
+              const resets = timeline instanceof PhysicsConstraintResetTimeline;
+              fail(
+                'A34_CONSTRAINT_TIMELINE_TARGETS',
+                `${at} timeline "${timelineName}": a physics group that names no constraint writes every physics ` +
+                  `constraint ${resets ? 'the skeleton has' : `declaring "${timelineName}Global": true`}, and ` +
+                  (rawPhysics.length === 0
+                    ? 'the skeleton has no physics constraint'
+                    : `none of ${rawPhysics.map((one) => `"${String(one.name)}"`).join(', ')} does`) +
+                  ' — the parser loads it, the runtime walks every constraint, and no constraint takes the key',
+              );
+            }
+            checkKeys(at, Object.entries(timelines));
+            continue;
+          }
           checkTarget(at, group, name, Object.entries(timelines));
         }
       }
@@ -2981,6 +3015,58 @@ export function validate(input: ValidateInput): ValidateReport {
       if (survey.spansUnconfirmed) stats.deformSpansUnconfirmed = survey.spansUnconfirmed;
     });
 
+    /**
+     * The constraints some animation keys to a value `live` accepts, on any
+     * channel of a timeline `owns` claims — the one answer to "does anything
+     * switch this on" for `A23`, `A36`, `A37` and `A40` (issues #743, #752).
+     *
+     * ⭐ It replaced `keyedBy`, which read the raw JSON and took a non-empty key
+     * array as the answer, and it did so rather than teaching that one to read
+     * values, because the raw file is the wrong place to read a value: a path
+     * `mix` key that omits `mixRotate` means 1 (`SkeletonJson.js:1011-1013`), a
+     * `mixY` it omits means that key's `mixX`, and a Bezier between two keys
+     * poses values neither key states. A raw reader would restate the parser's
+     * defaults and re-derive its curves — a second opinion on the runtime's own
+     * numbers — so this reads the loaded timelines instead, with
+     * `curveChannelValues` for the curves. [measured] the reading `keyedBy` gave
+     * was wrong in the accepting direction: a path constraint and a slider,
+     * both muted at rest and keyed to 0 only, pose every bone exactly where the
+     * same rig with no timeline does (max |Δ| 0.000000 over 60 steps at 60 fps) and both
+     * passed.
+     *
+     * A timeline naming no constraint is the physics family's global form and
+     * `unnamedPhysicsReach` answers who it reaches; every other constraint
+     * timeline names its one constraint by index.
+     */
+    const keyedLive = <T extends CurveTimeline & ConstraintTimeline>(
+      owns: (timeline: Timeline) => timeline is T,
+      live: (timeline: T, value: number) => boolean,
+    ): Set<object> => {
+      const reached = new Set<object>();
+      for (const animation of data.animations) {
+        for (const timeline of animation.timelines) {
+          if (!owns(timeline)) continue;
+          let keysLive = false;
+          for (let channel = 0; channel < timeline.getFrameEntries() - 1 && !keysLive; channel++) {
+            keysLive = curveChannelValues(timeline, channel).some((value) => live(timeline, value));
+          }
+          if (!keysLive) continue;
+          const reach =
+            timeline.constraintIndex === -1
+              ? unnamedPhysicsReach(timeline, data.constraints.filter((one) => one instanceof PhysicsConstraintData))
+              : [data.constraints[timeline.constraintIndex]];
+          for (const one of reach) if (one) reached.add(one);
+        }
+      }
+      return reached;
+    };
+
+    /**
+     * The one predicate a path or slider mix is judged by, at setup and on every
+     * value a key poses: above 0, where `update()` does anything at all.
+     */
+    const mixLive = (value: number): boolean => value > 0;
+
     // --- A23: a physics constraint that does nothing, quietly ---------------
     //
     // Every failure mode here is silent. The five component fields default to
@@ -3036,37 +3122,30 @@ export function validate(input: ValidateInput): ValidateReport {
       // [measured] at rest it reads NaN on every frame although an animation
       // keys `mass` to 1. A key cannot rescue a value that has already broken
       // the rig it is resting in.
+      //
+      // The keys are read by `keyedLive`, the one reading A36 and A37 share
+      // (issue #752), through the runtime's own accessor: the pose field is
+      // where the integrator reads the number, and for `mass` that is not the
+      // number the key states. It counts the unnamed global form through
+      // `unnamedPhysicsReach` and a Bezier segment's samples as well as its keys.
       const unmuted = new Map<PhysicsConstraintData, Set<string>>();
       const raised = new PhysicsConstraintPose();
-      for (const animation of data.animations) {
-        for (const timeline of animation.timelines) {
-          if (!(timeline instanceof PhysicsConstraintTimeline)) continue;
-          const rule = physicsRuleFor(PHYSICS_TIMELINE_NAMES[Number(timeline.getPropertyIds()[0].split('|')[0])] ?? '');
-          if (rule === undefined || !rule.inertAtSetup) continue;
-          const entries = timeline.getFrameEntries();
-          let keysInside = false;
-          for (let i = 0; i < timeline.frames.length && !keysInside; i += entries) {
-            // The runtime's own accessor, for the reason the second arm uses it:
-            // the pose field is where the integrator reads the number, and for
-            // `mass` that is not the number the key states.
-            timeline.set(raised, timeline.frames[i + 1]);
-            keysInside = rule.poseOk(raised[rule.field]);
-          }
-          if (!keysInside) continue;
-          // -1 is the global form: the timeline names no constraint and the
-          // runtime applies it to every physics constraint whose own data
-          // declares that property global (`Animation.js:2067-2075`). No rig
-          // spec can reach it — the compiler refuses a track naming a constraint
-          // the skeleton has not got, the empty name among them — but a file
-          // rigc did not write can carry one, and `timeline.global` is the
-          // runtime's own answer to which constraints it reaches.
-          for (const one of data.constraints) {
-            if (!(one instanceof PhysicsConstraintData)) continue;
-            if (timeline.constraintIndex === -1 ? !timeline.global(one) : data.constraints[timeline.constraintIndex] !== one) continue;
-            const by = unmuted.get(one) ?? new Set<string>();
-            by.add(rule.timeline);
-            unmuted.set(one, by);
-          }
+      for (const rule of PHYSICS_POSE_RULES) {
+        if (!rule.inertAtSetup) continue;
+        const reached = keyedLive(
+          (timeline): timeline is PhysicsConstraintTimeline =>
+            timeline instanceof PhysicsConstraintTimeline &&
+            PHYSICS_TIMELINE_NAMES[Number(timeline.getPropertyIds()[0].split('|')[0])] === rule.timeline,
+          (timeline, value) => {
+            timeline.set(raised, value);
+            return rule.poseOk(raised[rule.field]);
+          },
+        );
+        for (const one of data.constraints) {
+          if (!(one instanceof PhysicsConstraintData) || !reached.has(one)) continue;
+          const by = unmuted.get(one) ?? new Set<string>();
+          by.add(rule.timeline);
+          unmuted.set(one, by);
         }
       }
       let mutedUntilKeyed = 0;
@@ -3092,7 +3171,7 @@ export function validate(input: ValidateInput): ValidateReport {
           const drivesAMesh = rule.timeline === 'damping' && meshBoneNames.has(constraint.bone.name);
           fail(
             'A23_PHYSICS_CONSTRAINT_EFFECTIVE',
-            `${where} ${SETUP_POSE_SAYS[rule.timeline](pose, data.animations.length)}` +
+            `${where} ${SETUP_POSE_SAYS[rule.timeline](pose, data.animations.length, rule)}` +
               (drivesAMesh ? ' — and this bone drives a mesh, so the canvas never rests' : ''),
           );
         }
@@ -3246,7 +3325,9 @@ export function validate(input: ValidateInput): ValidateReport {
     });
 
     /**
-     * Does any animation key `<group>.<constraint>.<timeline>`?
+     * Which path constraints and sliders an animation switches ON — `keyedLive`
+     * over their `mix` timelines, judged by `mixLive`, the predicate their setup
+     * pose is judged by below.
      *
      * ⭐ The reason the two assertions below need this: a constraint whose mixes
      * are all 0 at setup is **the idiom**, not a defect — spineboy's aim rig is
@@ -3254,30 +3335,23 @@ export function validate(input: ValidateInput): ValidateReport {
      * "muted" is only a finding when nothing turns it on, and that question
      * lives in the animations rather than in the constraint.
      *
-     * ⚠️ This comment used to add "and the reason they are not A23 with a
-     * different type name", which said the idiom stops at path and slider
-     * constraints. It does not: a production rig rests 87 of its 87 physics
-     * constraints at `mix` 0 and keys them up in four of its six animations
-     * (issue #743), so A23 asks the same question now — and does NOT ask it
-     * here. Two reasons, both measured: this reads the raw JSON and takes a
-     * non-empty key array as a rescue, so a `mix` timeline that keys **0 only**
-     * counts, and [measured] such a rig poses its bone exactly where one with no
-     * timeline at all does; and it cannot see the unnamed global form, which the
-     * runtime applies to every constraint declaring that property global. A23's
-     * arm reads the key VALUES through the runtime's own accessor and asks
-     * `PhysicsConstraintTimeline.global` who they reach.
+     * 🔑 "Turns it on" is a VALUE question, and until issue #752 these two 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`), and `Slider.update` when
+     * `mix` is (`Slider.js:53-54`).
      */
-    const keyedBy = (group: string, name: string, timeline: string): boolean => {
-      if (!raw || !isObj(raw.animations)) return false;
-      for (const anim of Object.values(raw.animations as Json)) {
-        if (!isObj(anim) || !isObj(anim[group])) continue;
-        const timelines = (anim[group] as Json)[name];
-        if (!isObj(timelines)) continue;
-        const keys = timelines[timeline];
-        if (Array.isArray(keys) && keys.length > 0) return true;
-      }
-      return false;
-    };
+    const pathSwitchedOn = keyedLive(
+      (timeline): timeline is PathConstraintMixTimeline => timeline instanceof PathConstraintMixTimeline,
+      (_timeline, value) => mixLive(value),
+    );
+    const sliderSwitchedOn = keyedLive(
+      (timeline): timeline is SliderMixTimeline => timeline instanceof SliderMixTimeline,
+      (_timeline, value) => mixLive(value),
+    );
 
     // --- A36: a path constraint that follows nothing, quietly ---------------
     //
@@ -3293,9 +3367,9 @@ export function validate(input: ValidateInput): ValidateReport {
     // 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 the
-    // `mix` timeline (see `keyedBy`), and a chain with no bones on it is one
-    // whether or not anything is keyed.
+    // nothing. All three mixes at 0 is only a finding when no animation keys one
+    // of them above 0 (see `pathSwitchedOn`), and a chain with no bones on it is
+    // one whether or not anything is keyed.
     check('A36_PATH_CONSTRAINT_EFFECTIVE', () => {
       const constraints = data.constraints.filter((c) => c instanceof PathConstraintData);
       if (!constraints.length) return skip('A36_PATH_CONSTRAINT_EFFECTIVE', 'the skeleton declares no path constraint');
@@ -3322,12 +3396,13 @@ export function validate(input: ValidateInput): ValidateReport {
           );
         }
         const pose = constraint.setupPose;
-        const muted = !(pose.mixRotate > 0) && !(pose.mixX > 0) && !(pose.mixY > 0);
-        if (muted && !keyedBy('path', constraint.name, 'mix')) {
+        const muted = ![pose.mixRotate, pose.mixX, pose.mixY].some(mixLive);
+        if (muted && !pathSwitchedOn.has(constraint)) {
           fail(
             'A36_PATH_CONSTRAINT_EFFECTIVE',
-            `${where} has mixRotate ${pose.mixRotate}, mixX ${pose.mixX} and mixY ${pose.mixY} at setup and no ` +
-              'animation keys its mix timeline; update() returns on all-zero mixes, so nothing ever puts a bone on the path',
+            `${where} has mixRotate ${pose.mixRotate}, mixX ${pose.mixX} and mixY ${pose.mixY} at setup and ` +
+              `${noneKeysItsMixAbove0(data.animations.length)}; 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',
           );
         }
       }
@@ -3384,10 +3459,11 @@ export function validate(input: ValidateInput): ValidateReport {
           );
         }
         const mix = slider.setupPose.mix;
-        if (!(mix > 0) && !keyedBy('slider', slider.name, 'mix')) {
+        if (!mixLive(mix) && !sliderSwitchedOn.has(slider)) {
           fail(
             'A37_SLIDER_CONSTRAINT_EFFECTIVE',
-            `${where} has mix ${mix} at setup and no animation keys its mix timeline; update() returns on mix 0`,
+            `${where} has mix ${mix} at setup and ${noneKeysItsMixAbove0(data.animations.length)}; update() returns ` +
+              `on mix 0 — ${REST_OR_KEY_ITS_MIX}`,
           );
         }
       }
@@ -3510,7 +3586,15 @@ export function validate(input: ValidateInput): ValidateReport {
         );
       }
       // Clause 1 of the "could this be correct?" list above.
-      const authoritative = sliders.filter((s) => s.setupPose.mix >= 1 && !keyedBy('slider', s.name, 'mix'));
+      // "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 `keyedLive` gives, and unchanged by issue #752.
+      const mixKeyed = keyedLive(
+        (timeline): timeline is SliderMixTimeline => timeline instanceof SliderMixTimeline,
+        () => true,
+      );
+      const authoritative = sliders.filter((s) => s.setupPose.mix >= 1 && !mixKeyed.has(s));
       if (authoritative.length < 2) {
         return skip(
           'A40_SLIDERS_COMPOSE_ON_A_SHARED_TARGET',
@@ -3709,15 +3793,16 @@ export function validate(input: ValidateInput): ValidateReport {
        * A physics timeline whose animation names no constraint carries
        * `constraintIndex -1`, and `PhysicsConstraintTimeline.apply` reads that
        * as every ACTIVE physics constraint whose own data declares that property
-       * global. No rig spec reaches it — the compiler refuses a track naming an
-       * unknown physics constraint, the empty name among them — but a file rigc
-       * did not write can carry one, and this is the only assertion that would
-       * have to guess at it.
+       * global. A motion spec spells it `"physics": "*"` (issue #726) and a
+       * foreign file the empty name; `unnamedPhysicsReach` is the one reading
+       * of it, shared with `A23` and `A34`.
        */
       const drivenBy = (timeline: Timeline & ConstraintTimeline): number[] => {
         if (timeline.constraintIndex >= 0) return [timeline.constraintIndex];
-        if (!(timeline instanceof PhysicsConstraintTimeline)) return [];
-        return data.constraints.flatMap((one, index) => (one instanceof PhysicsConstraintData && timeline.global(one) ? [index] : []));
+        return unnamedPhysicsReach(
+          timeline,
+          data.constraints.filter((one) => one instanceof PhysicsConstraintData),
+        ).map((one) => data.constraints.indexOf(one));
       };
       let pairs = 0;
       let resets = 0;
@@ -3931,6 +4016,64 @@ export function validate(input: ValidateInput): ValidateReport {
       // static rig has no duration to compare — and the two must not print
       // different verdicts over one skeleton's empty animation list.
       if (data.animations.length === 0) return skip('A10_NO_NAN_AFTER_STEPPING', SKIP_NO_ANIMATION);
+      /** Is this a mode `updateWorldTransform`'s switch has a case for? Read off the runtime's own enum. */
+      const isMode = (inherit: unknown): boolean => typeof inherit === 'number' && Inherit[inherit] !== undefined;
+
+      // -- the bone's inheritance mode, posed at every `inherit` key ---------
+      //
+      // 🚨 The one bone timeline whose value is a NAME, and the only one that
+      // can pose a NaN with a finite world: `SkeletonJson` resolves a key's mode
+      // through `Utils.enumValue`, which folds the first letter's case and
+      // nothing else, so `"NOSCALE"` resolves to `undefined` and the timeline's
+      // `Float32Array` frame stores NaN. `InheritTimeline.apply` then sets
+      // `pose.inherit = NaN`, `updateWorldTransform`'s switch matches no case,
+      // and the bone keeps whatever world matrix it had — measured on a forged
+      // two-bone chain: at the key the child's `a,b,c,d` equal the setup
+      // Normal-mode pose to the last digit while the file says `noScale`. The
+      // world position stays finite, so the loop below never saw it (#733).
+      //
+      // ⚠️ Posed AT each key rather than read off the stepping loop, because a
+      // stepped value lives from its key to the next one and a sampling grid
+      // can step over a short span entirely. What is judged is whether the
+      // posed value IS a mode — which is this assertion's name exactly — and
+      // not which mode: for any spelling the lookup resolves, the mode posed
+      // is the mode written by construction of the same lookup, so an equality
+      // here would be the parser agreeing with itself.
+      const rawAnimations = isObj(raw) && isObj(raw.animations) ? raw.animations : {};
+      let unresolved = 0;
+      for (const [animName, rawAnim] of Object.entries(rawAnimations)) {
+        if (!isObj(rawAnim) || !isObj(rawAnim.bones)) continue;
+        for (const [boneName, timelines] of Object.entries(rawAnim.bones)) {
+          if (!isObj(timelines) || !Array.isArray(timelines.inherit)) continue;
+          if (!data.findAnimation(animName) || !data.findBone(boneName)) continue;
+          for (const rawKey of timelines.inherit as unknown[]) {
+            if (!isObj(rawKey)) continue;
+            const time = typeof rawKey.time === 'number' ? rawKey.time : 0;
+            const skeleton = new Skeleton(data);
+            const state = new AnimationState(new AnimationStateData(data));
+            state.setAnimation(0, animName, false);
+            skeleton.setupPose();
+            skeleton.update(0);
+            skeleton.updateWorldTransform(Physics.reset);
+            state.update(time);
+            state.apply(skeleton);
+            skeleton.update(time);
+            skeleton.updateWorldTransform(Physics.update);
+            const posed = skeleton.findBone(boneName)?.appliedPose.inherit;
+            if (isMode(posed)) continue;
+            unresolved++;
+            fail(
+              'A10_NO_NAN_AFTER_STEPPING',
+              `animation "${animName}" bone "${boneName}" inherit (t=${time}): the bone poses inheritance mode ` +
+                `${String(posed)} — the key spells ${JSON.stringify(rawKey.inherit)}, which the runtime's mode lookup ` +
+                `does not resolve (${BONE_INHERIT_KNOWN}), so no mode applies until the next key and the bone keeps ` +
+                'the world rotation, scale and shear it had',
+            );
+          }
+        }
+      }
+      if (unresolved > 0) return;
+
       for (const anim of data.animations) {
         const skeleton = new Skeleton(data);
         const state = new AnimationState(new AnimationStateData(data));
@@ -3950,6 +4093,23 @@ export function validate(input: ValidateInput): ValidateReport {
               fail('A10_NO_NAN_AFTER_STEPPING', `${anim.name}: bone "${bone.data.name}" world is (${pose.worldX}, ${pose.worldY})`);
               return;
             }
+            // The setup half of the clause above: a bone's own `inherit` goes
+            // through the same lookup, and a miss there loads `undefined` into
+            // the setup pose, which every frame copies. Only reachable on a
+            // file rigc did not write — `parseRigSpec` refuses the spelling.
+            if (!isMode(pose.inherit)) {
+              const rawBone = Array.isArray(raw?.bones)
+                ? (raw.bones as unknown[]).find((b) => isObj(b) && b.name === bone.data.name)
+                : undefined;
+              fail(
+                'A10_NO_NAN_AFTER_STEPPING',
+                `${anim.name}: bone "${bone.data.name}" poses inheritance mode ${String(pose.inherit)} — its setup ` +
+                  `spells inherit ${JSON.stringify(isObj(rawBone) ? rawBone.inherit : undefined)}, which the ` +
+                  `runtime's mode lookup does not resolve (${BONE_INHERIT_KNOWN}), so its world rotation, scale and shear ` +
+                  'are never computed — they stay 0 and everything the bone carries collapses to a point',
+              );
+              return;
+            }
           }
           for (const slot of skeleton.slots) {
             const c = slot.appliedPose.color;
@@ -4420,6 +4580,259 @@ export function validate(input: ValidateInput): ValidateReport {
         );
       }
     });
+
+    // --- A46: a numbered series shows the frame the file states ------------
+    //
+    // 🚨 Every way this goes wrong loads without a word (issue #729, measured on
+    // spine-core 4.3.13): a `sequence` block with no `count` loads a series of
+    // no region; a `setup` past the end is clamped to the last frame; a key's
+    // `mode` outside the seven loads as `hold`; an `index` past the end is
+    // clamped and a fraction truncated; an advancing mode at an effective delay
+    // of 0 never advances; and a `sequence` timeline on an attachment with no
+    // block steps a one-region series and shows that region under every mode.
+    //
+    // ⭐ Two halves, and the second is the one only posing can see. The first
+    // reads each of those off the FILE and names the value. The second POSES
+    // every key at sampled times — mid-frame, so a float32 key time cannot land
+    // a sample on a frame boundary — and compares the region the slot shows
+    // against the one the file's own statement gives: the frame arithmetic of
+    // `SequenceTimeline.applyToSlot` transcribed here, and the frame names of
+    // `Sequence.getPath` transcribed in `attachmentRegionLookups`. Neither is
+    // read off the loaded timeline, so the check is not the runtime agreeing
+    // with itself.
+    //
+    // ⚠️ A sample where the slot shows some other attachment is not compared —
+    // `applyToSlot` returns there, and a series that is hidden is not a series
+    // showing the wrong frame. A timeline with no comparable sample at all is
+    // counted in `stats.sequenceSamplesUnshown` rather than failed.
+    check('A46_SEQUENCE_ATTACHMENTS_SHOW_THE_FRAME_THE_FILE_STATES', () => {
+      const NAME = 'A46_SEQUENCE_ATTACHMENTS_SHOW_THE_FRAME_THE_FILE_STATES';
+      type Series = { where: string; lookups: string[] | null; count: number; setup: number };
+      /** The loaded attachment -> what the FILE says its series is. */
+      const series = new Map<object, Series>();
+      /** `skin\0slot\0placeholder` -> the loaded attachment, for the timelines to find. */
+      const byJoin = new Map<string, object>();
+      /** Attachments whose block was already refused above — their timelines say nothing more. */
+      const refused = new Set<object>();
+      const whole = (v: unknown, fallback: number): number | null =>
+        v === undefined ? fallback : typeof v === 'number' && Number.isInteger(v) ? v : null;
+      let blocks = 0;
+      for (const skin of isObj(raw) && Array.isArray(raw.skins) ? (raw.skins as unknown[]) : []) {
+        if (!isObj(skin) || !isObj(skin.attachments)) continue;
+        const skinName = typeof skin.name === 'string' ? skin.name : '(unnamed)';
+        const loadedSkin = data.findSkin(skinName);
+        for (const [slotName, entries] of Object.entries(skin.attachments)) {
+          if (!isObj(entries)) continue;
+          const slotIndex = data.findSlot(slotName)?.index;
+          for (const [placeholder, entry] of Object.entries(entries)) {
+            if (!isObj(entry)) continue;
+            const type = entry.type === undefined ? 'region' : entry.type;
+            if (type !== 'region' && type !== 'mesh' && type !== 'linkedmesh') continue;
+            const loaded = slotIndex === undefined ? null : loadedSkin?.getAttachment(slotIndex, placeholder) ?? null;
+            const where = `skin ${JSON.stringify(skinName)} slot ${JSON.stringify(slotName)} attachment ${JSON.stringify(placeholder)}`;
+            if (loaded !== null) byJoin.set(`${skinName}\u0000${slotName}\u0000${placeholder}`, loaded);
+            if (entry.sequence === undefined || entry.sequence === null) continue;
+            blocks++;
+            const seq = entry.sequence;
+            const name = typeof entry.name === 'string' ? entry.name : placeholder;
+            const path = typeof entry.path === 'string' ? entry.path : name;
+            const count = isObj(seq) ? whole(seq.count, 0) : null;
+            const setup = isObj(seq) ? whole(seq.setup, 0) : null;
+            if ((count === null || setup === null || count < 1) && loaded !== null) refused.add(loaded);
+            if (count === null || setup === null || count < 1) {
+              fail(
+                NAME,
+                `${where}: the sequence states ${JSON.stringify(seq)}` +
+                  (isObj(seq) && seq.count === undefined
+                    ? ' and no "count" — `readSequence` reads 0 (`SkeletonJson.js:644`), so the attachment loads holding no region and draws nothing'
+                    : ' — "count" is a whole number of at least 1 and "setup" a whole number, or the series the parser builds is not the one written'),
+              );
+              continue;
+            }
+            if ((setup < 0 || setup >= count) && loaded !== null) refused.add(loaded);
+            if (setup < 0 || setup >= count) {
+              fail(
+                NAME,
+                `${where}: the sequence's setup frame is ${setup} of a ${count}-frame series (frames 0 to ${count - 1}); ` +
+                  '`Sequence.resolveIndex` clamps it, so the setup pose shows ' +
+                  `${setup < 0 ? 'no frame at all' : `frame ${count - 1}, which the file does not name`}`,
+              );
+              continue;
+            }
+            if (loaded === null) continue; // A00/A08 own an attachment that did not load
+            series.set(loaded, { where, lookups: attachmentRegionLookups(seq, path), count, setup });
+          }
+        }
+      }
+
+      /** The frame `SequenceTimeline.applyToSlot` shows — transcribed, not called. */
+      const frameOf = (mode: string, index: number, elapsed: number, delay: number, count: number): number => {
+        if (mode === 'hold') return index;
+        let i = index + Math.trunc(elapsed / delay + 0.00001);
+        const n = count * 2 - 2;
+        switch (mode) {
+          case 'once':
+            return Math.min(count - 1, i);
+          case 'loop':
+            return i % count;
+          case 'pingpong':
+            i = n === 0 ? 0 : i % n;
+            return i >= count ? n - i : i;
+          case 'onceReverse':
+            return Math.max(count - 1 - i, 0);
+          case 'loopReverse':
+            return count - 1 - (i % count);
+          default: // pingpongReverse
+            i = n === 0 ? 0 : (i + count - 1) % n;
+            return i >= count ? n - i : i;
+        }
+      };
+
+      let timelines = 0;
+      let compared = 0;
+      let unshown = 0;
+      const rawAnimations = isObj(raw) && isObj(raw.animations) ? raw.animations : {};
+      for (const [animName, anim] of Object.entries(rawAnimations)) {
+        if (!isObj(anim) || !isObj(anim.attachments)) continue;
+        for (const [skinName, perSkin] of Object.entries(anim.attachments)) {
+          if (!isObj(perSkin)) continue;
+          for (const [slotName, perSlot] of Object.entries(perSkin)) {
+            if (!isObj(perSlot)) continue;
+            for (const [placeholder, perAttachment] of Object.entries(perSlot)) {
+              if (!isObj(perAttachment) || !Array.isArray(perAttachment.sequence)) continue;
+              const keys = perAttachment.sequence as unknown[];
+              if (keys.length === 0) continue; // `readAnimation` skips it; A34 owns an empty timeline
+              timelines++;
+              const where = `animation ${JSON.stringify(animName)} ${skinName}/${slotName}/${placeholder} sequence`;
+              const keyed = byJoin.get(`${skinName}\u0000${slotName}\u0000${placeholder}`);
+              if (keyed === undefined) continue; // the parser throws on a missing target: A00's
+              if (refused.has(keyed)) continue; // its block is already named above
+              const own = series.get(keyed);
+              if (own === undefined) {
+                fail(
+                  NAME,
+                  `${where}: the timeline steps an attachment that carries no "sequence" block. The parser gives it a ` +
+                    'series of ONE region (`readSequence(null)` is `new Sequence(1, false)`), so every mode shows that ' +
+                    'region at every time — measured: a "loop" key on a plain region showed it throughout',
+                );
+                continue;
+              }
+              // -- the keys, as the file states them --------------------------
+              type Key = { time: number; mode: string; index: number; delay: number };
+              const read: Key[] = [];
+              let carried = 0;
+              let malformed = false;
+              keys.forEach((rawKey, k) => {
+                const key = isObj(rawKey) ? rawKey : {};
+                const at = `${where} key ${k}`;
+                const time = typeof key.time === 'number' ? key.time : 0;
+                const mode = key.mode === undefined ? 'hold' : key.mode;
+                const index = key.index === undefined ? 0 : key.index;
+                if (key.delay !== undefined) carried = typeof key.delay === 'number' ? key.delay : Number.NaN;
+                if (typeof mode !== 'string' || !(SEQUENCE_MODES as readonly string[]).includes(mode)) {
+                  malformed = true;
+                  fail(
+                    NAME,
+                    `${at} (t=${time}): mode ${JSON.stringify(key.mode)} is not one of the ${SEQUENCE_MODES.length} the ` +
+                      `format has (${SEQUENCE_MODES.join(', ')}); the parser reads \`SequenceMode[mode]\`, which is ` +
+                      'undefined, stores mode bits 0, and the key plays as "hold"',
+                  );
+                  return;
+                }
+                if (typeof index !== 'number' || !Number.isInteger(index) || index < 0 || index >= own.count) {
+                  malformed = true;
+                  fail(
+                    NAME,
+                    `${at} (t=${time}): index ${JSON.stringify(key.index)} is not a frame of the ${own.count}-frame series ` +
+                      `(0 to ${own.count - 1}); the runtime stores \`index << 4\`, truncating a fraction, and ` +
+                      '`Sequence.resolveIndex` clamps a frame past the end to the last one',
+                  );
+                  return;
+                }
+                if (mode !== 'hold' && !(carried > 0)) {
+                  malformed = true;
+                  fail(
+                    NAME,
+                    `${at} (t=${time}): "${mode}" at a delay of ${String(carried)}${key.delay === undefined ? ' (carried from the key before, 0 on the first)' : ''} — ` +
+                      'the frame advances by `(time - keyTime) / delay`, and at 0 that is Infinity, `Infinity | 0` is 0, ' +
+                      'and the key shows its first frame throughout: "hold" spelt as another mode',
+                  );
+                  return;
+                }
+                read.push({ time, mode, index, delay: carried });
+              });
+              if (malformed) continue;
+
+              // -- the pose, sampled ------------------------------------------
+              const animation = data.findAnimation(animName);
+              const slotIndex = data.findSlot(slotName)?.index;
+              if (animation === null || slotIndex === undefined) continue; // A00's
+              /** `key` is the index into `read`, or -1 before the first key (the setup frame). */
+              const samples: Array<{ time: number; key: number; steps: number }> = [];
+              const end = animation.duration;
+              if (read[0].time > 0) samples.push({ time: read[0].time / 2, key: -1, steps: 0 });
+              read.forEach((key, k) => {
+                const until = k + 1 < read.length ? read[k + 1].time : end;
+                if (key.mode === 'hold') {
+                  samples.push({ time: key.time, key: k, steps: 0 });
+                  return;
+                }
+                // Mid-frame, and enough steps to wrap every mode at least once.
+                for (let step = 0; step < own.count * 2 + 2; step++) {
+                  const time = key.time + (step + 0.5) * key.delay;
+                  if (time >= until || time > end) break;
+                  samples.push({ time, key: k, steps: step + 0.5 });
+                }
+              });
+              let shownHere = 0;
+              for (const sample of samples) {
+                const skeleton = new Skeleton(data);
+                const state = new AnimationState(new AnimationStateData(data));
+                state.setAnimation(0, animName, false);
+                skeleton.setupPose();
+                skeleton.update(0);
+                skeleton.updateWorldTransform(Physics.reset);
+                state.update(sample.time);
+                state.apply(skeleton);
+                const pose = skeleton.slots[slotIndex].appliedPose;
+                const shown = pose.attachment;
+                // The slot must show the keyed attachment or one playing its
+                // timelines — the only case `applyToSlot` writes.
+                if (shown === null || (shown !== keyed && shown.timelineAttachment !== keyed)) continue;
+                const drawn = series.get(shown);
+                if (drawn === undefined || drawn.lookups === null) continue;
+                shownHere++;
+                compared++;
+                // The frame count the runtime folds by is the SHOWN attachment's:
+                // a link with a series of its own steps it by its source's keys.
+                const key = sample.key < 0 ? null : read[sample.key];
+                const want = key === null ? drawn.setup : frameOf(key.mode, key.index, sample.time - key.time, key.delay, drawn.count);
+                const sequence = (shown as RegionAttachment | MeshAttachment).sequence;
+                const region = (sequence.regions[sequence.resolveIndex(pose)] as TextureAtlasRegion | null | undefined)?.name ?? null;
+                if (region !== drawn.lookups[want]) {
+                  fail(
+                    NAME,
+                    `${where} (t=${Number(sample.time.toFixed(4))}): the slot shows region ${JSON.stringify(region)}, and ` +
+                      `the file states frame ${want} of ${drawn.count} — ${JSON.stringify(drawn.lookups[want])} — ` +
+                      (key === null
+                        ? 'the setup frame, before the first key'
+                        : `key ${sample.key} plays "${key.mode}" from frame ${key.index} every ${key.delay}s, ` +
+                          `${sample.steps} delay(s) in`),
+                  );
+                  break;
+                }
+              }
+              if (shownHere === 0) unshown++;
+            }
+          }
+        }
+      }
+      if (blocks === 0 && timelines === 0) return skip(NAME, SKIP_NO_SEQUENCE);
+      stats.sequenceBlocks = blocks;
+      stats.sequenceTimelines = timelines;
+      stats.sequenceSamples = compared;
+      if (unshown > 0) stats.sequenceSamplesUnshown = unshown;
+    });
   }
 
   // --- A06 / A17 / A19: the atlas against the PNGs on disk ------------------
@@ -4486,7 +4899,9 @@ export function validate(input: ValidateInput): ValidateReport {
         );
       }
       const info = header.info;
-      if (info !== null && (page.width !== info.width || page.height !== info.height)) {
+      const onPage = atlas.regions.filter((region) => region.page.name === page.name);
+      const gridSaid = info === null ? null : pageGridSentence(page, info, onPage);
+      if (gridSaid !== null) {
         // 🔒 **Still validity, and now for a measured reason rather than an
         // inherited one** (issue #715). The card that opened this expected the
         // clause to move behind the profile switch once the runtime's mapping
@@ -4494,29 +4909,11 @@ export function validate(input: ValidateInput): ValidateReport {
         // draws. What settles it the other way is that the sentence below can
         // name a repair the FORMAT already provides (`scale:`), and that two of
         // the three readers a wrong grid breaks are rigc's own and run under
-        // both profiles. See `pageGridReading` for the routines and the figures.
-        const grid = pageGridReading(page, info);
-        const said = `page "${page.name}" declares ${page.width}x${page.height} and its PNG is ${info.width}x${info.height}`;
-        if (grid === null) {
-          fail('A06_ATLAS_PAGE_SIZE_MATCHES_PNG', `${said}. ${PAGE_GRID_PREAMBLE}`);
-        } else {
-          const ratios =
-            `${said} — ${gridRatio(grid.x)} of the declared width and ${gridRatio(grid.y)} of the declared ` +
-            'height.';
-          const onPage = atlas.regions.filter((region) => region.page.name === page.name);
-          const off = grid.uniform ? firstNumberOffTheCoarseGrid(onPage, page.width, info.width) : null;
-          const repair = !grid.uniform
-            ? 'The `scale:` header states one ratio for both axes, so a page whose axes differ cannot be ' +
-              `declared honestly at all: re-export the page at ${page.width}x${page.height}, or repack it.`
-            : off !== null
-              ? 'The format states coarser texels with the `scale:` header, but this page cannot be re-declared ' +
-                `that way: ${off}. Re-export the page at ${page.width}x${page.height}, or repack it.`
-              : 'The format states coarser texels with the `scale:` header and rigc builds that: declare ' +
-                `\`size: ${info.width}, ${info.height}\` with \`scale: ${gridRatio(grid.x)}\` and multiply every ` +
-                `\`bounds\`/\`offsets\` on this page by ${gridRatio(grid.x)}, and every part keeps the size it ` +
-                'has now.';
-          fail('A06_ATLAS_PAGE_SIZE_MATCHES_PNG', `${ratios} ${PAGE_GRID_PREAMBLE} ${repair}`);
-        }
+        // both profiles. The sentence, and the one derivation of the ratio under
+        // it, is `pageGridSentence` in [`src/atlas.ts`](atlas.ts): the compiler's
+        // region lift states the same one when it is asked for texels on such a
+        // page (issue #750), so the two cannot come to describe one page two ways.
+        fail('A06_ATLAS_PAGE_SIZE_MATCHES_PNG', gridSaid);
       }
       // 📐 PROFILE, from here down. `pma: false` and no rotation are rigc's atlas
       // CONVENTION, not the atlas format's rules — a packed page with