spine-rigc 0.28.0 → 0.30.0

package/src/validate.ts

@@ -65,13 +65,14 @@ import {
   TOPLEVEL_CONSTRAINT_ARRAYS,
   type SpineGeneration,
 } from './generation.ts';
-import { colourTypeName, readPngInfo } from './png.ts';
+import { colourTypeName, readPngHeader } from './png.ts';
 import {
   CHANNELS_BY_KIND,
   KEY_TIME_EPSILON,
   PHYSICS_POSE_RULES,
   physicsKeyRefusal,
   physicsRuleFor,
+  SLOT_COLOR_CHANNELS,
   walkTimelines,
 } from './timelines.ts';
 import type { RigInfo } from './types.ts';
@@ -195,6 +196,7 @@ const ASSERTION_KIND: Record<string, 'validity' | 'renderer' | 'archetype'> = {
   A42_DRIVEN_CONSTRAINTS_UPDATE_AFTER_THEIR_DRIVER: 'validity',
   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',
 };
 
 /**
@@ -297,7 +299,9 @@ export const SKIP_NO_ATLAS_REGION = 'the atlas declares no region';
 export const SKIP_NO_ATTACHMENT_REGION_JOIN =
   'no attachment names a region and the atlas declares none, so there is no attachment-to-region join to hold';
 export const SKIP_NO_TWO_COLOR_TINT =
-  'no slot declares a "dark" colour and no animation keys an "rgba2" timeline, so there is no two-colour tint to read back';
+  'no slot declares a "dark" colour and no animation keys an "rgba2" or "rgb2" timeline, so there is no two-colour tint to read back';
+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';
 /**
  * A09's, which predates this list and joins it rather than being rewritten: it
@@ -464,9 +468,24 @@ const EDITOR_PHYSICS_COMPONENTS: ReadonlySet<(typeof PHYSICS_COMPONENTS)[number]
  * is worth nothing to a compiler refusing a key. `PHYSICS_POSE_RULES` is the
  * index, so a rule added there with no sentence here fails to type-check rather
  * than printing `undefined`.
+ *
+ * ⚠️ These are the SETUP pose's sentences and nothing else, which matters on the
+ * two rows whose keyed bound is wider than their resting one — `mix` since issue
+ * #610 and `strength` since #727. A key of 0 on either is accepted, so "it is
+ * muted" and "nothing pulls it back" are read here by a rig that states the
+ * number at rest, and what a key is refused with is the row's own `why`.
+ *
+ * `animations` is how many animations the skeleton declares, and only the `mix`
+ * sentence reads it: that bound is the one a key can satisfy instead of the
+ * setup pose (`inertAtSetup`, issue #743), so the refusal has to say that the
+ * other half was looked for and how wide the search was. A rig with no animation
+ * at all then says "none of the 0 animations" rather than implying somebody
+ * keyed something.
  */
-const SETUP_POSE_SAYS: Record<string, (pose: PhysicsConstraintPose) => string> = {
-  mix: (pose) => `has mix ${pose.mix}; it is muted`,
+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',
   mass: (pose) => `has massInverse ${pose.massInverse} (mass must be > 0)`,
   strength: (pose) => `has strength ${pose.strength}; nothing pulls it back`,
   damping: (pose) => `has damping ${pose.damping}; outside (0,1) it never settles`,
@@ -941,6 +960,127 @@ 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[] = [];
@@ -2873,6 +3013,63 @@ export function validate(input: ValidateInput): ValidateReport {
           }
         }
       }
+      // --- which constraints an animation switches ON (issue #743) ----------
+      //
+      // 🔑 The setup pose is the rig AT REST, and one of the four bounds is a
+      // state rather than a break there: `PHYSICS_POSE_RULES` marks `mix`
+      // `inertAtSetup`, because `update` opens with `if (mix === 0) return;`
+      // (`PhysicsConstraint.js:109-111`) and nothing else in the pose has such a
+      // branch. So a constraint that rests muted and is keyed above 0 by an
+      // animation is a rig the runtime plays as authored, and refusing it would
+      // refuse a design: physics off at rest, switched on by the animation that
+      // needs it.
+      //
+      // 📏 Measured on a generated physics fixture, 36 steps at 60 fps with the
+      // constraint's own bone swung by its parent: resting at `mix` 0 with an
+      // animation keying `mix` to 1 poses the bone IDENTICALLY to the same rig
+      // resting at 1 (max |dx| 0.000000) and up to 7.771177 away from the twin
+      // that keys nothing — which poses identically to one keyed to 0 only
+      // (max |dx| 0.000000). Two states, and the file says which.
+      //
+      // ⚠️ The escape is the rule's own field rather than the word "mix": a
+      // setup `mass` of 0 is `massInverse` Infinity BEFORE anything plays, and
+      // [measured] at rest it reads NaN on every frame although an animation
+      // keys `mass` to 1. A key cannot rescue a value that has already broken
+      // the rig it is resting in.
+      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);
+          }
+        }
+      }
+      let mutedUntilKeyed = 0;
       for (const constraint of data.constraints) {
         if (!(constraint instanceof PhysicsConstraintData)) continue;
         const where = `physics "${constraint.name}"`;
@@ -2888,10 +3085,14 @@ export function validate(input: ValidateInput): ValidateReport {
         // sentence.
         for (const rule of PHYSICS_POSE_RULES) {
           if (rule.poseOk(pose[rule.field])) continue;
+          if (rule.inertAtSetup && unmuted.get(constraint)?.has(rule.timeline)) {
+            mutedUntilKeyed++;
+            continue;
+          }
           const drivesAMesh = rule.timeline === 'damping' && meshBoneNames.has(constraint.bone.name);
           fail(
             'A23_PHYSICS_CONSTRAINT_EFFECTIVE',
-            `${where} ${SETUP_POSE_SAYS[rule.timeline](pose)}` +
+            `${where} ${SETUP_POSE_SAYS[rule.timeline](pose, data.animations.length)}` +
               (drivesAMesh ? ' — and this bone drives a mesh, so the canvas never rests' : ''),
           );
         }
@@ -2899,6 +3100,15 @@ export function validate(input: ValidateInput): ValidateReport {
           fail('A23_PHYSICS_CONSTRAINT_EFFECTIVE', `${where} has step ${constraint.step} (fps must be > 0)`);
         }
       }
+      // What the PASS would otherwise not say: this rig rests with physics off
+      // on that many constraints and an animation is what switches them on. A
+      // pass carries no detail — `passed` is a list of names — so `stats` is the
+      // channel that exists, and a number is what belongs in a line printed as
+      // `k=v`: naming every such constraint and the animations that reach it
+      // would be a paragraph on one line, and the rig where nobody meant it is
+      // the rig where the NUMBER is the surprise. Absent rather than 0 when
+      // nothing rests muted, so it appears only where it says something.
+      if (mutedUntilKeyed) stats.physicsMutedUntilKeyed = mutedUntilKeyed;
 
       // --- the same criterion, on every physics timeline key (issue #610) ----
       //
@@ -3038,12 +3248,24 @@ export function validate(input: ValidateInput): ValidateReport {
     /**
      * Does any animation key `<group>.<constraint>.<timeline>`?
      *
-     * ⭐ The reason the two assertions below need this, and the reason they are
-     * not A23 with a different type name: a constraint whose mixes are all 0 at
-     * setup is **the idiom**, not a defect — spineboy's aim rig is exactly that,
-     * and issue #88 landed the timelines that turn one on. So "muted" is only a
-     * finding when nothing turns it on, and that question lives in the animations
-     * rather than in the constraint.
+     * ⭐ 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
+     * exactly that, and issue #88 landed the timelines that turn one on. So
+     * "muted" is only a finding when nothing turns it on, and that question
+     * lives in the animations rather than in the constraint.
+     *
+     * ⚠️ 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.
      */
     const keyedBy = (group: string, name: string, timeline: string): boolean => {
       if (!raw || !isObj(raw.animations)) return false;
@@ -3770,7 +3992,8 @@ export function validate(input: ValidateInput): ValidateReport {
     //      `parseInt` over fixed offsets and stores whatever comes back, so
     //      `"4020"` loads `b = NaN` — a colour that is neither the author's nor
     //      an error.
-    //   3. An `rgba2` timeline on a slot with no `dark` at all. `Slot`'s
+    //   3. An `rgba2` (or, since issue #730, `rgb2`) timeline on a slot with no
+    //      `dark` at all. `Slot`'s
     //      constructor allocates `SlotPose.darkColor` only `if
     //      (data.setupPose.darkColor != null)`, and `RGBA2Timeline.apply1` then
     //      writes `dark.r` unconditionally — so the file parses, and the first
@@ -3811,20 +4034,31 @@ export function validate(input: ValidateInput): ValidateReport {
       for (const slot of Array.isArray(raw?.slots) ? (raw.slots as unknown[]) : []) {
         if (isObj(slot) && typeof slot.dark === 'string') declared.set(String(slot.name), slot.dark);
       }
-      const keyed: Array<{ anim: string; slot: string; keys: unknown[] }> = [];
+      // `rgb2` joined in issue #730, and it is this rule's subject rather than a
+      // new one's because it is the same tint with the light alpha left out:
+      // `RGB2Timeline` writes the light rgb and the dark colour, and on a slot
+      // with no dark colour it throws in `apply1` exactly as `RGBA2Timeline`
+      // does (measured on a forged file: `TypeError: null is not an object
+      // (evaluating 'dark.r = …')`). The one thing it does differently is the
+      // alpha it does NOT pose, which is `A45`'s question, not this one's.
+      const keyed: Array<{ anim: string; slot: string; timeline: 'rgba2' | 'rgb2'; keys: unknown[] }> = [];
       const rawAnimations = isObj(raw) && isObj(raw.animations) ? raw.animations : {};
       for (const [animName, anim] of Object.entries(rawAnimations)) {
         if (!isObj(anim) || !isObj(anim.slots)) continue;
         for (const [slotName, timelines] of Object.entries(anim.slots)) {
-          if (!isObj(timelines) || !Array.isArray(timelines.rgba2)) continue;
-          keyed.push({ anim: animName, slot: slotName, keys: timelines.rgba2 });
+          if (!isObj(timelines)) continue;
+          for (const timeline of ['rgba2', 'rgb2'] as const) {
+            const keys = timelines[timeline];
+            if (Array.isArray(keys)) keyed.push({ anim: animName, slot: slotName, timeline, keys });
+          }
         }
       }
       if (declared.size === 0 && keyed.length === 0) {
         return skip('A43_TWO_COLOR_TINT_LOADS_AND_POSES_AS_WRITTEN', SKIP_NO_TWO_COLOR_TINT);
       }
       stats.darkSlots = declared.size;
-      stats.rgba2Timelines = keyed.length;
+      stats.rgba2Timelines = keyed.filter((t) => t.timeline === 'rgba2').length;
+      stats.rgb2Timelines = keyed.filter((t) => t.timeline === 'rgb2').length;
 
       // -- clause 1: the setup pose ----------------------------------------
       for (const [name, hex] of declared) {
@@ -3864,7 +4098,7 @@ export function validate(input: ValidateInput): ValidateReport {
         }
       }
 
-      // -- clauses 2 and 3: every rgba2 timeline ----------------------------
+      // -- clauses 2 and 3: every rgba2 and rgb2 timeline --------------------
       //
       // ⚠️ Clause 2 poisons its whole ANIMATION, not only its own timeline: the
       // throw happens inside `state.apply`, which applies every timeline of the
@@ -3872,13 +4106,14 @@ export function validate(input: ValidateInput): ValidateReport {
       // same animation would take this assertion down with a `threw:` line
       // instead of the two named failures it has already worked out.
       const cannotPose = new Set(keyed.filter((t) => !declared.has(t.slot)).map((t) => t.anim));
-      for (const { anim: animName, slot: slotName, keys } of keyed) {
-        const where = `animation "${animName}" slot "${slotName}" rgba2`;
+      for (const { anim: animName, slot: slotName, timeline, keys } of keyed) {
+        const where = `animation "${animName}" slot "${slotName}" ${timeline}`;
         if (!declared.has(slotName)) {
           fail(
             'A43_TWO_COLOR_TINT_LOADS_AND_POSES_AS_WRITTEN',
             `${where}: slot "${slotName}" declares no setup "dark", so the runtime allocates no dark colour for ` +
-              'it and applying this animation throws instead of tinting — give the slot a `dark`, or key "rgba"',
+              `it and applying this animation throws instead of tinting — give the slot a \`dark\`, or key ` +
+              `"${timeline === 'rgba2' ? 'rgba' : 'rgb'}"`,
           );
           continue;
         }
@@ -3925,16 +4160,21 @@ export function validate(input: ValidateInput): ValidateReport {
             fail(
               'A43_TWO_COLOR_TINT_LOADS_AND_POSES_AS_WRITTEN',
               `${where} (t=${time}): the key states light ${JSON.stringify(rawKey.light)} and dark ` +
-                `${JSON.stringify(rawKey.dark)} — an rgba2 key needs both, each six or eight hex digits — and the ` +
+                `${JSON.stringify(rawKey.dark)} — an ${timeline} key needs both, each six or eight hex digits — and the ` +
                 `runtime poses light (${show(foundLight)}), dark (${show(foundDark)})`,
             );
             continue;
           }
-          if (foundLight.some((n, i) => off(n, wantLight[i]))) {
+          // An `rgb2` key's light colour is three channels, and the posed alpha
+          // is not its to state — `RGB2Timeline` leaves it where it was — so the
+          // comparison is over the channels the timeline writes. For `rgba2`
+          // that is all four, and the line reads as it always did.
+          const lightChannels = timeline === 'rgba2' ? 4 : 3;
+          if (foundLight.slice(0, lightChannels).some((n, i) => off(n, wantLight[i]))) {
             fail(
               'A43_TWO_COLOR_TINT_LOADS_AND_POSES_AS_WRITTEN',
-              `${where} (t=${time}): light posed (${show(foundLight)}), the key states ${JSON.stringify(rawKey.light)} ` +
-                `= (${show(wantLight)})`,
+              `${where} (t=${time}): light posed (${show(foundLight.slice(0, lightChannels))}), the key states ` +
+                `${JSON.stringify(rawKey.light)} = (${show(wantLight.slice(0, lightChannels))})`,
             );
           }
           if (foundDark.some((n, i) => off(n, wantDark[i]))) {
@@ -3948,6 +4188,175 @@ export function validate(input: ValidateInput): ValidateReport {
       }
     });
 
+    // --- A45: the separable colour timelines own their channels ------------
+    //
+    // ⭐ **Why this is its own rule and not a clause on `A43`.** `rgb` and
+    // `alpha` pose no dark colour, so under A43's name a failure would be a
+    // verdict saying "two-colour tint" about a file that states one colour —
+    // the name would say something other than what it decides (the rule #712
+    // applied to A43 itself, against a clause on A10). And the SKIP is the
+    // sharper half: a rig with a `dark` and no separable timeline has A43's
+    // subject present, so a clause there could only PASS on it, which is a pass
+    // for an absent subject.
+    //
+    // 🚨 **What it decides is what makes `rgb` + `alpha` not `rgba`**, and both
+    // clauses are about the file against the runtime:
+    //
+    //   1. **One channel, one timeline.** Each colour timeline poses its
+    //      channels at EVERY time — before its first key it writes the setup
+    //      value — so when two of one slot share a channel, the one applied
+    //      later (the one the file states later) overwrites the other
+    //      everywhere and the first one's keys on it are read by nothing
+    //      (`SLOT_COLOR_CHANNELS`). It is the shape a converter that writes a
+    //      separable `rgb` as `rgba` leaves beside the `alpha` it kept, and it
+    //      loads without a word.
+    //   2. **Posed as written.** Stepped to each key's own time, the channels
+    //      the timeline writes are the key's: a colour that is not six hex
+    //      digits loads as NaN, and a key whose time another key repeats is
+    //      read by nothing, and both parse in silence.
+    //
+    // ⚠️ An `rgb` timeline alone that a converter wrote as `rgba` with the
+    // setup alpha is NOT this rule's to see, and nothing that reads only the
+    // file can see it: the result is a correct `rgba`, which is also what an
+    // author keying the light colour and holding its alpha would write. What
+    // differs is what happens UNDER another track that moves the alpha, which
+    // is the consumer's composing rather than the object (CLAUDE.md). That
+    // file SKIPs here — it keys no `rgb` or `alpha` — and says so.
+    //
+    // ⚠️ The required values are parsed HERE, as A43's are, and the channel
+    // table is `timelines.ts`'s rather than the loaded timelines' property ids:
+    // a check that asked the parser what a timeline writes would agree with it
+    // whatever it did. A selftest control holds that table to the runtime's ids.
+    check('A45_SEPARABLE_COLOR_TIMELINES_OWN_THEIR_CHANNELS_AND_POSE_AS_WRITTEN', () => {
+      const NAME = 'A45_SEPARABLE_COLOR_TIMELINES_OWN_THEIR_CHANNELS_AND_POSE_AS_WRITTEN';
+      /** `rrggbb`, or `rrggbbaa` whose alpha an `rgb` key cannot pose. Null for anything else. */
+      const readRgbHex = (hex: unknown): [number, number, number] | null => {
+        if (typeof hex !== 'string') return null;
+        const body = hex.startsWith('#') ? hex.slice(1) : hex;
+        if (!/^[\da-fA-F]{6}([\da-fA-F]{2})?$/.test(body)) return null;
+        return [0, 2, 4].map((i) => Number.parseInt(body.slice(i, i + 2), 16) / 255) as [number, number, number];
+      };
+      /** Half a byte step for a hex channel; a stored `Float32` for an alpha `value`. */
+      const HEX_STEP = 1 / 510;
+      const FLOAT_STEP = 1e-6;
+      const off = (found: number, want: number, step: number): boolean => !Number.isFinite(found) || Math.abs(found - want) > step;
+      const show = (c: readonly number[]): string => c.map((n) => (Number.isFinite(n) ? n.toFixed(4) : 'NaN')).join(', ');
+
+      // -- the subjects, read off the FILE ---------------------------------
+      const subjects: Array<{ anim: string; slot: string; timelines: Record<string, unknown> }> = [];
+      const rawAnimations = isObj(raw) && isObj(raw.animations) ? raw.animations : {};
+      for (const [animName, anim] of Object.entries(rawAnimations)) {
+        if (!isObj(anim) || !isObj(anim.slots)) continue;
+        for (const [slotName, timelines] of Object.entries(anim.slots)) {
+          if (!isObj(timelines)) continue;
+          if (Array.isArray(timelines.rgb) || Array.isArray(timelines.alpha)) {
+            subjects.push({ anim: animName, slot: slotName, timelines });
+          }
+        }
+      }
+      if (subjects.length === 0) return skip(NAME, SKIP_NO_SEPARABLE_COLOR);
+      stats.separableColorTimelines = subjects.reduce(
+        (n, s) => n + (Array.isArray(s.timelines.rgb) ? 1 : 0) + (Array.isArray(s.timelines.alpha) ? 1 : 0),
+        0,
+      );
+
+      for (const { anim: animName, slot: slotName, timelines } of subjects) {
+        const at = `animation "${animName}" slot "${slotName}"`;
+        // In FILE order, which is the order `readAnimation` pushes them and so
+        // the order they apply in.
+        const colour = Object.keys(timelines).filter((name) => name in SLOT_COLOR_CHANNELS && Array.isArray(timelines[name]));
+
+        // -- clause 1: one channel, one timeline ---------------------------
+        let shared = false;
+        for (const channel of ['rgb', 'alpha', 'dark'] as const) {
+          const writers = colour.filter((name) => SLOT_COLOR_CHANNELS[name].includes(channel));
+          if (writers.length < 2 || !writers.some((name) => name === 'rgb' || name === 'alpha')) continue;
+          shared = true;
+          const last = writers[writers.length - 1];
+          fail(
+            NAME,
+            `${at}: ${writers.map((name) => `"${name}"`).join(' and ')} ${writers.length === 2 ? 'both' : 'all'} key the ${channel === 'rgb' ? 'light rgb' : channel === 'alpha' ? 'alpha' : 'dark colour'} ` +
+              `— each poses it at every time, its setup value before its first key included, so "${last}", which the ` +
+              `file states last, overwrites ${writers.length === 2 ? `"${writers[0]}"` : 'the others'} everywhere and ` +
+              'those keys are read by nothing. Key each channel once: "rgb" and "alpha" on their own key times, or one "rgba"',
+          );
+        }
+        if (shared) continue;
+
+        // -- clause 2: posed as written ------------------------------------
+        //
+        // ⚠️ Two things this does NOT do, both measured rather than skipped:
+        // it does not read the loaded timeline's CLASS back, and it does not
+        // hold a channel the timeline leaves alone to the setup pose. Against
+        // the linked parser neither can fail — every `rgb` / `alpha` array that
+        // loads at all loads as an `RGBTimeline` / `AlphaTimeline`, and the
+        // three other outcomes (an empty array, a slot the skeleton lacks, a
+        // name outside the switch) throw at `A00` — so either would be a clause
+        // nobody can see fire. The selftest reads both off spine-core directly
+        // (`S82`–`S84`), where they are measurements of the runtime rather than
+        // checks on a file.
+        if (!data.findAnimation(animName)) {
+          fail(NAME, `${at}: the loaded skeleton has no animation "${animName}"`);
+          continue;
+        }
+        for (const name of ['rgb', 'alpha'] as const) {
+          const keys = timelines[name];
+          if (!Array.isArray(keys)) continue;
+          const where = `${at} ${name}`;
+          for (const rawKey of keys) {
+            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);
+            const posed = skeleton.slots.find((s) => s.data.name === slotName)?.appliedPose;
+            if (!posed) {
+              fail(NAME, `${where} (t=${time}): the posed skeleton has no slot "${slotName}" to read`);
+              continue;
+            }
+            const light = [posed.color.r, posed.color.g, posed.color.b, posed.color.a];
+            if (name === 'rgb') {
+              const stated = readRgbHex(rawKey.color);
+              if (stated === null) {
+                fail(
+                  NAME,
+                  `${where} (t=${time}): the key states color ${JSON.stringify(rawKey.color)} — an rgb key is six hex ` +
+                    `digits — and the runtime poses (${show(light.slice(0, 3))})`,
+                );
+              } else if (light.slice(0, 3).some((n, i) => off(n, stated[i], HEX_STEP))) {
+                fail(
+                  NAME,
+                  `${where} (t=${time}): rgb posed (${show(light.slice(0, 3))}), the key states ` +
+                    `${JSON.stringify(rawKey.color)} = (${show(stated)})`,
+                );
+              }
+            } else {
+              // `readTimeline1(…, 0, 1)`: an absent `value` IS 0, and an editor
+              // omits it there, so absence is read the parser's way rather than
+              // as a malformed key.
+              const stated = rawKey.value === undefined ? 0 : rawKey.value;
+              if (typeof stated !== 'number' || off(light[3], stated, FLOAT_STEP)) {
+                fail(
+                  NAME,
+                  `${where} (t=${time}): alpha posed ${show([light[3]])}, the key states value ${JSON.stringify(rawKey.value)}` +
+                    (typeof stated !== 'number'
+                      ? ' — an alpha key\'s value is a number'
+                      : stated < 0 || stated > 1
+                        ? ' — the runtime clamps a posed alpha to 0..1'
+                        : ''),
+                );
+              }
+            }
+          }
+        }
+      }
+    });
+
     // --- A44: a linked mesh states no geometry of its own ------------------
     //
     // 🚨 The one shape the parser reads in SILENCE. `readAttachment` returns from
@@ -4053,13 +4462,62 @@ export function validate(input: ValidateInput): ValidateReport {
     for (const page of atlas.pages) {
       const abs = resolve(input.atlasDir, page.name);
       if (!existsSync(abs)) continue; // A17 owns this
-      const info = readPngInfo(abs);
-      if (page.width !== info.width || page.height !== info.height) {
+      // 🔒 **A page that is not a PNG is a named failure, not a throw** (issue
+      // #732). The reader's throw used to reach this rule's catch and print as
+      // `threw: not a PNG (bad signature)`: the verdict right, the sentence a
+      // stack message that named neither what the file was nor what rigc reads.
+      // `pngProblem` ([`src/png.ts`](png.ts)) is the one sentence every reader
+      // of a page states; this rule prefixes the size the atlas declares, the
+      // value the file would have had to carry.
+      //
+      // ⚠️ No size is read off a file rigc cannot decode, deliberately. A WebP
+      // header carries its dimensions in a fixed field, and reading them would
+      // print a number no oracle in this tree has checked (rigc links no WebP
+      // reader to compare a parse against), about a page that is refused here
+      // either way — and measured, the variant that PASSED a WebP page whose
+      // size agreed built green under the default profile and wrote a
+      // directory that `render` then refused.
+      const header = readPngHeader(abs);
+      if (header.problem !== null) {
         fail(
           'A06_ATLAS_PAGE_SIZE_MATCHES_PNG',
-          `page "${page.name}" declares ${page.width}x${page.height} but the PNG is ${info.width}x${info.height}`,
+          `page "${page.name}" declares ${page.width}x${page.height} and its file cannot be read as PNG, so the ` +
+            `size was not measured: ${header.problem}`,
         );
       }
+      const info = header.info;
+      if (info !== null && (page.width !== info.width || page.height !== info.height)) {
+        // 🔒 **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
+        // was measured — it is declared-size-relative, so a rescaled page
+        // 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}`);
+        }
+      }
       // 📐 PROFILE, from here down. `pma: false` and no rotation are rigc's atlas
       // CONVENTION, not the atlas format's rules — a packed page with
       // `rotate: 90` is what the Spine packer produces and every official example
@@ -4255,6 +4713,30 @@ export function validate(input: ValidateInput): ValidateReport {
       const abs = resolve(input.atlasDir, page.name);
       if (!existsSync(abs)) continue;
       const on = sharedPages.get(page.name) ?? [];
+      // 🔒 **A page that is not a PNG is a non-measurement for every part on
+      // it** (issue #732), stated the way #705's and #715's are: a FAIL naming
+      // what was not read, because `skip()` is per assertion and would delete
+      // the verdicts on every other page of the same report. The file's
+      // identity is `A06`'s to judge, and this sentence points there. A page
+      // holding nothing but the full-stage base plate has no part to judge and
+      // says nothing, exactly as a readable one would.
+      const header = readPngHeader(abs);
+      if (header.problem !== null) {
+        const shared = on.length > 1;
+        const parts = shared ? on.filter((region) => !baseRegions.has(region.name)).map((region) => region.name) : [];
+        if (shared ? parts.length === 0 : basePages.has(page.name)) continue;
+        const subject = shared
+          ? `the ${parts.length} part(s) on shared page "${page.name}" (${parts.map((name) => JSON.stringify(name)).join(', ')}) are`
+          : `part image "${page.name}" is`;
+        fail(
+          'A19_OVERLAY_PNGS_HAVE_ALPHA',
+          `${subject} not measured: this rule reads a page's alpha out of its PNG, and the file cannot be read as ` +
+            'one, so it states nothing about whether any of them can draw a transparent pixel. What the file is ' +
+            "belongs to A06_ATLAS_PAGE_SIZE_MATCHES_PNG, which names it. This is renderer policy, and it belongs to " +
+            '--profile spine-html: the default --profile spine does not run this check.',
+        );
+        continue;
+      }
       if (on.length > 1) {
         // 🚨 A rotated region is refused by A06 under this profile, so this
         // reading was assumed to be cosmetic — a rectangle printed beside a
@@ -4289,6 +4771,37 @@ export function validate(input: ValidateInput): ValidateReport {
         // requires: a part this rule could not read must not be certified by
         // it.
         const plate = readPlate(abs);
+        // 🚨 **The scan's coordinates are the atlas's, so a file that is not the
+        // declared grid is a non-measurement for every region on it** (issue
+        // #715), and #705's clause above does not cover it. That one fires when
+        // a rectangle has NO texel on the page; a page whose image is a rescale
+        // of the declared size leaves most rectangles partly on it, at
+        // coordinates that address a different part of the picture. Measured on
+        // a two-region pack at a uniform 0.5: the opaque part's failure
+        // DISAPPEARED — the scan found a transparent texel 32 texels away from
+        // it and returned — while the other printed #705's sentence over 0 of
+        // 256 texels. A verdict and a silence, both about texels nobody located.
+        //
+        // A FAIL for #705's reason, word for word: `skip()` is per assertion and
+        // would delete the verdicts on every other page in the same report.
+        if (plate.width !== page.width || plate.height !== page.height) {
+          for (const region of on) {
+            if (baseRegions.has(region.name)) continue;
+            const { width, height } = pageFootprint(region);
+            fail(
+              'A19_OVERLAY_PNGS_HAVE_ALPHA',
+              `part "${region.name}" is not measured: this rule opens the page at the coordinates the atlas ` +
+                `states, and page "${page.name}" declares ${page.width}x${page.height} over a ` +
+                `${plate.width}x${plate.height} image, so the ${width}x${height} rectangle at ${region.x},` +
+                `${region.y} is not where "${region.name}"'s texels are on this file and this rule states ` +
+                'nothing about whether it can draw a transparent pixel. The page grid is ' +
+                "A06_ATLAS_PAGE_SIZE_MATCHES_PNG's to judge, and it names the ratio and how to declare the page " +
+                'honestly. This is renderer policy, and it belongs to --profile spine-html: the default ' +
+                '--profile spine does not run this check.',
+            );
+          }
+          continue;
+        }
         for (const region of on) {
           if (baseRegions.has(region.name)) continue;
           const { width, height } = pageFootprint(region);
@@ -4341,7 +4854,7 @@ export function validate(input: ValidateInput): ValidateReport {
         }
         continue;
       }
-      const info = readPngInfo(abs);
+      const info = header.info;
       if (info.hasTransparency) continue;
       if (basePages.has(page.name)) continue; // full-stage base plate: opaque is correct
       fail(