@hatiolab/figure-model 0.10.0 → 0.11.1

package/dist/joint-writing.js

@@ -9,14 +9,16 @@ import { compileFigureGraph, figureShapeFaces } from "./graph.js";
 import { remappedFaces } from "./shape-edit.js";
 import { REPEAT_LIMIT, AXES } from "./words.js";
 import { FIGURE_INSTANCE_SIZE_INPUTS } from "./instance-size.js";
-import { FIGURE_FACES, FIGURE_JOINT_TYPES, FIGURE_JOINT_PIVOTS, figureMimicLeadersOf, followsSomething, followedTermsOf } from "./authoring-types.js";
+import { FIGURE_FACES, FIGURE_MOTION_TYPES, FIGURE_JOINT_PIVOTS, figureMimicLeadersOf, followsSomething, followedTermsOf } from "./authoring-types.js";
 import { fail, nodeById, partOf, namer, constantOf, measureRef, sumOf, stableDimension, ownInput, holdingDeclared, dropIfUnused, parentOf, round6 } from "./authoring-nodes.js";
 import { mul3, neg, half, ownSpansOf, IDENTITY, transpose3, mv3, eulerOfAny, rpyMatrix, isQuarterMatrix, receivingAxisOf, rpyOf } from "./authoring-geometry.js";
 import { placeOnFace, addMotion, removeMotion, reseat, turnSeat } from "./authoring-fastening.js";
 import { figureShapeExtremeAlong, lin, plus, times, writeFigureReach } from "./shape-extreme.js";
+import { figureAxesOf, figureMotionsOf, isMovingJoint, motionNodeIdOf, motionStateIdOf } from "./joint-motions.js";
 const everyKey = () => (...keys) => keys;
 const JOINT_FIELDS = {
-    joint: everyKey()('id', 'type', 'body0', 'body1', 'origin', 'axis', 'lowerLimit', 'upperLimit', 'travel', 'state', 'mimic', 'repeat'),
+    joint: everyKey()('id', 'body0', 'body1', 'origin', 'motion', 'repeat'),
+    motion: everyKey()('id', 'type', 'axis', 'through', 'lowerLimit', 'upperLimit', 'travel', 'state', 'mimic'),
     body0: everyKey()('part', 'face', 'surface', 'plane', 'at'),
     surface: everyKey()('toward', 'around', 'along'),
     body1: everyKey()('part', 'at'),
@@ -28,8 +30,8 @@ const JOINT_FIELDS = {
     source: everyKey()('of', 'axis', 'input', 'part'),
     travel: everyKey()('source', 'times', 'plus', 'sum'),
     state: everyKey()('id', 'label', 'start', 'sweep'),
-    mimic: everyKey()('joint', 'multiplier', 'offset', 'sum'),
-    leader: everyKey()('joint', 'multiplier'),
+    mimic: everyKey()('motion', 'multiplier', 'offset', 'sum'),
+    leader: everyKey()('motion', 'multiplier'),
     repeat: everyKey()('axis', 'pitch', 'count', 'rise'),
     rise: everyKey()('axis', 'mm')
 };
@@ -79,18 +81,29 @@ function knownJointFields(j, path) {
             measure(a?.mm, `${path}.origin.align.${axis}.mm`);
         }
     }
-    only(j.axis, JOINT_FIELDS.axes, `${path}.axis`);
-    if (j.travel && typeof j.travel === 'object') {
-        only(j.travel, JOINT_FIELDS.travel, `${path}.travel`);
-        source(j.travel.source, `${path}.travel.source`);
-        if (Array.isArray(j.travel.sum))
-            measure({ sum: j.travel.sum }, `${path}.travel`);
+    if (j.motion !== undefined && !Array.isArray(j.motion))
+        fail('JOINT_SCHEMA', `${path}.motion`, 'a motion is a list of axes');
+    for (const [k, a] of (Array.isArray(j.motion) ? j.motion : []).entries()) {
+        const at = `${path}.motion.${k}`;
+        only(a, JOINT_FIELDS.motion, at);
+        if (!a || typeof a !== 'object')
+            continue;
+        only(a.axis, JOINT_FIELDS.axes, `${at}.axis`);
+        only(a.through, JOINT_FIELDS.axes, `${at}.through`);
+        for (const [axis, d] of Object.entries(a.through && typeof a.through === 'object' ? a.through : {}))
+            measure(d, `${at}.through.${axis}`);
+        if (a.travel && typeof a.travel === 'object') {
+            only(a.travel, JOINT_FIELDS.travel, `${at}.travel`);
+            source(a.travel.source, `${at}.travel.source`);
+            if (Array.isArray(a.travel.sum))
+                measure({ sum: a.travel.sum }, `${at}.travel`);
+        }
+        only(a.state, JOINT_FIELDS.state, `${at}.state`);
+        only(a.mimic, JOINT_FIELDS.mimic, `${at}.mimic`);
+        if (Array.isArray(a.mimic?.sum))
+            for (const [i, t] of a.mimic.sum.entries())
+                only(t, JOINT_FIELDS.leader, `${at}.mimic.sum.${i}`);
     }
-    only(j.state, JOINT_FIELDS.state, `${path}.state`);
-    only(j.mimic, JOINT_FIELDS.mimic, `${path}.mimic`);
-    if (Array.isArray(j.mimic?.sum))
-        for (const [i, t] of j.mimic.sum.entries())
-            only(t, JOINT_FIELDS.leader, `${path}.mimic.sum.${i}`);
     only(j.repeat, JOINT_FIELDS.repeat, `${path}.repeat`);
     if (j.repeat && typeof j.repeat === 'object') {
         measure(j.repeat.pitch, `${path}.repeat.pitch`);
@@ -110,7 +123,6 @@ export function figureAttachmentsOf(asset) {
 export function jointAbove(asset, part) {
     return asset.joints?.find(j => j.body1.part === part);
 }
-export const stateIdOf = (j) => j.state?.id ?? j.id;
 /** Whether a joint is placed at its parent's origin rather than on a face (ADR-0107 decision 4). */
 export const isOriginPlaced = (j) => !!j.body0 && 'at' in j.body0;
 /** A record's axis as a unit vector when it is written as one; undefined for a token. Zero or not finite is refused. */
@@ -204,6 +216,83 @@ function checkJointFrames(j, path) {
     if (o.offset !== undefined && (!o.offset || typeof o.offset !== 'object'))
         fail('JOINT_SCHEMA', `${path}.origin.offset`, 'an offset is a length along x, y and z');
 }
+/**
+ * A joint's axes (ADR-0159): each turns or slides about an axis, has its limits -- a revolute one may have none and
+ * turns without end, a slide always has them -- or follows other axes. Its id is unique among every joint's axes and
+ * every other joint's id, so a follower, a control and the joint list name one thing. Two axes in a row on one line
+ * are two: each its own control, range and followers, though the pose they make is one turn (review 2026-10-24).
+ */
+function checkMotion(others, j, path) {
+    const motions = figureMotionsOf(j);
+    const theirs = figureAxesOf(others).map(a => a.motion);
+    const ids = new Set([...theirs.map(a => a.id), ...others.map(o => o.id)]);
+    for (const [k, a] of motions.entries()) {
+        const at = `${path}.motion.${k}`;
+        const record = j.motion[k];
+        if (!record || typeof record !== 'object')
+            fail('JOINT_SCHEMA', at, 'an axis is { type, axis }');
+        if (!FIGURE_MOTION_TYPES.includes(a.type))
+            fail('JOINT_SCHEMA', at, `${String(a.type)} is not a motion; ${FIGURE_MOTION_TYPES.join(', ')}`);
+        if (record.id !== undefined && (typeof record.id !== 'string' || !record.id.trim()))
+            fail('JOINT_SCHEMA', `${at}.id`, 'an axis id is a name');
+        if (ids.has(a.id))
+            fail('JOINT_SCHEMA', `${at}.id`, `${a.id} names another axis already; an axis id is unique among every joint's axes`);
+        ids.add(a.id);
+        if (!['X', 'Y', 'Z'].includes(a.axis) && !jointVectorOf(a.axis, at))
+            fail('JOINT_SCHEMA', at, `a ${a.type} axis is X, Y or Z, or a vector { x, y, z }`);
+        for (const [x, d] of Object.entries(a.through ?? {}))
+            if (d !== undefined && (typeof d === 'number' ? !Number.isFinite(d) : !followsSomething(d)))
+                fail('JOINT_SCHEMA', `${at}.through.${x}`, 'the point an axis passes is millimetres, or a length that follows something');
+        if (a.travel !== undefined && a.type !== 'prismatic')
+            fail('JOINT_SCHEMA', at, 'only a prismatic axis travels a length');
+        const limited = a.lowerLimit !== undefined || a.upperLimit !== undefined;
+        if (a.type === 'prismatic' && a.travel && !limited) {
+            record.lowerLimit = 0;
+            record.upperLimit = 1;
+        }
+        /* A revolute axis without limits turns without end (USD); with them, both are given. A slide always has them. */
+        if (!a.mimic && (limited || a.type === 'prismatic')) {
+            const [lo, hi] = [record.lowerLimit, record.upperLimit];
+            if (!(Number.isFinite(lo) && Number.isFinite(hi) && lo < hi))
+                fail('JOINT_SCHEMA', at, `a ${a.type} axis has both limits, lower below upper`);
+            /*
+              The rest pose is every axis at 0 -- the kinematic reference it is read at (joint-list.ts) -- and 0 need not be a
+              value it may take: an axis limited to 10..80 still has its reference at 0 (ADR-0107 J4). Its starting value, the
+              stored state default, is held to its limits as every control's is (addMotion).
+            */
+        }
+    }
+    for (const [k, a] of motions.entries()) {
+        if (!a.mimic)
+            continue;
+        const at = `${path}.motion.${k}`;
+        /*
+          One leader or a sum of them (ADR-0107 decision 2), each held to the same rules: an axis that leads itself -- so a
+          follower is never a leader and no loop can close -- that moves the way this one does (degrees are not added to
+          millimetres), named once, with a finite multiplier.
+        */
+        const sum = Object.hasOwn(a.mimic, 'sum');
+        if (sum && !(Array.isArray(a.mimic.sum) && a.mimic.sum.length))
+            fail('JOINT_SCHEMA', at, 'a mimic sum follows one axis or more');
+        const seen = new Set();
+        for (const t of figureMimicLeadersOf(a)) {
+            const leader = [...theirs, ...motions].find(o => o.id === t?.motion && o.id !== a.id);
+            if (!leader)
+                fail('JOINT_SCHEMA', at, `${String(t?.motion)} is not a moving axis to follow`);
+            if (seen.has(leader.id))
+                fail('JOINT_SCHEMA', at, `${leader.id} is followed twice; a sum names each axis once`);
+            seen.add(leader.id);
+            if (leader.mimic)
+                fail('JOINT_SCHEMA', at, `${leader.id} follows another axis; follow the one it follows`);
+            if ((leader.type === 'prismatic') !== (a.type === 'prismatic'))
+                fail('JOINT_SCHEMA', at, `${leader.id} ${leader.type === 'prismatic' ? 'slides' : 'turns'}; an axis follows ones that move the same way: a slide a slide, a turn a turn`);
+            if (!Number.isFinite(t.multiplier))
+                fail('JOINT_SCHEMA', at, 'a mimic has a multiplier');
+        }
+        if (a.mimic.offset !== undefined && !Number.isFinite(a.mimic.offset))
+            fail('JOINT_SCHEMA', at, "a mimic's offset is a number in the axis's unit");
+    }
+}
 /** A record that is well formed on its own, and fits the tree the others make. */
 function checkJoint(asset, j) {
     const m = asset.document.model;
@@ -211,8 +300,6 @@ function checkJoint(asset, j) {
     if (!j || typeof j.id !== 'string' || !j.id.trim())
         fail('JOINT_SCHEMA', 'joints', 'a joint has an id');
     knownJointFields(j, path);
-    if (!FIGURE_JOINT_TYPES.includes(j.type))
-        fail('JOINT_SCHEMA', path, `${String(j.type)} is not a joint type; ${FIGURE_JOINT_TYPES.join(', ')}`);
     if (!j.body1 || typeof j.body1.part !== 'string')
         fail('JOINT_SCHEMA', path, 'a joint carries a part (body1)');
     partOf(m, j.body1.part, path);
@@ -234,56 +321,7 @@ function checkJoint(asset, j) {
             up = next && 'part' in next ? next.part : undefined;
         }
     }
-    const moving = j.type !== 'fixed';
-    const limited = j.lowerLimit !== undefined || j.upperLimit !== undefined;
-    if (moving && !['X', 'Y', 'Z'].includes(j.axis) && !jointVectorOf(j.axis, path))
-        fail('JOINT_SCHEMA', path, `a ${j.type} joint has an axis, X, Y or Z, or a vector { x, y, z }`);
-    if (!moving && (j.axis !== undefined || limited || j.mimic !== undefined || j.travel !== undefined))
-        fail('JOINT_SCHEMA', path, 'a fixed joint has no axis, limits, mimic or travel');
-    if (j.travel !== undefined && j.type !== 'prismatic')
-        fail('JOINT_SCHEMA', path, 'only a prismatic joint travels a length');
-    if (j.type === 'prismatic' && j.travel && !limited) {
-        j.lowerLimit = 0;
-        j.upperLimit = 1;
-    }
-    /* A revolute joint without limits turns without end (USD); with them, both are given. A slide always has them. */
-    if (moving && !j.mimic && (limited || j.type === 'prismatic')) {
-        const [lo, hi] = [j.lowerLimit, j.upperLimit];
-        if (!(Number.isFinite(lo) && Number.isFinite(hi) && lo < hi))
-            fail('JOINT_SCHEMA', path, `a ${j.type} joint has both limits, lower below upper`);
-        /*
-          The rest pose is every joint at 0 -- the kinematic reference its axis is read at (joint-list.ts) -- and 0 need not
-          be a value the joint may take: a joint limited to 10..80 still has its reference at 0 (ADR-0107 J4). Its starting
-          value, the stored state default, is held to its limits as every control's is (addMotion).
-        */
-    }
-    if (j.mimic) {
-        /*
-          One leader or a sum of them (ADR-0107 decision 2), each held to the same rules: a moving joint that leads itself
-          -- so a follower is never a leader and no loop can close -- that moves the way this one does (degrees are not
-          added to millimetres), named once, with a finite multiplier.
-        */
-        const sum = Object.hasOwn(j.mimic, 'sum');
-        if (sum && !(Array.isArray(j.mimic.sum) && j.mimic.sum.length))
-            fail('JOINT_SCHEMA', path, 'a mimic sum follows one joint or more');
-        const seen = new Set();
-        for (const t of figureMimicLeadersOf(j)) {
-            const leader = others.find(o => o.id === t?.joint);
-            if (!leader || leader.type === 'fixed')
-                fail('JOINT_SCHEMA', path, `${String(t?.joint)} is not a moving joint to follow`);
-            if (seen.has(leader.id))
-                fail('JOINT_SCHEMA', path, `${leader.id} is followed twice; a sum names each joint once`);
-            seen.add(leader.id);
-            if (leader.mimic)
-                fail('JOINT_SCHEMA', path, `${leader.id} follows another joint; follow the one it follows`);
-            if ((leader.type === 'prismatic') !== (j.type === 'prismatic'))
-                fail('JOINT_SCHEMA', path, `${leader.id} ${leader.type === 'prismatic' ? 'slides' : 'turns'}; a joint follows ones that move the same way: a slide a slide, a turn a turn`);
-            if (!Number.isFinite(t.multiplier))
-                fail('JOINT_SCHEMA', path, 'a mimic has a multiplier');
-        }
-        if (j.mimic.offset !== undefined && !Number.isFinite(j.mimic.offset))
-            fail('JOINT_SCHEMA', path, "a mimic's offset is a number in the joint's unit");
-    }
+    checkMotion(others, j, path);
     if (j.origin?.childRotate !== undefined &&
         (!j.origin.childRotate || typeof j.origin.childRotate !== 'object' || Object.values(j.origin.childRotate).some(t => !Number.isFinite(t))))
         fail('JOINT_SCHEMA', `${path}.origin.childRotate`, 'a pose is degrees about x, y and z');
@@ -392,78 +430,84 @@ function placeAtOrigin(asset, j) {
         turnSeat(asset, child, rpyMatrix(j.origin.parentRotate), j.origin.parentRotate, IDENTITY);
 }
 /**
- * A moving joint's motion, at the joint frame, about or along its axis turned into the parent's frame by `back`: a token
- * is one of the parent's axes, either way along it (a parent standing twisted refuses one that is not); a vector goes
- * as it is, as its unit vector (URDF's axis). A row is laid out last, once its part's motion is written.
+ * A moving joint's axes, in order (ADR-0159), each at the joint frame about or along its axis turned into the parent's
+ * frame by `back`: a token is one of the parent's axes, either way along it (a parent standing twisted refuses one that
+ * is not); a vector goes as it is, as its unit vector (URDF's axis). Each passes its point (`through`) and is carried by
+ * the ones before it. A row is laid out last, once its part's motion is written.
  */
 function moveJoint(asset, j, back) {
     const m = asset.document.model;
     const child = j.body1.part;
     const parent = 'part' in j.body0 ? j.body0.part : undefined;
     const path = `joints.${j.id}`;
-    /* A row is laid out last, once its part's motion is written: every copy moves on it (a roller row spinning). */
-    if (j.type === 'fixed') {
-        if (j.repeat)
-            repeatPart(asset, j);
-        return;
-    }
-    const kind = j.type === 'prismatic' ? 'slide' : 'turn';
-    const unit = j.type === 'prismatic' ? (j.travel ? 'ratio' : 'mm') : 'deg';
-    const range = j.lowerLimit !== undefined && j.upperLimit !== undefined
-        ? { min: j.lowerLimit, max: j.upperLimit }
-        : j.type === 'revolute'
-            ? { min: -180, max: 180 }
-            : { min: 0, max: 1 };
-    const leaders = figureMimicLeadersOf(j).map(t => ({
-        leader: (asset.joints ?? []).find(o => o.id === t.joint),
-        k: t.multiplier
-    }));
-    /* The axis turned into the parent's frame too: one of its axes, either way along it. */
-    const vector = jointVectorOf(j.axis, path);
-    const along = mv3(back, vector ?? AXES.map(a => (a === j.axis.toLowerCase() ? 1 : 0)));
-    const axisIndex = vector ? 0 : along.findIndex(v => Math.abs(Math.abs(v) - 1) < 1e-9);
-    if (axisIndex < 0)
-        fail('JOINT_SCHEMA', path, `${parent} stands twisted; the axis ${j.axis} is not level with an axis in it`);
-    /* Twelve places, as a twist's factors: the same record writes the same constants however the vector was turned. */
-    const direction = vector
-        ? along.map(v => (Math.abs(v) < 1e-12 ? 0 : Math.round(v * 1e12) / 1e12))
-        : along[axisIndex] > 0
-            ? 1
-            : -1;
-    addMotion(asset, {
-        kind: 'add-motion',
-        part: child,
-        motion: { kind, axis: AXES[axisIndex] },
-        state: {
-            id: stateIdOf(j),
-            unit,
-            min: range.min,
-            max: range.max,
-            start: j.state?.start ?? Math.min(range.max, Math.max(range.min, 0)),
-            ...(j.state?.label !== undefined ? { label: j.state.label } : {}),
-            ...(j.state?.sweep !== undefined ? { sweep: j.state.sweep } : {})
-        },
-        ...(j.travel ? { travel: j.travel } : {}),
-        replace: true
-    }, 
     /*
-      A follower follows how far its leader has gone -- its distance or angle -- not the leader's control: a leader whose
-      stroke is a share of a length has a control of 0..1, and multiplying that gave a follower a number with no length
-      (the telescopic conveyor, 2026-09-25). For a leader whose control is its distance the two are one value.
+      What an axis's value is worked out from comes first, the order axes are carried in after: each keeps its place
+      (`<part>.motion.<k>`), but an axis that follows another of its joint is written once its leader's distance is there
+      -- else it read the leader's control, a share, as millimetres (review 2026-10-24, F3). A leader leads itself, so
+      the axes that lead themselves are written first.
     */
-    j.mimic
-        ? {
-            terms: leaders.map(({ leader, k }) => ({
-                of: nodeById(m, `${leader.body1.part}.motion`)?.args[3] ?? stateIdOf(leader),
-                k
-            })),
-            c: j.mimic.offset ?? 0,
-            sum: Object.hasOwn(j.mimic, 'sum')
-        }
-        : undefined, direction);
+    const order = figureMotionsOf(j)
+        .map((a, k) => ({ a, k }))
+        .sort((x, y) => Number(!!x.a.mimic) - Number(!!y.a.mimic) || x.k - y.k);
+    for (const { a, k } of order) {
+        const at = `${path}.motion.${k}`;
+        const kind = a.type === 'prismatic' ? 'slide' : 'turn';
+        const unit = a.type === 'prismatic' ? (a.travel ? 'ratio' : 'mm') : 'deg';
+        const range = a.lowerLimit !== undefined && a.upperLimit !== undefined
+            ? { min: a.lowerLimit, max: a.upperLimit }
+            : a.type === 'revolute'
+                ? { min: -180, max: 180 }
+                : { min: 0, max: 1 };
+        const leaders = figureMimicLeadersOf(a).map(t => ({ leader: figureAxisOf(asset, t.motion), k: t.multiplier }));
+        /* The axis turned into the parent's frame too: one of its axes, either way along it. */
+        const vector = jointVectorOf(a.axis, at);
+        const along = mv3(back, vector ?? AXES.map(x => (x === a.axis.toLowerCase() ? 1 : 0)));
+        const axisIndex = vector ? 0 : along.findIndex(v => Math.abs(Math.abs(v) - 1) < 1e-9);
+        if (axisIndex < 0)
+            fail('JOINT_SCHEMA', at, `${parent} stands twisted; the axis ${a.axis} is not level with an axis in it`);
+        /* Twelve places, as a twist's factors: the same record writes the same constants however the vector was turned. */
+        const direction = vector
+            ? along.map(v => (Math.abs(v) < 1e-12 ? 0 : Math.round(v * 1e12) / 1e12))
+            : along[axisIndex] > 0
+                ? 1
+                : -1;
+        addMotion(asset, {
+            kind: 'add-motion',
+            part: child,
+            motion: { kind, axis: AXES[axisIndex] },
+            state: {
+                id: motionStateIdOf(a),
+                unit,
+                min: range.min,
+                max: range.max,
+                start: a.state?.start ?? Math.min(range.max, Math.max(range.min, 0)),
+                ...(a.state?.label !== undefined ? { label: a.state.label } : {}),
+                ...(a.state?.sweep !== undefined ? { sweep: a.state.sweep } : {})
+            },
+            ...(a.travel ? { travel: a.travel } : {}),
+            replace: true
+        }, 
+        /*
+          A follower follows how far its leader has gone -- its distance or angle -- not the leader's control: a leader whose
+          stroke is a share of a length has a control of 0..1, and multiplying that gave a follower a number with no length
+          (the telescopic conveyor, 2026-09-25). For a leader whose control is its distance the two are one value.
+        */
+        a.mimic
+            ? {
+                terms: leaders.map(({ leader, k: times }) => ({
+                    of: nodeById(m, motionNodeIdOf(leader.joint.body1.part, leader.k))?.args[3] ?? motionStateIdOf(leader.motion),
+                    k: times
+                })),
+                c: a.mimic.offset ?? 0,
+                sum: Object.hasOwn(a.mimic, 'sum')
+            }
+            : undefined, direction, { k, through: a.through, path: at });
+    }
     if (j.repeat)
         repeatPart(asset, j);
 }
+/** The axis that goes by this id, among the asset's joints. */
+const figureAxisOf = (asset, id) => figureAxesOf(asset.joints).find(a => a.motion.id === id);
 /**
  * A fastened part made a row (r3 §8): its placement becomes the template of a `repeat@1`. The row starts at the
  * parent's lower edge along the axis and runs to its upper edge, so its length is the parent's and follows it; each
@@ -618,9 +662,9 @@ export function stripJoint(asset, j) {
 }
 /**
  * Every length a joint record holds that may follow something, read as a measure, with a way to write it back: the
- * gap, a row's pitch, a slide's travel (its one-term form names the source `source`, and without one is `plus` mm),
- * each offset across the face and each of the joint frame's offset (ADR-0107). Renaming a part and taking one away
- * read and write them all alike.
+ * gap, a row's pitch, each slide's travel (its one-term form names the source `source`, and without one is `plus` mm)
+ * and each axis's point (ADR-0159), each offset across the face and each of the joint frame's offset (ADR-0107).
+ * Renaming a part and taking one away read and write them all alike.
  */
 export function jointMeasures(j) {
     const out = [];
@@ -628,32 +672,37 @@ export function jointMeasures(j) {
         out.push({ at: 'gap', get: () => j.origin.gap, set: v => (j.origin.gap = v) });
     if (j.repeat)
         out.push({ at: 'pitch', get: () => j.repeat.pitch, set: v => (j.repeat.pitch = v) });
-    if (j.travel) {
-        const t = j.travel;
-        out.push({
-            at: 'travel',
-            get: () => Object.hasOwn(t, 'sum')
-                ? { sum: t.sum, ...(t.plus !== undefined ? { plus: t.plus } : {}) }
-                : t.source
-                    ? {
-                        from: t.source,
-                        ...(t.times !== undefined ? { times: t.times } : {}),
-                        ...(t.plus !== undefined ? { plus: t.plus } : {})
-                    }
-                    : (t.plus ?? 0),
-            set: v => {
-                const f = followedTermsOf(v);
-                j.travel = !f
-                    ? { plus: v }
-                    : f.sum
-                        ? { sum: f.terms, ...(f.plus ? { plus: f.plus } : {}) }
-                        : {
-                            source: f.terms[0].from,
-                            ...(f.terms[0].times !== undefined ? { times: f.terms[0].times } : {}),
-                            ...(v.plus !== undefined ? { plus: v.plus } : {})
-                        };
-            }
-        });
+    for (const [k, a] of (j.motion ?? []).entries()) {
+        if (a.travel) {
+            const t = a.travel;
+            out.push({
+                at: `motion.${k}.travel`,
+                get: () => Object.hasOwn(t, 'sum')
+                    ? { sum: t.sum, ...(t.plus !== undefined ? { plus: t.plus } : {}) }
+                    : t.source
+                        ? {
+                            from: t.source,
+                            ...(t.times !== undefined ? { times: t.times } : {}),
+                            ...(t.plus !== undefined ? { plus: t.plus } : {})
+                        }
+                        : (t.plus ?? 0),
+                set: v => {
+                    const f = followedTermsOf(v);
+                    a.travel = !f
+                        ? { plus: v }
+                        : f.sum
+                            ? { sum: f.terms, ...(f.plus ? { plus: f.plus } : {}) }
+                            : {
+                                source: f.terms[0].from,
+                                ...(f.terms[0].times !== undefined ? { times: f.terms[0].times } : {}),
+                                ...(v.plus !== undefined ? { plus: v.plus } : {})
+                            };
+                }
+            });
+        }
+        for (const axis of Object.keys(a.through ?? {}))
+            if (a.through[axis] !== undefined)
+                out.push({ at: `motion.${k}.through.${axis}`, get: () => a.through[axis], set: v => (a.through[axis] = v) });
     }
     for (const axis of Object.keys(j.origin?.align ?? {})) {
         const how = j.origin.align[axis];
@@ -678,17 +727,19 @@ export function mapMeasureSources(measure, to) {
         return { ...measure, sum: f.terms.map(t => ({ ...t, from: to(t.from) })) };
     return { ...measure, from: to(f.terms[0].from) };
 }
-/** Joints in an order each can be written in: its parent's joint and the joints it mimics first. */
+/** Joints in an order each can be written in: its parent's joint and the joints whose axes it mimics first. */
 function writingOrder(joints) {
     const done = new Set();
     const out = [];
     const byChild = new Map(joints.map(j => [j.body1.part, j]));
+    const jointOf = new Map(figureAxesOf(joints).map(a => [a.motion.id, a.joint.id]));
     while (out.length < joints.length) {
         const ready = joints.filter(j => {
             if (done.has(j.id))
                 return false;
             const up = 'part' in j.body0 ? byChild.get(j.body0.part) : undefined;
-            return (!up || done.has(up.id)) && figureMimicLeadersOf(j).every(t => done.has(t.joint));
+            const leaders = figureMotionsOf(j).flatMap(a => figureMimicLeadersOf(a).map(t => jointOf.get(t.motion)));
+            return (!up || done.has(up.id)) && leaders.every(id => id === j.id || done.has(id));
         });
         if (!ready.length)
             fail('JOINT_TREE', 'joints', 'the joints do not make a tree');
@@ -737,10 +788,10 @@ export function rewriteJoints(asset) {
             if (owner && ownInput(m, owner, ref))
                 dropIfUnused(asset, ref, ref);
         }
-        // A joint's value as the author left it (「지금 자세를 기본으로」) is theirs, not the record's.
-        for (const j of order)
-            if (j.type !== 'fixed' && !j.mimic && keep[stateIdOf(j)] !== undefined)
-                asset.stateDefaults[stateIdOf(j)] = keep[stateIdOf(j)];
+        // An axis's value as the author left it (「지금 자세를 기본으로」) is theirs, not the record's.
+        for (const { motion } of figureAxesOf(order))
+            if (!motion.mimic && keep[motionStateIdOf(motion)] !== undefined)
+                asset.stateDefaults[motionStateIdOf(motion)] = keep[motionStateIdOf(motion)];
     });
 }
 export function setJoint(asset, joint) {
@@ -757,9 +808,13 @@ export function setJoint(asset, joint) {
             j.origin = { ...(j.origin ?? {}), childRotate: pose };
     }
     const joints = (asset.joints ?? []).filter(o => o.id !== j.id);
-    const followers = joints.filter(o => figureMimicLeadersOf(o).some(t => t.joint === j.id));
-    if (followers.length && j.type === 'fixed')
-        fail('JOINT_SCHEMA', `joints.${j.id}`, `${followers.map(f => f.id).join(', ')} follow ${j.id}; it cannot stop moving`);
+    /* An axis something follows stays: the joint written again without it would leave its followers following nothing. */
+    const was = (asset.joints ?? []).find(o => o.id === j.id);
+    const staying = new Set(figureMotionsOf(j).map(a => a.id));
+    const going = (was ? figureMotionsOf(was) : []).map(a => a.id).filter(id => !staying.has(id));
+    const followers = followersOf(joints, going);
+    if (followers.length)
+        fail('JOINT_SCHEMA', `joints.${j.id}`, `${followers.map(f => f.id).join(', ')} follow ${going.join(', ')}; ${j.id} cannot stop moving that way`);
     asset.joints = [...joints, j];
     rewriteJoints(asset);
 }
@@ -823,12 +878,14 @@ export function applyFaceRemap(asset, part, remap) {
     }
     remappedFaces.set(asset, faces);
 }
+/** The joints with an axis that follows one of these axes. */
+const followersOf = (joints, axes) => joints.filter(o => figureMotionsOf(o).some(a => figureMimicLeadersOf(a).some(t => axes.includes(t.motion))));
 export function removeJoint(asset, id) {
     const joints = (asset.joints ?? []);
     const j = joints.find(o => o.id === id);
     if (!j)
         fail('EDIT_TARGET', `joints.${id}`, `there is no joint ${id}`);
-    const followers = joints.filter(o => figureMimicLeadersOf(o).some(t => t.joint === id));
+    const followers = followersOf(joints.filter(o => o.id !== id), figureMotionsOf(j).map(a => a.id));
     if (followers.length)
         fail('JOINT_SCHEMA', `joints.${id}`, `${followers.map(f => f.id).join(', ')} follow ${id}; remove them first`);
     const m = asset.document.model;
@@ -863,7 +920,9 @@ export function removeJoint(asset, id) {
  * square to it. Read from the figure as drawn at rest: every joint at 0, its reference pose.
  */
 function childRotateOf(asset, part, body0, parentRotate) {
-    const rest = Object.fromEntries((asset.joints ?? []).filter(j => j.type !== 'fixed' && !j.mimic).map(j => [stateIdOf(j), 0]));
+    const rest = Object.fromEntries(figureAxesOf(asset.joints)
+        .filter(a => !a.motion.mimic)
+        .map(a => [motionStateIdOf(a.motion), 0]));
     const compiled = compileFigureAssetUnjointed(asset);
     /* A control whose range does not hold 0 is read where it stands: its reference is still 0, but it cannot be drawn there. */
     const geometry = (() => {
@@ -929,7 +988,7 @@ export function fastenAsJoint(asset, a, standing = asset) {
     /* Its pose now, in the new parent's frame (ADR-0140 3.6): it is fastened as it stands. */
     const pose = childRotateOf(standing, a.part, body0, was?.origin?.parentRotate);
     setJoint(asset, {
-        ...(was ?? { id, type: 'fixed' }),
+        ...(was ?? { id }),
         body0,
         body1: { part: a.part },
         origin: {