@rig-c/parts 1.5.5 → 1.7.0

package/src/rig.ts

@@ -27,9 +27,38 @@
  *   numbers the reference wrote. A key the turn would re-aim — a translate
  *   key under a turned parent, a scale or shear key on a turned bone — is
  *   refused (`RIG_KEY_FRAME_UNTURNED`); rotate keys mean what they meant.
- *   A single bone with a `tip` is not turned (its tip is still a segment
- *   end for the weights); giving it a lever would be the same change on
- *   that bone and its children, and is not made here.
+ *   A single bone with a `tip` is turned the same way (issue #239): its
+ *   `rotation` is the direction from its origin to its tip and its `length`
+ *   that distance, the segment its weights are already measured along, so a
+ *   `tip` the config states is never accepted and ignored. A tip on its own
+ *   origin has no direction and is refused (`RIG_TIP_DISTINCT`).
+ * - **The face's axis** (issue #239). The five face bones a blink or an
+ *   expression scales or translates, {@link FACE_BONES}, take the eye line's
+ *   angle as their world rotation, so the blink's `scaley` squashes across
+ *   the eye line and not across the page's horizontal on a tilted head. The
+ *   line exists when parts.json holds the parts tagged `eyewhite-r` and
+ *   `eyewhite-l` (the first of each, a cut's piece not counted — the parts
+ *   `propose` stands `eye_r` and `eye_l` on) and config.bones declares both
+ *   eye bones; it runs through the two eye bones' origins, read from the
+ *   image-left one to the image-right one, so the angle is always the
+ *   measured one, inside (−90°, 90°), which tag is which side does not enter
+ *   it, and it is the line rigc's A51 draws. With one eyewhite or none, an
+ *   eye bone missing, or two eye bones in one column, there is no line:
+ *   {@link FaceAxis} says why and the face bones
+ *   keep the page's axes. A face bone with its own `tip` takes the tip. A
+ *   bone under a face bone that nothing else turns keeps its parent's axis,
+ *   so a key on it means the face's axis too; the face bones' controls carry
+ *   the turn as a link's do. Regions on these bones are turned back as every
+ *   region is, so the setup pose is the same picture; a scale key on a face
+ *   bone, and a translate key on a bone under one, mean the face's axes and
+ *   are not refused. A translate key on a face bone itself still moves it
+ *   along its parent's (the head's) axes — Spine's rule, which turning the
+ *   bone does not change. With a line the rig spec also declares
+ *   `invariants.axes` (rig-c 2.40.0): one entry, {@link FACE_AXIS_NAME},
+ *   through `eye_r` and `eye_l`, holding the turned bones and their controls,
+ *   which rigc's `A51_BONES_LIE_ALONG_THEIR_DECLARED_AXIS` checks. Its
+ *   tolerance is measured on the bones as rigc emits them (see where it is
+ *   written), the float floor; with no line no entry is written.
  * - **Meshes** over the parts named in `meshes`: a square lattice (`src/mesh.ts`)
  *   weighted by distance to the mesh's candidate segments (`src/weights.ts`),
  *   written in rigc's by-name `weights` form. The slot's bone is the first
@@ -84,6 +113,7 @@
 import { type AutoSpec, type BoneEntry, type WeightRule, type CharacterConfig, type ConfigConstraint, CONSTRAINT_FOLLOWS, constraintForRig, type ContourSpec, type Point, type RibsSpec, ROOT_BONE, weightsABone } from './config.ts';
 import { type BoneTransform, computeExactFrameTransforms, cropToSpineY, normaliseDegrees, toBoneLocal, toWorld } from './coords.ts';
 import { type Problem, refuseIfAny } from './errors.ts';
+import { f32 } from 'rig-c/compile';
 import type { MeshCounts, MeshQualityReport, MeshReductionInput, MotionAmplitude, ReducedMesh, Termination } from 'rig-c/mesh';
 import { type AmplitudeRow, amplitudeRow, partAmplitude, withAmplitude } from './autoamplitude.ts';
 import { type ResidualRow, residualRow, slotEnvelope, withSkinning } from './autoenvelope.ts';
@@ -112,7 +142,8 @@ import { type ContourChainRibs, type ContourReport, contourMesh, type ContourReg
 import { type LocalInfluence, localInfluences } from './localweights.ts';
 import { artCoverage, ART_ALPHA, latticeMesh, ONE_LOOP_PASSES } from './mesh.ts';
 import { BLINK, blinkHoldMisses, blinkSpan, CONTROL_SUFFIX, controlledBones, IDLE_FPS, idleMotion, type MotionSpec, moveKeysToControls } from './motion.ts';
-import { PAINTING_RUN, type PartsFile, readFrom } from './parts.ts';
+import { PAINTING_RUN, type PartsFile, readFrom, tagOf } from './parts.ts';
+import { EYE_GROUP_TAGS } from './propose.ts';
 import { alphaAbove, crop, pad, type Raster } from './raster/index.ts';
 import { pyRound } from './round.ts';
 import { boneHeat, heatInfluences, heatRow, type HeatRow, latticeSilhouette, tracedSilhouette } from './heat.ts';
@@ -151,6 +182,88 @@ function places(v: number): number {
   return placed(v, OFFSET_PLACES);
 }
 
+/**
+ * The face bones that take the face's axis (issue #239): the bones `propose`
+ * writes for the eyes, the brows and the mouth, which the blink and an
+ * expression scale or translate. Read by name, as the blink's groups name
+ * them; a config without one of them has nothing of that name to turn.
+ */
+export const FACE_BONES: readonly string[] = ['eye_r', 'eye_l', 'brow_r', 'brow_l', 'mouth'];
+
+/** The eye line the face bones are turned to, or why there is none (issue #239). */
+export interface FaceAxis {
+  /** The eye line's angle in Spine degrees (counter-clockwise, y up), as written; null with no line. */
+  degrees: number | null;
+  /** The eyewhite parts that make the line exist, `eyewhite-r`'s first; fewer than two when they are what is missing. */
+  parts: string[];
+  /** The face bones turned to the line, in {@link FACE_BONES} order; empty with no line. */
+  turned: string[];
+  /** The face bones a `tip` of their own turns instead, in {@link FACE_BONES} order. */
+  ownTip: string[];
+  /** Why there is no line, or null. */
+  none: string | null;
+  /** The `invariants.axes` entry written for the line (issue #239, rig-c's `A51`), or null with the reason in {@link FaceAxis.noAxis}. */
+  axis: RigAxis | null;
+  /** Why no axes entry was written, or null when one was (or there is no line, which {@link FaceAxis.none} says). */
+  noAxis: string | null;
+}
+
+/** One `invariants.axes` entry: rig-c's `RigAxis`, held by its gate rule `A51_BONES_LIE_ALONG_THEIR_DECLARED_AXIS` (2.40.0). */
+export interface RigAxis {
+  name: string;
+  through: [string, string];
+  bones: string[];
+  tolerance: number;
+}
+
+/** The name of the face's `invariants.axes` entry. */
+export const FACE_AXIS_NAME = 'face';
+
+/** One unit in the last place a rotation is written to ({@link OFFSET_PLACES}): the axes entry's tolerance stands this far above the gap it measures. */
+const WRITTEN_UNIT = 10 ** -6;
+
+/** Two directions' gap as lines, 0 to 90 degrees — rig-c's `lineGap` (A51), restated here because it is not on an entry this package imports. */
+function lineGap(a: number, b: number): number {
+  const d = (((a - b) % 180) + 180) % 180;
+  return Math.min(d, 180 - d);
+}
+
+/** The bones the face's line runs through: rigc's A51 draws its line through their origins, and the face bones are turned to that same line. */
+export const EYE_BONES: readonly [string, string] = ['eye_r', 'eye_l'];
+
+/**
+ * The eye line (issue #239). It exists when parts.json holds an eye on each
+ * side — the first part tagged `eyewhite-r` and the first tagged `eyewhite-l`
+ * (a cut's piece is neither), the parts `propose` stands `eye_r` and `eye_l`
+ * on — and config.bones declares both eye bones. Its angle is read off the
+ * two eye bones' origins as the config writes them, image-left to
+ * image-right, in Spine's axes through the one y flip: the very line rigc's
+ * A51 draws through those bones, so the face bones stand on what the gate
+ * measures (the eyewhites' unrounded centres would sit up to a rounding off
+ * it — demo's half pixel was 0.47 degrees), and a moved eye bone moves the
+ * line with it. Null with the reason when an eyewhite or an eye bone is
+ * missing, or when the two eye bones share a column, so the line has no
+ * left-to-right direction to read.
+ */
+export function eyeLine(parts: PartsFile, eyeBones: ReadonlyMap<string, Point>): { degrees: number; parts: [string, string] } | { degrees: null; parts: string[]; none: string } {
+  const H = parts.rig_size[1];
+  const found = EYE_GROUP_TAGS.map((tag) => ({ tag, part: parts.parts.find((p) => tagOf(p.from) === tag && p.cut_from === undefined) }));
+  const have = found.flatMap((f) => (f.part === undefined ? [] : [f.part]));
+  if (have.length < 2) {
+    const missing = found.filter((f) => f.part === undefined).map((f) => f.tag);
+    return { degrees: null, parts: have.map((p) => p.name), none: `parts.json holds no part tagged ${missing.join(' or ')} (a cut's piece is not counted), so there is no eye line` };
+  }
+  const names = have.map((p) => p.name);
+  const absent = EYE_BONES.filter((n) => !eyeBones.has(n));
+  if (absent.length > 0) return { degrees: null, parts: names, none: `config.bones declares no single bone ${absent.join(' or ')}, so there is no pair of eye bones for the eye line to run through` };
+  const [a, b] = EYE_BONES.map((n) => eyeBones.get(n) as Point);
+  if (a[0] === b[0]) return { degrees: null, parts: names, none: `${EYE_BONES[0]} ${pt(a)} and ${EYE_BONES[1]} ${pt(b)} share the column x = ${a[0]}, so the eye line has no left-to-right direction to read` };
+  const [l, r] = a[0] < b[0] ? [a, b] : [b, a];
+  const dx = r[0] - l[0];
+  const dy = cropToSpineY(r[1], H) - cropToSpineY(l[1], H);
+  return { degrees: (Math.atan2(dy, dx) * 180) / Math.PI, parts: [names[0], names[1]] };
+}
+
 /**
  * The weights a contour vertex is written with: a vertex no region reaches is
  * rounded as the lattice rounds (each to 5 places, the last `1 − sum(others)`),
@@ -249,7 +362,7 @@ export interface RigSpec {
    * the idle keys a mesh-driving bone. `detached`: written only when a
    * constraint follows a bone ({@link detachedRules}).
    */
-  invariants?: { idleDrivesMeshes?: { why: string }; detached?: DetachedRule[]; deformMayFold?: Array<{ slot: string; why: string }> };
+  invariants?: { idleDrivesMeshes?: { why: string }; detached?: DetachedRule[]; deformMayFold?: Array<{ slot: string; why: string }>; axes?: RigAxis[] };
 }
 
 /** One `invariants.detached` entry: rig-c's `RigDetachedRule`, checked by its gate rule `A25`. */
@@ -541,6 +654,8 @@ export interface RigOutput {
   loopPasses: Record<string, number>;
   /** Per automatic mesh, in parts.json order: what the rig stage's motion gate compares (`src/automotion.ts`). Nothing written. */
   autoMotion: AutoMotionCase[];
+  /** The eye line the face bones were turned to, or why there is none (issue #239). */
+  faceAxis: FaceAxis;
 }
 
 /**
@@ -614,6 +729,8 @@ export function buildRig(
   const chains = new Map<string, string[]>();
   /** Each chain's points and tip, rig px, as declared (issue #188: the ribs are placed along them). */
   const chainLines = new Map<string, Point[]>();
+  /** The single bones that state a `tip` (issue #239: each is turned towards it). */
+  const singleTips = new Set<string>();
   cfg.bones.forEach((e: BoneEntry, i) => {
     if ('chain' in e) {
       const names: string[] = [];
@@ -641,7 +758,17 @@ export function buildRig(
       chainLines.set(e.chain, polyline);
     } else {
       B.set(e.name, { name: e.name, parent: e.parent, x: e.at[0], y: e.at[1] });
-      if (e.tip !== undefined) tips.set(e.name, [e.tip[0], e.tip[1]]);
+      if (e.tip !== undefined) {
+        if (same(e.at, e.tip)) {
+          fail(
+            'RIG_TIP_DISTINCT',
+            `config.bones[${i}] "${e.name}".tip`,
+            `is ${pt(e.tip)}, the bone's own origin; a bone is turned from its origin towards its tip (issue #239), and a tip on the origin has no direction — give a tip other than ${pt(e.at)}, or leave the tip out`,
+          );
+        }
+        tips.set(e.name, [e.tip[0], e.tip[1]]);
+        singleTips.add(e.name);
+      }
     }
   });
 
@@ -824,6 +951,38 @@ export function buildRig(
       if (controls.includes(l)) aim.set(`${l}${CONTROL_SUFFIX}`, a);
     }
   }
+  // A single bone with a tip points at it the same way, and its control with it (issue #239).
+  for (const n of singleTips) {
+    const b = B.get(n) as Bone;
+    const end = tips.get(n) as Point;
+    const dx = spineX(end[0]) - spineX(b.x);
+    const dy = spineY(end[1]) - spineY(b.y);
+    const a = { rotation: (Math.atan2(dy, dx) * 180) / Math.PI, length: pyRound(Math.sqrt(dx * dx + dy * dy), 3) };
+    aim.set(n, a);
+    if (controls.includes(n)) aim.set(`${n}${CONTROL_SUFFIX}`, a);
+  }
+  // ---- the face's axis (issue #239) --------------------------------------
+  // Each face bone config.bones declares as a single bone with no tip of its own stands on the eye line, and its
+  // control with it; a bone under a face-framed bone that nothing else turns keeps that frame.
+  const eyeAt = new Map<string, Point>();
+  for (const e of cfg.bones) if (!('chain' in e) && (EYE_BONES as readonly string[]).includes(e.name)) eyeAt.set(e.name, [e.at[0], e.at[1]]);
+  const line = eyeLine(parts, eyeAt);
+  const declared = FACE_BONES.filter((n) => cfg.bones.some((e) => !('chain' in e) && e.name === n));
+  const faceAxis: FaceAxis = {
+    degrees: line.degrees,
+    parts: line.parts,
+    turned: line.degrees === null ? [] : declared.filter((n) => !singleTips.has(n)),
+    ownTip: declared.filter((n) => singleTips.has(n)),
+    none: line.degrees === null ? line.none : null,
+    axis: null,
+    noAxis: null,
+  };
+  const faceTurn = new Map<string, number>();
+  for (const n of faceAxis.turned) {
+    faceTurn.set(n, line.degrees as number);
+    if (controls.includes(n)) faceTurn.set(`${n}${CONTROL_SUFFIX}`, line.degrees as number);
+  }
+  const faceRoots = new Set(declared.flatMap((n) => (controls.includes(n) ? [n, `${n}${CONTROL_SUFFIX}`] : [n])));
   // Each bone's local rotation turns it from its parent's world rotation to
   // the one it should have: its chain's direction, or 0 for every other bone,
   // so a named bone under a chain link is turned back upright. `turn` is the
@@ -831,6 +990,8 @@ export function buildRig(
   // tree. Each local offset is the bone's origin carried into its parent's
   // setup frame as written, through rigc's inverse (`src/coords.ts`).
   const turn = new Map<string, number>();
+  /** The bones whose frame is the face's (issue #239): the face bones, their controls, and what hangs under them unturned. */
+  const faceFramed = new Set<string>();
   const bones: RigBone[] = [];
   for (const b of ordered) {
     if (b.parent === null) {
@@ -840,7 +1001,10 @@ export function buildRig(
     }
     const up = turn.get(b.parent) as number;
     const a = aim.get(b.name);
-    const rotation = places(normaliseDegrees((a?.rotation ?? 0) - up));
+    const inherits = a === undefined && !faceRoots.has(b.name) && faceFramed.has(b.parent);
+    if (faceRoots.has(b.name) || inherits) faceFramed.add(b.name);
+    const target = a?.rotation ?? faceTurn.get(b.name) ?? (inherits ? up : 0);
+    const rotation = places(normaliseDegrees(target - up));
     turn.set(b.name, places(up + rotation));
     const frame = computeExactFrameTransforms(bones).get(b.parent) as BoneTransform;
     const [x, y] = toBoneLocal(frame, spineX(b.x), spineY(b.y));
@@ -848,6 +1012,34 @@ export function buildRig(
   }
   const world = computeExactFrameTransforms(bones);
 
+  // ---- the face's axes entry (issue #239, rig-c 2.40.0's A51) -------------
+  // The gate draws its line through the eye bones' setup origins, and the face bones were turned to the line through
+  // the same two origins as the config writes them ({@link eyeLine}); what separates the two is only how the numbers
+  // are stored. So the tolerance is measured, not chosen: the largest gap, as lines, between the line through
+  // eye_r -> eye_l and any listed bone's world x axis, in the setup frames of the bones as rigc emits them (each x, y
+  // and rotation through rig-c's own `f32`, the float32 the skeleton stores — 36.869898 is stored 1.6e-6 degrees off,
+  // more than a 6-place unit), rounded up to the places a rotation is written to, plus one unit of that last place —
+  // the float floor of the emitted rig, to the precision this stage writes. A bone turned further off is A51's.
+  if (faceAxis.turned.length > 0) {
+    const through: [string, string] = [EYE_BONES[0], EYE_BONES[1]];
+    const listed = bones.map((b) => b.name).filter((n) => faceTurn.has(n));
+    const emitted = computeExactFrameTransforms(
+      bones.map((bn) => ({ ...bn, x: f32(bn.x), y: f32(bn.y), ...(bn.rotation === undefined ? {} : { rotation: f32(bn.rotation) }) })),
+    );
+    const [a, b] = through.map((n) => emitted.get(n) as BoneTransform);
+    const gateLine = (Math.atan2(b.worldY - a.worldY, b.worldX - a.worldX) * 180) / Math.PI;
+    if (a.worldX === b.worldX && a.worldY === b.worldY) faceAxis.noAxis = `eye_r and eye_l share the world origin (${a.worldX}, ${a.worldY}), so they draw no line`;
+    else {
+      const gap = Math.max(...listed.map((n) => {
+        const t = emitted.get(n) as BoneTransform;
+        return lineGap((Math.atan2(t.c, t.a) * 180) / Math.PI, gateLine);
+      }));
+      const tolerance = pyRound(Math.ceil(gap / WRITTEN_UNIT) * WRITTEN_UNIT + WRITTEN_UNIT, OFFSET_PLACES);
+      if (tolerance >= 90) faceAxis.noAxis = `the face bones lie ${pyRound(gap, 6)} degrees off the line through eye_r and eye_l, and rigc takes a tolerance below 90 only`;
+      else faceAxis.axis = { name: FACE_AXIS_NAME, through, bones: listed, tolerance };
+    }
+  }
+
   // ---- keys a turned frame would change ----------------------------------
   // A rotate key turns a bone about its origin whatever its frame, so the
   // idle's chain sways mean what they meant. A translate key moves a bone
@@ -866,7 +1058,8 @@ export function buildRig(
     const translate = k.prop.startsWith('translate');
     const frameBone = translate ? parent : k.bone;
     const deg = turn.get(frameBone) as number;
-    if (deg === 0) continue;
+    // A key in a face-framed bone's frame means the face's axes: that is the point of the turn (issue #239).
+    if (deg === 0 || faceFramed.has(frameBone)) continue;
     const axis = k.prop.slice(-1);
     fail(
       'RIG_KEY_FRAME_UNTURNED',
@@ -1359,7 +1552,9 @@ export function buildRig(
   // issue #126 item 3: an automatic part whose author set motion.deformMayFold — written only then, so no other rig moves.
   const mayFold = autoMotion.filter((c) => c.motion?.deformMayFold === true).map((c) => ({ slot: c.part, why: DEFORM_MAY_FOLD_WHY }));
   if (mayFold.length > 0) rig.invariants = { ...rig.invariants, deformMayFold: mayFold };
-  return { rig, motion, meshReport, images: outImages, controls, meshKeyed, idleKeys, loopPasses, autoMotion };
+  // issue #239: the face's line, written only when the face bones were turned to one, so no other rig moves.
+  if (faceAxis.axis !== null) rig.invariants = { ...rig.invariants, axes: [faceAxis.axis] };
+  return { rig, motion, meshReport, images: outImages, controls, meshKeyed, idleKeys, loopPasses, autoMotion, faceAxis };
 }
 
 /**
@@ -1377,7 +1572,9 @@ export function rigJsonText(value: unknown): string {
  * weight's bind `x, y` and each region's `x, y` is carried out of its frame as
  * written (rigc's `toWorld`, `src/coords.ts`) and back in as a difference from
  * the frame's origin, at the reference's 3 places; `length` and `rotation` are
- * dropped. Everything else is copied.
+ * dropped, and so is `invariants.axes` (issue #239): it holds bones to a
+ * line they lie along only when turned, which the flat form undoes, and the
+ * reference declared none. Everything else is copied.
  *
  * It exists so the reference's outputs stay an oracle: the chain suite and
  * `scripts/rig_oracle.ts` compare `flattenRig(built)` with the reference's
@@ -1436,5 +1633,11 @@ export function flattenRig(rig: RigSpec, sense: 1 | -1 = 1): RigSpec {
     skin[slot] = flat;
   }
   refuseIfAny(problems);
-  return { ...rig, bones, skins: { default: skin } };
+  const flat: RigSpec = { ...rig, bones, skins: { default: skin } };
+  if (rig.invariants?.axes !== undefined) {
+    const { axes: _axes, ...rest } = rig.invariants;
+    if (Object.keys(rest).length > 0) flat.invariants = rest;
+    else delete flat.invariants;
+  }
+  return flat;
 }

package/src/scene.ts

@@ -17,6 +17,7 @@
  *
  * - **Names, totally.** Every bone, slot, attachment (skin entry), constraint
  *   (its name and every bone or slot it names), `invariants.detached` bone,
+ *   `invariants.axes` entry (its name, its `through` and its `bones`; issue #239),
  *   track, group and easing of character `<id>` is renamed `<id>:<name>`
  *   ({@link prefixed}); `root` is the one shared root. A name resolves to
  *   exactly one character, and nothing resolves across characters without its
@@ -382,7 +383,7 @@ const BONE_KEYS = ['name', 'parent', 'length', 'rotation', 'x', 'y'];
 const SLOT_KEYS = ['name', 'bone', 'attachment'];
 const ATTACHMENT_KEYS = ['type', 'image', 'width', 'height', 'uvs', 'triangles', 'hull', 'weights', 'x', 'y', 'rotation'];
 const RIG_KEYS = ['spec', 'name', 'images', 'skeleton', 'bones', 'slots', 'skins', 'constraints', 'invariants'];
-const INVARIANT_KEYS = ['idleDrivesMeshes', 'detached'];
+const INVARIANT_KEYS = ['idleDrivesMeshes', 'detached', 'axes'];
 const MOTION_KEYS = ['spec', 'archetype', 'cut', 'easings', 'groups', 'animations'];
 const IDLE_KEYS = ['duration', 'loop', 'note', 'tracks'];
 const TRACK_KEYS = ['bone', 'group', 'property', 'keys'];
@@ -965,6 +966,10 @@ export function composeScene(
       ownBone(b.id, d.bone, `character "${b.id}" rig.json invariants.detached[${k}].bone`);
       ownBone(b.id, d.notUnder, `character "${b.id}" rig.json invariants.detached[${k}].notUnder`);
     }
+    for (const [k, ax] of (b.rig.invariants?.axes ?? []).entries()) {
+      ax.through.forEach((n, j) => ownBone(b.id, n, `character "${b.id}" rig.json invariants.axes[${k}].through[${j}]`));
+      ax.bones.forEach((n, j) => ownBone(b.id, n, `character "${b.id}" rig.json invariants.axes[${k}].bones[${j}]`));
+    }
   }
   // The root is shared: a character that drives it would move every character.
   for (const b of ready) {
@@ -1030,6 +1035,7 @@ export function composeScene(
   }
   const constraints: Array<Record<string, unknown>> = [];
   const detached: NonNullable<NonNullable<RigSpec['invariants']>['detached']> = [];
+  const axes: NonNullable<NonNullable<RigSpec['invariants']>['axes']> = [];
   scene.characters.forEach((c) => {
     const b = byId.get(c.id) as CharacterBuild;
     const id = c.id;
@@ -1090,6 +1096,8 @@ export function composeScene(
       constraints.push(out);
     }
     for (const d of b.rig.invariants?.detached ?? []) detached.push({ ...d, bone: P(id, d.bone), notUnder: P(id, d.notUnder) });
+    // An axis entry's name is unique within one rig, and two characters each carry a "face": the name is prefixed too.
+    for (const ax of b.rig.invariants?.axes ?? []) axes.push({ name: prefixed(id, ax.name), through: [P(id, ax.through[0]), P(id, ax.through[1])], bones: ax.bones.map((n) => P(id, n)), tolerance: ax.tolerance });
   });
   const slots: RigSpec['slots'] = [];
   if (scene.plate !== null && plate !== null) slots.push({ name: PLATE, bone: PLATE, attachment: PLATE });
@@ -1101,6 +1109,7 @@ export function composeScene(
   const invariants: NonNullable<RigSpec['invariants']> = {};
   if (whys.length === 1) invariants.idleDrivesMeshes = { why: whys[0] };
   if (detached.length > 0) invariants.detached = detached;
+  if (axes.length > 0) invariants.axes = axes;
   if (Object.keys(invariants).length > 0) rig.invariants = invariants;
 
   // ---- the motion ---------------------------------------------------------------
@@ -1246,6 +1255,10 @@ export function unprefixedNames(rig: RigSpec, motion: MotionSpec, ids: readonly
     name('invariants.detached bone', d.bone, false);
     name('invariants.detached notUnder', d.notUnder, false);
   }
+  for (const ax of rig.invariants?.axes ?? []) {
+    name('invariants.axes name', ax.name, false);
+    for (const n of [...ax.through, ...ax.bones]) name(`invariants.axes ${ax.name} bone`, n, false);
+  }
   for (const [k, v] of Object.entries(motion.easings)) name('easing', k, false);
   for (const [g, members] of Object.entries(motion.groups)) {
     name('group', g, false);