@rig-c/core 2.39.0 → 2.40.0

package/src/assertions/model/index.ts

@@ -64,6 +64,9 @@ import { a06AtlasPageSizeMatchesPng } from '../bodies/a06.ts';
 import { a19OverlayPngsHaveAlpha } from '../bodies/a19.ts';
 import { a49PackedFootprintsDoNotOverlap } from '../bodies/a49.ts';
 import { a50StageBoxIsTheStage } from '../bodies/a50.ts';
+import { a51BonesLieAlongTheirDeclaredAxis } from '../bodies/a51.ts';
+import { modelSetupWorld } from './setup_world.ts';
+import type { SetupWorldFacts } from '../facts/setup_world.ts';
 import { modelStageBox } from './stage_box.ts';
 import type { StageBoxFacts } from '../facts/stage_box.ts';
 import { a27RegionNameMatchesPageFilename } from '../bodies/a27.ts';
@@ -197,6 +200,8 @@ export interface ModelSupply {
   steppedPoses: (read: ReadDocument) => SteppedPoseFacts;
   /** The stage box the document asks for and what its default skin holds there (issue #1168, `./stage_box.ts`). */
   stageBox: (read: ReadDocument) => StageBoxFacts;
+  /** Each bone's world frame at the setup pose, A50's pose (issue #1351, `./setup_world.ts`). */
+  setupWorld: (read: ReadDocument) => SetupWorldFacts;
   /** The rig info the document declares (issue #1054, `./declared.ts`); a caller's `rig` beside it is refused by name. */
   rigInfo: (read: ReadDocument, input: ModelValidateInput) => RigInfo;
   /** Each animation's declared duration as the document states it (issue #1054); a caller's `declaredDurations` beside it is refused by name. */
@@ -228,6 +233,7 @@ export const MODEL_SUPPLY: ModelSupply = {
   constraintTargets: modelConstraintTargets,
   steppedPoses: modelSteppedPoses,
   stageBox: modelStageBox,
+  setupWorld: modelSetupWorld,
   rigInfo: (read, input) => {
     refuseDeclaredBeside(read, input, 'rig');
     return modelRigInfo(read);
@@ -318,6 +324,7 @@ export const MOVED_ASSERTIONS: readonly MovedAssertion[] = [
   { code: 'A28_RIBBON_ROWS_SHARE_WEIGHTS', run: (v, read, input, supply) => a28RibbonRowsShareWeights(v, supply.meshes(read), supply.rigInfo(read, input)), unread: SKIP_NO_MODEL },
   { code: 'A29_STROKE_WITHIN_CONTACT_DEPTH', run: (v, read, input, supply) => a29StrokeWithinContactDepth(v, supply.boneTimelines(read), { rig: supply.rigInfo(read, input) }), unread: SKIP_NO_MODEL, beforeTheParse: true },
   { code: 'A30_STROKE_WITHIN_CAP_CONTAINMENT', run: (v, read, input, supply) => a30StrokeWithinCapContainment(v, supply.boneTimelines(read), { rig: supply.rigInfo(read, input) }), unread: SKIP_NO_MODEL, beforeTheParse: true },
+  { code: 'A51_BONES_LIE_ALONG_THEIR_DECLARED_AXIS', run: (v, read, input, supply) => a51BonesLieAlongTheirDeclaredAxis(v, supply.setupWorld(read), { rig: supply.rigInfo(read, input) }), unread: SKIP_NO_MODEL },
 ];
 
 /** The codes the model side prints: its two parse rules, then the moved assertions. */

package/src/assertions/model/setup_world.ts

@@ -0,0 +1,35 @@
+/**
+ * The model side's supply of `SetupWorldFacts` (issue #1351): each bone's
+ * world frame at the setup pose as rigc's core poses it — `poseSetup` under no
+ * skin, constraints applied, the pose `./stage_box.ts` reads for A50 — posed
+ * once, on the first question, so a rig that declares no axis poses nothing.
+ *
+ * Links nothing from the runtime.
+ */
+import { activeBones, poseSetup, rawNumber, underNoSkin } from '../../core/index.ts';
+import type { CoreWorld } from '../../core/world.ts';
+import { inactiveAtSetup, type SetupWorldFacts } from '../facts/setup_world.ts';
+import type { ReadDocument } from './parse.ts';
+
+export function modelSetupWorld(read: ReadDocument): SetupWorldFacts {
+  let posed: { active: ReadonlySet<string>; world: Map<string, CoreWorld> | string } | null = null;
+  const pose = (): { active: ReadonlySet<string>; world: Map<string, CoreWorld> | string } => {
+    if (posed !== null) return posed;
+    const view = underNoSkin(read.doc);
+    const setup = poseSetup(view, { round: rawNumber });
+    const world = setup.world ?? setup.absent.find(([block]) => block === 'setup.bones')?.[1] ?? "rigc's core does not pose this setup pose";
+    posed = { active: activeBones(view), world };
+    return posed;
+  };
+  return {
+    frameOf: (bone) => {
+      if (!read.doc.bones.some((b) => b.name === bone)) return null;
+      const { active, world } = pose();
+      if (!active.has(bone)) return inactiveAtSetup(bone);
+      if (typeof world === 'string') return world;
+      const frame = world.get(bone);
+      if (frame === undefined) return `bone "${bone}" has no setup world transform`;
+      return { worldX: frame.worldX, worldY: frame.worldY, a: frame.a, c: frame.c };
+    },
+  };
+}

package/src/ballot.ts

@@ -616,7 +616,7 @@ export function buildBallot(input: BallotInput): { html: string; manifest: Ballo
 <meta name="viewport" content="width=device-width, initial-scale=1">
 <title>rigc ballot — ${escapeHtml(manifest.ballot)}</title>
 <!--
-  Generated by rigc ${escapeHtml(input.version)} — https://github.com/firejune/rigc
+  Generated by rigc ${escapeHtml(input.version)} — https://github.com/rig-c/core
 
   Every candidate's skeleton, atlas and atlas pages are embedded in this file as
   data URIs, so it plays on its own with no server and no sibling files.

package/src/bonedist.ts

@@ -9,7 +9,7 @@
  * a rotation of 300° are one key each. Stage 3 is the measure for that, and
  * until this file it did not exist: *"None of it exists. Do not report a
  * per-frame figure until it does"*
- * ([issue #8](https://github.com/firejune/rigc/issues/8)).
+ * ([issue #8](https://github.com/rig-c/core/issues/8)).
  *
  * `rigc check` is the other neighbour and it is **not** this. It measures a
  * candidate against **pictures** — the rendered reference frames — which is

package/src/cli/shared.ts

@@ -334,7 +334,7 @@ function ceilingPair(axis: { positive: FoldLimit | null; negative: FoldLimit | n
  * above the minimum. A ceiling set by one bad texel has 99 % of the mesh
  * surviving to the form's angle while the reported number collapses — 64.58°
  * against 6.08° for one texel of 160,000, with the percentile unmoved at 64.80°
- * in both ([#412](https://github.com/firejune/rigc/issues/412),
+ * in both ([#412](https://github.com/rig-c/core/issues/412),
  * `bench/studies/2026-09-05-noise` §6).
  *
  * Three spellings, three different claims, for the reason `ceilingPair` prints

package/src/cli/spine_commands.ts

@@ -28,7 +28,7 @@ import { dirname, join, resolve } from 'node:path';
 function repositoryUrl(): string {
   const repo = readPackageMeta()?.repository;
   const url = typeof repo === 'string' ? repo : repo?.url;
-  return (url ?? 'https://github.com/firejune/rigc').replace(/^git\+/, '').replace(/\.git$/, '');
+  return (url ?? 'https://github.com/rig-c/core').replace(/^git\+/, '').replace(/\.git$/, '');
 }
 
 // ---------------------------------------------------------------------------

package/src/compile.ts

@@ -7555,6 +7555,8 @@ function buildRigInfo(
     consumerDrivenMix: (rig.invariants?.consumerDrivenMix ?? []).map((e) => ({ type: e.type, constraint: e.constraint, why: e.why })),
     // `parseRigSpec` refused every shape but a non-blank `why`.
     idleDrivesMeshes: rig.invariants?.idleDrivesMeshes?.why ?? null,
+    // `parseRigSpec` resolved every name and refused every shape (issue #1351).
+    axes: (rig.invariants?.axes ?? []).map((e) => ({ name: e.name, through: [e.through[0], e.through[1]] as [string, string], bones: [...e.bones], tolerance: e.tolerance })),
     // `isBase` is set on the manifest route only; every other image says false.
     basePlates: images.filter((img) => img.isBase).map((img) => img.region),
     meshSlotBudget: rig.invariants?.meshSlots ?? null,

package/src/deformmeasure.ts

@@ -4,9 +4,9 @@
  * ⭐ **One survey, two consumers.** `A39_DEFORM_KEEPS_TRIANGLE_WINDING` reads the
  * reversals out of it and refuses a build; `explain`'s `DEFORM` block prints the
  * whole of it and refuses nothing. That split is issue
- * [#296](https://github.com/firejune/rigc/issues/296)'s two halves —
- * [#314](https://github.com/firejune/rigc/pull/314) landed the assertion and
- * [#316](https://github.com/firejune/rigc/issues/316) the report — and the reason
+ * [#296](https://github.com/rig-c/core/issues/296)'s two halves —
+ * [#314](https://github.com/rig-c/core/pull/314) landed the assertion and
+ * [#316](https://github.com/rig-c/core/issues/316) the report — and the reason
  * they share this file rather than each posing the skeleton themselves is that
  * the report's `winding 32 of 32 kept` and A39's `8 of 32 reverse` are **the same
  * count**. Two derivations of one number drift, and the one that drifts silently

package/src/depth.ts

@@ -454,14 +454,14 @@ export function foldPrecedes(
  * minimum alone cannot answer the question an author actually has: `degrees` is
  * the same number whether a whole band of the mesh reaches the limit together
  * or one triangle does, and those are a form and a bad texel respectively
- * ([#412](https://github.com/firejune/rigc/issues/412),
+ * ([#412](https://github.com/rig-c/core/issues/412),
  * `bench/studies/2026-09-05-noise` §6).
  *
  * ⚠️ And a band is not sufficient evidence of a form either, which is what
  * `stepShare` is here for: an OUTLINE is a band, so a mesh whose ceiling is set
  * by the occlusion edge of a cut-out reads `p1/degrees` near 1 and a `depthStep`
  * of most of the sheet's range — both of the older figures reading *healthy* on
- * the same measurement ([#448](https://github.com/firejune/rigc/issues/448)).
+ * the same measurement ([#448](https://github.com/rig-c/core/issues/448)).
  *
  * ⛔ Neither figure changes `degrees`, and neither is a threshold. rigc does not
  * have the authority to guess its input away, so nothing here filters,
@@ -499,7 +499,7 @@ export interface FoldLimit {
    * triangle that folds first.
    *
    * ⭐ The figure that tells a form from a cliff, and it is the one reading the
-   * other two cannot give ([#448](https://github.com/firejune/rigc/issues/448)).
+   * other two cannot give ([#448](https://github.com/rig-c/core/issues/448)).
    * A form has a slope, so refining the lattice halves the step and halves this
    * with it while the angle converges. A **discontinuity has no slope**: the
    * step stays the whole range however fine the lattice gets, this figure pins

package/src/diff.ts

@@ -362,7 +362,7 @@ function atPlaces(n: number): number {
  * it, so `note` states both rates and which side is the bigger one. A histogram
  * intersection over the same quantity reads 421/1339 whether the candidate has
  * a third of the reference's keys or three times them — that ambiguity is what
- * [issue #20](https://github.com/firejune/rigc/issues/20) turned on, and a
+ * [issue #20](https://github.com/rig-c/core/issues/20) turned on, and a
  * figure that repeated it would be the second copy of the same defect.
  */
 function rateAgreement(id: string, what: string, unit: string, a: number, b: number, convention: string): DiffMeasure {

package/src/generation.ts

@@ -7,7 +7,7 @@
  * **silently**: 4.3 takes constraints from the top-level `constraints` array
  * alone, so a 4.0–4.2 file parses clean with none of them — measured across
  * 1,302 shipped skeletons that loaded 0 of 8,672 constraints
- * ([#706](https://github.com/firejune/rigc/issues/706) row 1). rigc is where
+ * ([#706](https://github.com/rig-c/core/issues/706) row 1). rigc is where
  * that knowledge lives for the tools around it (#706 *Ownership*), and living
  * in one place means one reader of `skeleton.spine`:
  * `A16_SKELETON_VERSION_4_3` asks this function for its verdict, and `ingest`

package/src/preview.ts

@@ -263,7 +263,7 @@ export function buildPreview(input: PreviewInput): string {
 <meta name="viewport" content="width=device-width, initial-scale=1">
 <title>rigc preview — ${label}</title>
 <!--
-  Generated by rigc ${escapeHtml(input.version)} — https://github.com/firejune/rigc
+  Generated by rigc ${escapeHtml(input.version)} — https://github.com/rig-c/core
 
   The skeleton, the atlas and every atlas page are embedded in this file as data
   URIs, so it plays on its own with no server and no sibling files.
@@ -357,7 +357,7 @@ export function buildPreviewPanes(inputs: PreviewInput[], version: string): stri
 <meta name="viewport" content="width=device-width, initial-scale=1">
 <title>rigc preview — ${inputs.length} candidates</title>
 <!--
-  Generated by rigc ${escapeHtml(version)} — https://github.com/firejune/rigc
+  Generated by rigc ${escapeHtml(version)} — https://github.com/rig-c/core
 
   Every candidate's skeleton, atlas and atlas pages are embedded in this file as
   data URIs, so it plays on its own with no server and no sibling files.

package/src/rig.ts

@@ -1757,6 +1757,51 @@ export interface RigInvariants {
    * refused at the gate: it would switch off nothing while reading like it did.
    */
   idleDrivesMeshes?: RigIdleDrivesMeshes;
+  /**
+   * Lines some of the rig's bones are held to: for each entry, the line
+   * through the setup-pose world origins of the two `through` bones, and every
+   * bone in `bones` with its setup-pose world x axis within `tolerance` degrees
+   * of it, as a line — `A51_BONES_LIE_ALONG_THEIR_DECLARED_AXIS` (issue #1351).
+   *
+   * 🔑 **Why a bone's axes are the rig's business.** A `scaleY` key squashes
+   * along the bone's own y axis and a `translateY` key moves along it. On a face
+   * painted upright with every bone at rotation 0 that is the face's axis; on a
+   * face painted tilted it is the page's, so a blink squashes the eye along the
+   * page's vertical rather than across the eye line, a brow rises toward the
+   * page's top rather than the forehead — and the parser, the round trip and
+   * every other rule accept it. The author cannot see it. Rotating the bones to
+   * the face's line (their attachments counter-rotated, so the setup pose is
+   * unmoved) is the fix, and this is the declaration that holds it.
+   *
+   * 🚨 **Held whether or not any animation keys the bones.** A consumer writes
+   * them at run time (`openTrack({ adjust })` on the core entry), which no
+   * animation in the file shows, so "nothing keys it" is not "nothing reads it".
+   *
+   * ⚠️ `tolerance` is **required**, finite, above 0 and below 90 — the compiler
+   * does not invent one. Two lines meet at 0° to 90°, so a tolerance of 90 or
+   * more admits every orientation and could never fail; and a bone's world
+   * angle is read off a posed matrix in floating point, so 0 would refuse a
+   * bone rotated exactly onto the line whenever the arithmetic rounds.
+   *
+   * Every name resolves or is refused by name: an unknown bone in `through` or
+   * `bones`, `through` naming one bone twice, a repeated entry `name`. Two
+   * `through` bones that land on one world origin draw no line, and that is
+   * known only once the setup pose is posed — constraints included — so the
+   * gate refuses it, by the entry's name, rather than this parser.
+   */
+  axes?: RigAxis[];
+}
+
+/** One line some bones are held to — `invariants.axes` (`A51`). */
+export interface RigAxis {
+  /** Names the entry in every failure; unique among the rig's axes. */
+  name: string;
+  /** The two bones whose setup-pose world origins draw the line, first to second. Two different bones. */
+  through: string[];
+  /** The bones whose setup-pose world x axis must lie along it. */
+  bones: string[];
+  /** Degrees, required: above 0 and below 90 — see `RigInvariants.axes`. */
+  tolerance: number;
 }
 
 /** The rig's `idle` is meant to deform meshes — `invariants.idleDrivesMeshes` (`A15`). */
@@ -1869,7 +1914,8 @@ export const RIG_KEYS = {
   RigBoneFrom: ['anchor', 'slotWindow', 'meshCenter', 'rotation'],
   RigSlot: ['name', 'bone', 'attachment', 'color', 'dark', 'blend'],
   RigEvent: ['int', 'float', 'string', 'audio', 'volume', 'balance'],
-  RigInvariants: ['meshSlots', 'meshTriangles', 'axisBone', 'massBone', 'detached', 'deformMayFold', 'consumerDrivenMix', 'idleDrivesMeshes'],
+  RigInvariants: ['meshSlots', 'meshTriangles', 'axisBone', 'massBone', 'detached', 'deformMayFold', 'consumerDrivenMix', 'idleDrivesMeshes', 'axes'],
+  RigAxis: ['name', 'through', 'bones', 'tolerance'],
   RigIdleDrivesMeshes: ['why'],
   RigDetachedRule: ['bone', 'notUnder', 'why'],
   RigDeformFoldExemption: ['slot', 'why'],
@@ -1977,8 +2023,9 @@ export const RIG_TYPES = {
   RigEvent: { int: 'number', float: 'number', string: 'string', audio: 'string', volume: 'number', balance: 'number' },
   RigInvariants: {
     meshSlots: 'number', meshTriangles: 'number', axisBone: 'string', massBone: 'string', detached: 'object[]',
-    deformMayFold: 'object[]', consumerDrivenMix: 'object[]', idleDrivesMeshes: 'object',
+    deformMayFold: 'object[]', consumerDrivenMix: 'object[]', idleDrivesMeshes: 'object', axes: 'object[]',
   },
+  RigAxis: { name: 'string', through: 'string[]', bones: 'string[]', tolerance: 'number' },
   RigIdleDrivesMeshes: { why: 'string' },
   RigDetachedRule: { bone: 'string', notUnder: 'string', why: 'string' },
   RigDeformFoldExemption: { slot: 'string', why: 'string' },
@@ -2312,6 +2359,9 @@ function checkRigSpecKeys(raw: Record<string, unknown>, where: string): Array<{
       at(rule, 'RigConsumerDrivenMix', `invariants.consumerDrivenMix[${i}]`, ['invariants', 'consumerDrivenMix', i]);
     }
     at(raw.invariants.idleDrivesMeshes, 'RigIdleDrivesMeshes', 'invariants.idleDrivesMeshes', ['invariants', 'idleDrivesMeshes']);
+    for (const [i, rule] of (Array.isArray(raw.invariants.axes) ? raw.invariants.axes : []).entries()) {
+      at(rule, 'RigAxis', `invariants.axes[${i}]`, ['invariants', 'axes', i]);
+    }
   }
 
   for (const [skinName, skin] of Object.entries(isObj(raw.skins) ? raw.skins : {})) {
@@ -2777,6 +2827,58 @@ export function parseRigSpec(raw: unknown, where: string): RigSpec {
     }
   }
 
+  // `invariants.axes` (issue #1351) — a field that TURNS A CHECK ON, and every
+  // way an entry could check nothing while reading like it did is refused by
+  // name: a bone that resolves to nothing, a line through one bone, a repeated
+  // name, a tolerance that is missing or admits every orientation. What it
+  // cannot refuse is two `through` bones landing on one world origin: that is
+  // a fact about the posed setup pose, constraints included, which this parser
+  // does not pose — `A51_BONES_LIE_ALONG_THEIR_DECLARED_AXIS` refuses it by the
+  // entry's name.
+  const axes = spec.invariants?.axes;
+  if (axes !== undefined) {
+    const shape = 'an array of { "name": …, "through": [<bone>, <bone>], "bones": [<bone>, …], "tolerance": <degrees> }';
+    if (!Array.isArray(axes)) throw new CompileError(`${where}: invariants.axes is ${JSON.stringify(axes)}, expected ${shape}`);
+    const named = new Set<string>();
+    for (const [i, entry] of axes.entries()) {
+      const field = `invariants.axes[${i}]`;
+      if (!isObj(entry) || typeof entry.name !== 'string' || entry.name.length === 0) {
+        throw new CompileError(`${where}: ${field} needs a "name" — ${shape}`);
+      }
+      const axis = `${field} "${entry.name}"`;
+      if (named.has(entry.name)) throw new CompileError(`${where}: ${field}: invariants.axes names "${entry.name}" twice — a failure names its entry, and two entries of one name could not be told apart`);
+      named.add(entry.name);
+      const through: unknown = entry.through;
+      if (!Array.isArray(through) || through.length !== 2 || !through.every((b): b is string => typeof b === 'string')) {
+        throw new CompileError(`${where}: ${axis}: "through" is ${JSON.stringify(through)}, expected two bone names — the line is drawn through their setup-pose world origins`);
+      }
+      for (const [k, bone] of through.entries()) {
+        if (!seen.has(bone)) throw new CompileError(`${where}: ${axis}: through[${k}] names bone "${bone}", which this rig does not declare — a line through nothing holds nothing`);
+      }
+      if (through[0] === through[1]) {
+        throw new CompileError(`${where}: ${axis}: "through" names bone "${through[0]}" twice — one bone's origin is a point, and a point draws no line`);
+      }
+      const bones: unknown = entry.bones;
+      if (!Array.isArray(bones) || bones.length === 0 || !bones.every((b): b is string => typeof b === 'string')) {
+        throw new CompileError(`${where}: ${axis}: "bones" is ${JSON.stringify(bones)}, expected a non-empty array of bone names — the bones held to the line`);
+      }
+      const held = new Set<string>();
+      for (const [k, bone] of bones.entries()) {
+        if (!seen.has(bone)) throw new CompileError(`${where}: ${axis}: bones[${k}] names bone "${bone}", which this rig does not declare — a name that resolves to nothing is held to nothing, and reads like it was`);
+        if (held.has(bone)) throw new CompileError(`${where}: ${axis}: "bones" names bone "${bone}" twice`);
+        held.add(bone);
+      }
+      const tolerance: unknown = entry.tolerance;
+      if (typeof tolerance !== 'number' || !Number.isFinite(tolerance) || !(tolerance > 0) || !(tolerance < 90)) {
+        throw new CompileError(
+          `${where}: ${axis}: "tolerance" is ${tolerance === undefined ? 'absent' : JSON.stringify(tolerance)}; it must be a number of degrees above 0 and below 90, ` +
+            'and there is no default — two lines meet at 0° to 90°, so 90 or more admits every orientation and can never fail, ' +
+            'and 0 refuses a bone rotated exactly onto the line whenever the posed arithmetic rounds',
+        );
+      }
+    }
+  }
+
   // --- skins: the attachment table, and what the skin ACTIVATES --------------
   //
   // The lists resolve by name like everything else in this format, and the

package/src/trackgen.ts

@@ -87,7 +87,7 @@ export interface TrackDeriveTurn {
    *
    * ⚠️ That sign is the one thing here no assertion can check, and this comment
    * had it backwards until issue #350's neighbour
-   * ([#351](https://github.com/firejune/rigc/issues/351)). The closed form is
+   * ([#351](https://github.com/rig-c/core/issues/351)). The closed form is
    * the arbiter: `d = (x−about)·(cos t − 1) − (depth − carried)·sin t` gives a
    * part with `depth > carried` a **negative** residual, and FACE §3 makes
    * exactly that the nose diagnostic — *if the nose's residual is not negative,

package/src/types.ts

@@ -1495,6 +1495,15 @@ export interface RigInfo {
    * `validate <dir>` has no rig, so null, and A15 refuses per bone as before.
    */
   idleDrivesMeshes: string | null;
+  /**
+   * The lines the rig declares some of its bones to lie along, from
+   * `invariants.axes`, in the rig spec's order — each with the two bones whose
+   * setup-pose world origins draw it, the bones held to it and the tolerance in
+   * degrees. Empty is the ordinary case, and `A51` SKIPs on it. `parseRigSpec`
+   * resolved every name and refused every shape before this was built (issue
+   * #1351).
+   */
+  axes: Array<{ name: string; through: [string, string]; bones: string[]; tolerance: number }>;
   /**
    * The atlas region(s) the build names as its base plate — the one image
    * `A19_OVERLAY_PNGS_HAVE_ALPHA` lets be opaque — in compile order.

package/src/validate.ts

@@ -105,6 +105,8 @@ import { a06AtlasPageSizeMatchesPng } from './assertions/bodies/a06.ts';
 import { a19OverlayPngsHaveAlpha } from './assertions/bodies/a19.ts';
 import { a49PackedFootprintsDoNotOverlap } from './assertions/bodies/a49.ts';
 import { a50StageBoxIsTheStage } from './assertions/bodies/a50.ts';
+import { a51BonesLieAlongTheirDeclaredAxis } from './assertions/bodies/a51.ts';
+import { inactiveAtSetup, type SetupWorldFacts } from './assertions/facts/setup_world.ts';
 import { SKIP_NO_STAGE_BOX, type StageBoxFacts } from './assertions/facts/stage_box.ts';
 import { a27RegionNameMatchesPageFilename } from './assertions/bodies/a27.ts';
 import type { MeshEntry as MeshAttachmentEntry, MeshFacts } from './assertions/facts/mesh_attachments.ts';
@@ -1309,6 +1311,31 @@ export function spineStageBox(data: ReturnType<SkeletonJson['readSkeletonData']>
   return { asked, why: '', slot: true, held: { type: 'boundingbox', weighted, stored, world } };
 }
 
+/**
+ * The runtime's supply of `SetupWorldFacts` (issue #1351): each bone's world
+ * frame on a fresh skeleton at the setup pose — `setupPose()`,
+ * `updateWorldTransform(Physics.none)`, no skin set, the pose `spineStageBox`
+ * reads for A50 — posed once, on the first question.
+ */
+export function spineSetupWorld(data: ReturnType<SkeletonJson['readSkeletonData']>): SetupWorldFacts {
+  let skeleton: Skeleton | null = null;
+  return {
+    frameOf: (name) => {
+      if (data.findBone(name) === null) return null;
+      if (skeleton === null) {
+        skeleton = new Skeleton(data);
+        skeleton.setupPose();
+        skeleton.updateWorldTransform(Physics.none);
+      }
+      const bone = skeleton.findBone(name);
+      if (bone === null) return null;
+      if (!bone.active) return inactiveAtSetup(name);
+      const { a, c, worldX, worldY } = bone.appliedPose;
+      return { worldX, worldY, a, c };
+    },
+  };
+}
+
 /** The box a `rigc-compiled/3` document's stage asks for, with that stage — or the SKIP's reason where nothing asks (`spineStageBox`). */
 function documentStageBox(modelText: string | undefined): StageBoxFacts['asked'] & object | string {
   if (modelText === undefined) return SKIP_NO_STAGE_BOX;
@@ -3422,6 +3449,28 @@ export function validate(input: ValidateInput): ValidateReport {
   // re-measure containment for the scaled contour and say so.
   check('A30_STROKE_WITHIN_CAP_CONTAINMENT', () => a30StrokeWithinCapContainment(verdicts, rawBoneTimelines(raw), input));
 
+  // --- A51: the bones a rig declares to share an axis lie along it ---------
+  //
+  // ⭐ A `scaleY` key squashes along the bone's own y axis and a `translateY`
+  // key moves along it, so on a face painted tilted with its bones at rotation
+  // 0 a blink squashes the eye along the page's vertical rather than across the
+  // eye line — measured on a seated rig whose eye line is 23.7° off the page,
+  // where all five face bones sat at 0 and the closed eyes came out level on a
+  // tilted face (issue #1351). The file loads, every other rule passes, and the
+  // picture is wrong: the author cannot see it, which is the case this gate is
+  // for. The rig declares the line (`invariants.axes`) and the bones held to
+  // it; this measures their setup-pose world x axes against it, as A50 poses
+  // the setup pose.
+  //
+  // 🔒 **Validity, not archetype.** It fires only on a declaration, so it
+  // cannot fire on foreign data — the reason archetype rules leave the default
+  // profile — and a declaration the default profile never read would be one
+  // nothing reads. And it holds every declared bone, keyed or not: a consumer
+  // writes them at run time (`openTrack({ adjust })`), which no animation shows.
+  check('A51_BONES_LIE_ALONG_THEIR_DECLARED_AXIS', () =>
+    skeletonData === null ? skip('A51_BONES_LIE_ALONG_THEIR_DECLARED_AXIS', SKIP_NO_SKELETON) : a51BonesLieAlongTheirDeclaredAxis(verdicts, spineSetupWorld(skeletonData), input),
+  );
+
   // --- A18: determinism ----------------------------------------------------
   // The body is `./assertions/bodies/a18.ts` (issue #1060): the model document's clause, which the model side
   // runs too, and the Spine pair's two clauses handed to it as this side's encoding findings, in their order.