@hatiolab/figure-model 0.4.6 → 0.5.1

package/dist/authoring-actions.js

@@ -21,985 +21,24 @@
  * absent until something makes it move. `<parent>.world` is the parent's own chain, so moving or resizing the
  * parent carries the child with it. A part that is fastened to nothing poses straight into the asset frame.
  */
-import { compileAndSealFigureAsset } from "./asset.js";
+import { upgradeFigurePlacement, compileFigureAssetUnjointed, compileFigureAsset, compileAndSealFigureAsset } from "./asset.js";
 import { settleFigureClips } from "./clip-keeping.js";
-import { compileFigureAsset, compileFigureAssetUnjointed, figurePlacementOf, upgradeFigurePlacement } from "./asset.js";
 import { checkPublicInput, keepPublicInputs } from "./public-inputs.js";
 import { figurePartsExtentOf } from "./gate.js";
-import { compileFigureGraph, figureShapeFaces } from "./graph.js";
+import { compileFigureGraph } from "./graph.js";
 import { figureFollowableAxesOf, figureShapeProviderOf } from "./shape-provider.js";
-import { figureExtrudeLayoutOf, figureLoftLayoutOf, figureShapeDescriptionOf } from "./shape-ops.js";
-import { figureSectionSizeChanges, setFigureCavity, setFigureSectionCorner, setFigureSectionApex, setFigureSectionPoints, remappedFaces } from "./shape-edit.js";
+import { setFigureSectionCorner, setFigureCavity, setFigureSectionPoints, setFigureSectionApex, figureSectionSizeChanges } from "./shape-edit.js";
 import { figureSizeEditChanges } from "./size-edit.js";
-import { FigureContractError } from "./contract.js";
-import { figureSlotPlacesOf } from "./slot-places.js";
-import { persistenceIssues, validateSlotLayout } from "./slot-layout.js";
-import { AXES, REPEAT_LIMIT, isDetailLevel } from "./words.js";
-import { defaultInstanceSizeRange, foldInstanceSizeRange, figureInstanceSizeLimitsOf, FIGURE_INSTANCE_SIZE_DEFAULT, FIGURE_INSTANCE_SIZE_INPUTS } from "./instance-size.js";
-import { FIGURE_PLACEMENTS } from "./asset-types.js";
+import { isDetailLevel, AXES } from "./words.js";
+import { defaultInstanceSizeRange, foldInstanceSizeRange, figureInstanceSizeLimitsOf, FIGURE_INSTANCE_SIZE_INPUTS } from "./instance-size.js";
 import { carrierDeclarationOf } from "./carrier.js";
-const fail = (code, path, message) => {
-    throw new FigureContractError(code, path, message);
-};
-/** The six faces of a box-shaped part, and the axis each one faces along. */
-export const FIGURE_FACES = { left: 'x', right: 'x', bottom: 'y', top: 'y', back: 'z', front: 'z' };
-/**
- * UsdPhysics's joint types (ADR-0093, amended 2026-09-25: the joint follows USD). A `fixed` joint is a fastening; a
- * `revolute` joint turns -- with no limits it turns without end, its value a phase (-180..180), as USD's revolute
- * joint without limits does; a `prismatic` joint slides.
- */
-export const FIGURE_JOINT_TYPES = ['fixed', 'revolute', 'prismatic'];
-const SIGN = { left: -1, right: 1, bottom: -1, top: 1, back: -1, front: 1 };
-const OPPOSITE = { left: 'right', right: 'left', bottom: 'top', top: 'bottom', back: 'front', front: 'back' };
-/** The joints a follower follows, each with its multiplier: one for a one-leader mimic, none for a joint that leads itself. */
-export function figureMimicLeadersOf(j) {
-    const mimic = j.mimic;
-    if (!mimic || typeof mimic !== 'object')
-        return [];
-    if (Object.hasOwn(mimic, 'sum'))
-        return Array.isArray(mimic.sum) ? mimic.sum : [];
-    return [{ joint: mimic.joint, multiplier: mimic.multiplier }];
-}
-/** Whether a length is written as something to follow: one source, or a sum of one term or more, each with a source. */
-const followsSomething = (measure) => {
-    const terms = followedTermsOf(measure)?.terms;
-    return Array.isArray(terms) && terms.length > 0 && terms.every(t => !!t?.from);
-};
-/** A length that follows something, as its terms and its margin; undefined for a number (or nothing). */
-function followedTermsOf(measure) {
-    if (!measure || typeof measure !== 'object')
-        return undefined;
-    if (Object.hasOwn(measure, 'sum')) {
-        const m = measure;
-        return { terms: m.sum, plus: m.plus ?? 0, sum: true };
-    }
-    const m = measure;
-    return { terms: [{ from: m.from, ...(m.times !== undefined ? { times: m.times } : {}) }], plus: m.plus ?? 0, sum: false };
-}
-const everyKey = () => (...keys) => keys;
-const JOINT_FIELDS = {
-    joint: everyKey()('id', 'type', 'body0', 'body1', 'origin', 'axis', 'lowerLimit', 'upperLimit', 'travel', 'state', 'mimic', 'repeat'),
-    body0: everyKey()('part', 'face', 'plane'),
-    body1: everyKey()('part', 'face'),
-    origin: everyKey()('facing', 'gap', 'align', 'turn', 'twist'),
-    axes: everyKey()('x', 'y', 'z'),
-    alignment: everyKey()('mm'),
-    measure: everyKey()('from', 'times', 'plus', 'sum'),
-    term: everyKey()('from', 'times'),
-    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'),
-    repeat: everyKey()('axis', 'pitch', 'count', 'rise'),
-    rise: everyKey()('axis', 'mm')
-};
-/** Refuses, by name, a key of a joint record or of an object in it that this kernel does not know. A key left undefined is no field. */
-function knownJointFields(j, path) {
-    const only = (o, allowed, at) => {
-        if (!o || typeof o !== 'object' || Array.isArray(o))
-            return;
-        for (const [k, v] of Object.entries(o))
-            if (v !== undefined && !allowed.includes(k))
-                fail('JOINT_SCHEMA', at, `${k} is a field this kernel does not know`);
-    };
-    const source = (s, at) => only(s, JOINT_FIELDS.source, at);
-    const measure = (m, at) => {
-        if (!m || typeof m !== 'object')
-            return;
-        only(m, JOINT_FIELDS.measure, at);
-        source(m.from, `${at}.from`);
-        if (Array.isArray(m.sum))
-            for (const [i, t] of m.sum.entries()) {
-                only(t, JOINT_FIELDS.term, `${at}.sum.${i}`);
-                source(t?.from, `${at}.sum.${i}.from`);
-            }
-    };
-    only(j, JOINT_FIELDS.joint, path);
-    only(j.body0, JOINT_FIELDS.body0, `${path}.body0`);
-    only(j.body1, JOINT_FIELDS.body1, `${path}.body1`);
-    const o = j.origin;
-    only(o, JOINT_FIELDS.origin, `${path}.origin`);
-    if (o && typeof o === 'object') {
-        measure(o.gap, `${path}.origin.gap`);
-        only(o.turn, JOINT_FIELDS.axes, `${path}.origin.turn`);
-        only(o.align, JOINT_FIELDS.axes, `${path}.origin.align`);
-        for (const [axis, a] of Object.entries(o.align && typeof o.align === 'object' ? o.align : {})) {
-            only(a, JOINT_FIELDS.alignment, `${path}.origin.align.${axis}`);
-            measure(a?.mm, `${path}.origin.align.${axis}.mm`);
-        }
-    }
-    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`);
-    }
-    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`);
-        only(j.repeat.rise, JOINT_FIELDS.rise, `${path}.repeat.rise`);
-    }
-}
-const clone = (asset) => structuredClone(asset);
-const nodeById = (m, id) => m.nodes.find((n) => n.id === id);
-const writerOf = (m, ref) => m.nodes.find((n) => Object.values(n.outputs).includes(ref));
-/** A part an authoring command can work with, and the pieces of it those commands need. */
-/** The part whose row carries this one -- fastened to it, however far down -- or undefined. */
-function rowHolding(m, id) {
-    const place = nodeById(m, id);
-    if (place?.op !== 'member@1' || nodeById(m, `${id}.repeat`))
-        return undefined;
-    const assembly = m.nodes.find((n) => n.op === 'assembly@1' && n.args.includes(place.outputs.placed));
-    return assembly ? String(assembly.id).replace(/\.assembly$/, '') : undefined;
-}
-function partOf(m, id, path) {
-    const place = nodeById(m, id);
-    /* A row's template is the part too: it is placed through its row (`repeatPart`). */
-    const rowTemplate = place?.op === 'member@1' && (!!nodeById(m, `${id}.repeat`) || rowHolding(m, id) !== undefined);
-    if (!place || (place.op !== 'place@1' && !rowTemplate))
-        fail('TARGET_ABSENT', path, `${id} is not a placed part`);
-    const shape = writerOf(m, place.args[0]);
-    if (!shape)
-        fail('TARGET_ABSENT', path, `${id} has no shape`);
-    const pose = nodeById(m, `${id}.pose`);
-    if (!pose || pose.op !== 'rigid@1')
-        fail('EDIT_TARGET', path, `${id} is not posed by a rigid@1 this command can read`);
-    return { place, shape, pose };
-}
-const isReach = (e) => !Array.isArray(e);
-/** A drawn section's points (and a pyramid's apex) along one plane axis, as graph values. */
-function drawnOffsetsOf(shape, axis) {
-    const L = shape.op === 'loft@1' ? figureLoftLayoutOf(shape.params, shape.id) : figureExtrudeLayoutOf(shape.params, shape.id);
-    const at = Object.values(L.arg.point ?? {}).map(p => p[axis]).filter(i => i !== undefined);
-    const apex = L.apex?.[axis];
-    return [...at, ...(apex !== undefined ? [apex] : [])].map(i => ({ ref: shape.args[i], k: 1 }));
-}
-function sizeRefsOf(m, id, path) {
-    const { shape } = partOf(m, id, path);
-    /* A shape operation says itself which argument is each axis's measure (ADR-0100). */
-    const described = figureShapeDescriptionOf(shape);
-    if (described) {
-        const out = {};
-        for (const axis of AXES) {
-            const e = described.edit[axis];
-            if ('refused' in e)
-                return fail('EDIT_TARGET', path, `${id} is a drawn section; its reach across is its points, not a measure this command can read`);
-            out[axis] = { ref: shape.args[e.arg], k: e.k };
-        }
-        return out;
-    }
-    return fail('EDIT_TARGET', path, `${id} is a ${shape.op}; it is not a shape this command can measure`);
-}
-/**
- * What a part takes up along each of its own axes, as candidates whose largest is the answer. A taper is as wide as
- * the larger of its two ends, and which end that is changes when a radius follows a size -- so both are candidates, and
- * the room's bounds take the larger when the graph is evaluated (G5, chief architect 2026-09-26). Every other part
- * has one candidate: its size.
- */
-function occupiedExtentsOf(m, id, path, single = false) {
-    const { shape } = partOf(m, id, path);
-    const described = figureShapeDescriptionOf(shape);
-    if (described && !single) {
-        const out = {};
-        for (const axis of AXES) {
-            const terms = described.measure[axis];
-            /* A drawn section across its plane: its points, which need not sit about its origin (a wedge drawn off centre). */
-            if (terms === 'profile')
-                out[axis] = { offsets: drawnOffsetsOf(shape, axis) };
-            else
-                out[axis] = terms.map(t => ({ ref: shape.args[t.arg], k: t.k }));
-        }
-        return out;
-    }
-    const own = sizeRefsOf(m, id, path);
-    return { x: [own.x], y: [own.y], z: [own.z] };
-}
-/** The angle a pose argument holds, whether it is a constant or a design input, or null when it is neither. */
-function angleOf(m, asset, ref) {
-    const constant = m.constants.find((c) => c.id === ref);
-    if (constant)
-        return constant.value;
-    const input = m.inputs.find((i) => i.id === ref);
-    if (input && input.role !== 'state')
-        return asset.designInputs[ref] ?? null;
-    return null;
-}
-/** The turn in a part's pose, in degrees about X, Y and Z, or null for an axis whose turn is neither a number nor a design value. */
-function turnOf(m, asset, id, path) {
-    return partOf(m, id, path).pose.args.slice(3, 6).map((ref) => angleOf(m, asset, ref));
-}
-const saidTurn = (turn) => AXES.map((a, i) => `${a.toUpperCase()} ${turn[i] ?? '?'}°`).join(', ');
-/** A part with no turn in its pose: a face of a turned body is not the plane this command assumes. */
-function requireUnturned(m, asset, id, path) {
-    const turn = turnOf(m, asset, id, path);
-    if (turn.some(t => t !== 0))
-        fail('EDIT_TARGET', path, `${id} is turned (${saidTurn(turn)}); fastening to a turned part by its faces is not covered by this command`);
-}
-/**
- * The part's size along each axis as it stands in its seat -- after its own turn. A turn by a whole number of
- * quarter turns only swaps the axes (a cylinder laid on its side is 2r tall and its length deep), so its faces are
- * still axis-aligned planes; any other turn is refused, and says the angle. The turn is then fixed as it is: a part
- * fastened by its faces keeps the turn its faces were measured in (chief architect's ruling 2026-09-25).
- */
-/**
- * The part's own turn as a signed axis permutation, when it is a whole number of quarter turns; any other turn is
- * refused and says the angle. With `freeze` the turn is fixed as it is: a part fastened by its faces keeps the turn
- * its faces were measured in (chief architect's ruling 2026-09-25).
- */
-function quarterTurnOf(m, asset, id, path, freeze) {
-    const turn = turnOf(m, asset, id, path);
-    if (turn.every(t => t === 0))
-        return [[1, 0, 0], [0, 1, 0], [0, 0, 1]];
-    if (turn.some(t => t === null || !Number.isFinite(t) || Math.abs(t / 90 - Math.round(t / 90)) > 1e-9))
-        fail('EDIT_TARGET', path, `${id} is turned (${saidTurn(turn)}); only quarter turns keep its faces level with the axes`);
-    const r = turnMatrix(turn);
-    if (freeze) {
-        const pose = partOf(m, id, path).pose;
-        const old = pose.args.slice(3, 6);
-        pose.args = [...pose.args.slice(0, 3), ...turn.map(t => constantOf(m, 'deg', t, 'a'))];
-        // Its turn fields go with it: typing into them would change nothing.
-        for (const ref of old)
-            dropIfUnused(asset, ref, ownInput(m, id, ref) ? ref : undefined);
-    }
-    return r;
-}
-/** A quarter turn in degrees about X, Y and Z as `rigid@1` turns (X, then Y, then Z), as a signed axis permutation. */
-function turnMatrix(turn) {
-    const [rx, ry, rz] = turn.map(t => (t * Math.PI) / 180);
-    const cos = (a) => Math.round(Math.cos(a)), sin = (a) => Math.round(Math.sin(a));
-    const X = [[1, 0, 0], [0, cos(rx), -sin(rx)], [0, sin(rx), cos(rx)]];
-    const Y = [[cos(ry), 0, sin(ry)], [0, 1, 0], [-sin(ry), 0, cos(ry)]];
-    const Z = [[cos(rz), -sin(rz), 0], [sin(rz), cos(rz), 0], [0, 0, 1]];
-    return mul3(mul3(X, Y), Z);
-}
-const mul3 = (a, b) => a.map(row => b[0].map((_, j) => row.reduce((sum, v, k) => sum + v * b[k][j], 0)));
-function standingRefsOf(m, asset, id, path, freeze = true) {
-    const own = sizeRefsOf(m, id, path);
-    const r = quarterTurnOf(m, asset, id, path, freeze);
-    const standing = {};
-    AXES.forEach((axis, i) => (standing[axis] = own[AXES[r[i].findIndex(v => v !== 0)]]));
-    return standing;
-}
-const neg = (lin) => lin.map(t => ({ ref: t.ref, k: -t.k }));
-const half = (lin) => lin.map(t => ({ ref: t.ref, k: t.k / 2 }));
-const OUTER = { x: ['left', 'right'], y: ['bottom', 'top'], z: ['back', 'front'] };
-/** A part's declared faces, from its shape's own definition, or a refusal saying the shape has none. */
-function facesOfPart(m, id, path) {
-    const { shape } = partOf(m, id, path);
-    /* With the graph: a centred push's ends are ±half its length, the planes fastenings have always been made from. */
-    const faces = figureShapeFaces(shape, m);
-    if (!faces)
-        fail('EDIT_TARGET', path, `${id} is a ${shape.op}; it has no flat face to fasten by`);
-    return { shape, faces: faces };
-}
-/**
- * The face a joint's child is measured by: its own, or for `centre` the face that would meet the parent's -- the part is
- * measured and turned as that face, and only where its middle sits differs (\`attach\`).
- */
-function childFaceOf(m, j) {
-    if (j.body1.face !== 'centre')
-        return j.body1.face;
-    const path = `joints.${j.id}.body1.face`;
-    if (!('part' in j.body0))
-        fail('JOINT_SCHEMA', path, 'a part stands on the mounting plane by a face of its own, not by its centre');
-    /* One of the six, in the record's words: the face across from it. An opening's face, read from the parent's shape. */
-    const named = j.body0.face;
-    if (Object.hasOwn(FIGURE_FACES, named))
-        return Object.keys(FIGURE_FACES).find(f => FIGURE_FACES[f] === FIGURE_FACES[named] && SIGN[f] === -SIGN[named]);
-    const theirs = facesOfPart(m, j.body0.part, path).faces[j.body0.face];
-    if (!theirs)
-        fail('JOINT_SCHEMA', path, `${j.body0.part} has no face ${j.body0.face}`);
-    return Object.keys(FIGURE_FACES).find(f => FIGURE_FACES[f] === theirs.axis && SIGN[f] === -theirs.normal);
-}
-const planeOf = (shape, face) => face.plane.map(p => ({ ref: shape.args[p.arg], k: p.k }));
-/** The part's outer faces on each axis in its own frame; an axis without a pair of flat faces has none. */
-function ownSpansOf(m, id, path) {
-    const { shape, faces } = facesOfPart(m, id, path);
-    const spans = {};
-    const measure = figureShapeDescriptionOf(shape, m).measure;
-    for (const axis of AXES) {
-        const [lo, hi] = OUTER[axis].map(n => faces[n]);
-        /* One face on an axis and a measure along it (a pyramid's base): the span's other end is the face plus the measure. */
-        const reach = measure[axis];
-        const along = reach && reach !== 'profile' ? planeOf(shape, { axis, normal: 1, plane: reach }) : undefined;
-        if (!lo && !hi)
-            continue;
-        if ((!lo || !hi) && !along)
-            continue;
-        const l = lo ? planeOf(shape, lo) : [...planeOf(shape, hi), ...neg(along)], h = hi ? planeOf(shape, hi) : [...planeOf(shape, lo), ...along];
-        spans[axis] = { lo: l, hi: h, centred: JSON.stringify(l) === JSON.stringify(neg(h)) };
-    }
-    return spans;
-}
-/**
- * The part's spans as it stands in its seat, after its own quarter turn (the turn is fixed as `standingRefsOf` fixes
- * it). A turn that flips an axis swaps its two faces: the part's own right face becomes the standing left.
- */
-function standingSpansOf(m, asset, id, path) {
-    const own = ownSpansOf(m, id, path);
-    const r = quarterTurnOf(m, asset, id, path, true);
-    const standing = {};
-    AXES.forEach((axis, i) => {
-        const j = r[i].findIndex(v => v !== 0);
-        const span = own[AXES[j]];
-        if (!span)
-            return;
-        standing[axis] = r[i][j] > 0 ? span : { lo: neg(span.hi), hi: neg(span.lo), centred: span.centred };
-    });
-    return standing;
-}
-/** Fresh node ids under a part, so two commands never claim one id. */
-function namer(m, prefix) {
-    const taken = new Set([...m.nodes.map((n) => n.id), ...m.nodes.flatMap((n) => Object.values(n.outputs)), ...m.constants.map((c) => c.id), ...m.inputs.map((i) => i.id)]);
-    return (hint) => {
-        let id = `${prefix}.${hint}`;
-        for (let k = 2; taken.has(id) || taken.has(`${id}.value`); k++)
-            id = `${prefix}.${hint}.${k}`;
-        taken.add(id);
-        taken.add(`${id}.value`);
-        return id;
-    };
-}
-/** A constant, reusing one that already holds the same number in the same unit. */
-function constantOf(m, unit, value, hint) {
-    const found = m.constants.find((c) => c.unit === unit && c.value === value);
-    if (found)
-        return found.id;
-    const id = `${hint}.${unit}.${String(value).replace(/[^0-9a-zA-Z]/g, '_')}`;
-    m.constants.push({ id, unit, value });
-    return id;
-}
-/** value = ref × times + plus, written as nodes, and folded away when there is nothing to do. */
-function scaled(m, name, ref, times, plus, hint) {
-    let out = ref;
-    if (times !== 1) {
-        const id = name(`${hint}.times`);
-        m.nodes.push({ id, op: 'mul@1', args: [out, constantOf(m, 'ratio', times, 'k')], outputs: { value: `${id}.value` } });
-        out = `${id}.value`;
-    }
-    if (plus !== 0) {
-        const id = name(`${hint}.plus`);
-        m.nodes.push({ id, op: 'add@1', args: [out, constantOf(m, 'mm', plus, 'd')], outputs: { value: `${id}.value` } });
-        out = `${id}.value`;
-    }
-    return out;
-}
-/** A measure as one graph reference: a constant, or the source it follows times a multiple plus a margin. */
-function measureRef(m, asset, name, measure, hint, path) {
-    if (measure === undefined)
-        return constantOf(m, 'mm', 0, 'd');
-    if (typeof measure === 'number') {
-        if (!Number.isFinite(measure))
-            fail('SCHEMA', path, 'a finite length is required');
-        return constantOf(m, 'mm', measure, 'd');
-    }
-    if (!measure || typeof measure !== 'object' || !(Object.hasOwn(measure, 'sum') || measure.from))
-        fail('SCHEMA', path, 'a length is a number of millimetres, or something to follow');
-    const { terms, plus, sum } = followedTermsOf(measure);
-    const refs = termRefs(m, asset, terms, plus, path);
-    /* One term is written as it always was; a sum adds its terms, then the margin (the same add@1 and mul@1 nodes). */
-    if (!sum)
-        return scaled(m, name, refs[0].ref, refs[0].k, plus, hint);
-    return scaled(m, name, sumOf(m, name, refs, `${hint}.sum`), 1, plus, hint);
-}
-/** Each term of a followed length as a graph reference and its multiple, every one checked as a one-term length is. */
-function termRefs(m, asset, terms, plus, path) {
-    if (!Array.isArray(terms) || !terms.length)
-        fail('SCHEMA', path, 'a sum has one term or more');
-    if (!Number.isFinite(plus))
-        fail('SCHEMA', path, 'finite times and plus required');
-    return terms.map((t, i) => {
-        const at = terms.length > 1 ? `${path}.sum.${i}` : path;
-        if (!t || typeof t !== 'object' || !t.from)
-            fail('SCHEMA', at, 'a length is a number of millimetres, or something to follow');
-        if (!Number.isFinite(t.times ?? 1))
-            fail('SCHEMA', at, 'finite times and plus required');
-        return { ref: sourceRef(m, asset, t.from, at), k: t.times ?? 1 };
-    });
-}
-/** Σ k·ref, written as nodes, with nothing emitted for a weight of zero and no node for a single term. */
-function sumOf(m, name, terms, hint) {
-    const live = terms.filter(t => t.k !== 0);
-    if (!live.length)
-        return constantOf(m, 'mm', 0, 'd');
-    let out = '';
-    for (const [i, t] of live.entries()) {
-        const piece = scaled(m, name, t.ref, t.k, 0, `${hint}.${i}`);
-        if (!out)
-            out = piece;
-        else {
-            const id = name(`${hint}.${i}.sum`);
-            m.nodes.push({ id, op: 'add@1', args: [out, piece], outputs: { value: `${id}.value` } });
-            out = `${id}.value`;
-        }
-    }
-    return out;
-}
-/** The size one axis reads once the figure grows by one ratio: u times its authored size (`scaleUniformly`). */
-function uniformSizeOf(m, axis, path) {
-    const node = nodeById(m, `sizing.size.${axis}`);
-    if (!node)
-        fail('TARGET_ABSENT', path, `the figure grows by one ratio but has no sizing.size.${axis}`);
-    return node.outputs.value;
-}
-function sourceRef(m, asset, source, path) {
-    if (!source || typeof source !== 'object')
-        fail('SCHEMA', path, 'a dimension source is required');
-    if (source.of === 'instance') {
-        const id = `size.${source.axis}`;
-        if (!m.inputs.some((i) => i.id === id))
-            fail('TARGET_ABSENT', path, `the instance has no ${id}; declare it before following it`);
-        /* A figure that grows by one ratio is read at that ratio's size: a link made after it had read the raw size. */
-        return asset.sizing === 'uniform' ? uniformSizeOf(m, source.axis, path) : id;
-    }
-    if (source.of === 'input') {
-        const input = m.inputs.find((i) => i.id === source.input);
-        if (!input)
-            fail('TARGET_ABSENT', path, `${source.input} is not an input of this asset`);
-        if (input.role === 'state')
-            fail('EDIT_TARGET', path, `${source.input} is a state input; a dimension that follows state is a different declaration`);
-        return source.input;
-    }
-    if (source.of === 'part')
-        return stableDimension(m, source.part, source.axis, path);
-    return fail('SCHEMA', path, `${String(source.of)} is not a dimension source`);
-}
-/**
- * The name of a part's dimension, which stays the same name however that dimension is later worked out.
- *
- * "B is as wide as A" has to keep meaning that when A is told to follow something else. Reading A's shape
- * argument at the moment of linking gave B whatever A happened to read then — A's own control — so relinking A
- * left B on the old value (designer's counterexample 2026-09-23: A went to 300 and B stayed at 100). Every
- * dimension a command touches gets a node of its own, `<part>.dimension.<axis>`, and that is what the shape
- * reads and what anything following it reads. Relinking rewrites what that node computes, and everyone pointing
- * at it comes along — fastenings included, since they measure the same references.
- */
-function stableDimension(m, part, axis, path) {
-    const shape = partOf(m, part, path).shape;
-    const described = figureShapeDescriptionOf(shape);
-    if (described) {
-        const e = described.edit[axis];
-        if ('refused' in e)
-            return fail('EDIT_TARGET', path, `${part} is a drawn section; its measures are its points, which no measure can follow`);
-        /* An axis whose argument is another axis's value (a circle's two radii) is that axis's dimension. */
-        if (e.sameAs)
-            return stableDimension(m, part, e.sameAs, path);
-        const id = `${part}.dimension.${axis}`;
-        const ref = `${id}.value`;
-        if (nodeById(m, id))
-            return ref;
-        const was = shape.args[e.arg];
-        const one = constantOf(m, 'ratio', 1, 'k');
-        m.nodes.push({ id, op: 'mul@1', args: [was, one], outputs: { value: ref } });
-        /* Every argument that is this value goes with it, and so does a start written from this length (a centred push). */
-        shape.args = shape.args.map((r) => (r === was ? ref : r));
-        const start = nodeById(m, `${part}.start`);
-        if (start)
-            start.args = start.args.map((r) => (r === was ? ref : r));
-        return ref;
-    }
-    return fail('EDIT_TARGET', path, `${part} is a ${shape.op}; it is not a shape with measures`);
-}
-/** What a part's dimension is worked out from right now: the first argument of its own dimension node. */
-const dimensionSource = (m, part, axis) => nodeById(m, `${part}.dimension.${axis}`)?.args?.[0];
-/** Whether this side of the part already follows something, rather than reading its own control. */
-/**
- * A part's own number for a dimension: a design input named under the part. `addFigureBox` names it `<part>.size.<axis>`,
- * the editor's shape palette `<part>.dimension.width` (and height, depth); both are the part's own, and a dimension
- * read from one follows nothing. Reading only the first name made a palette box look linked as soon as any command
- * had routed its dimension, and a link was refused as a replacement (2026-09-24, :3300).
- */
-const ownInput = (m, part, ref) => !!ref && ref.startsWith(`${part}.`) && m.inputs.some((i) => i.id === ref && i.role === 'design');
-const followsAlready = (m, part, axis) => {
-    const from = dimensionSource(m, part, axis);
-    return from !== undefined && !ownInput(m, part, from);
-};
-function linkDimension(asset, a) {
-    const m = asset.document.model;
-    const path = `${a.part}.${a.axis}`;
-    const mine = stableDimension(m, a.part, a.axis, path);
-    if (followsAlready(m, a.part, a.axis) && !a.replace)
-        fail('DIMENSION_LINKED', path, `${a.part}'s ${a.axis} already follows something; pass replace to change what it follows, or unlink it first`);
-    const sum = Object.hasOwn(a, 'sum');
-    const terms = sum ? a.sum : [{ from: a.source, ...(a.times !== undefined ? { times: a.times } : {}) }];
-    const plus = a.plus ?? 0;
-    /* Each term is checked for a loop as a one-term link is: none may read the measure it would set. */
-    for (const t of Array.isArray(terms) ? terms : [])
-        if (t?.from?.of === 'part' && t.from.part === a.part && t.from.axis === a.axis)
-            fail('DIMENSION_CYCLE', path, `${a.part}'s ${a.axis} cannot follow itself`);
-    const refs = termRefs(m, asset, terms, plus, path);
-    for (const [i, { ref }] of refs.entries()) {
-        const source = terms[i].from;
-        if (ref === mine)
-            fail('DIMENSION_CYCLE', path, `${a.part}'s ${a.axis} cannot follow itself`);
-        if (reaches(m, ref, mine))
-            fail('DIMENSION_CYCLE', path, `${String(source.of === 'part' ? source.part : source.of)} already follows ${a.part}'s ${a.axis}`);
-    }
-    const name = namer(m, `${a.part}.${a.axis}`);
-    const value = sum ? scaled(m, name, sumOf(m, name, refs, 'follows.sum'), 1, plus, 'follows') : scaled(m, name, refs[0].ref, refs[0].k, plus, 'follows');
-    const node = nodeById(m, `${a.part}.dimension.${a.axis}`);
-    const was = node.args[0];
-    const owned = ownInput(m, a.part, was) ? was : `${a.part}.size.${a.axis}`;
-    node.args = [value, node.args[1]];
-    // Joints read this part's size; made again from their records, they read the size as it now is.
-    if (asset.joints?.length)
-        rewriteJoints(asset);
-    // The part's own control is no longer read by anything; leaving it would show a dial that changes nothing.
-    dropIfUnused(asset, was, owned);
-    return asset;
-}
-/** Whether one value is worked out from another, so a link cannot be made to close a loop. */
-function reaches(m, from, target, seen = new Set()) {
-    if (from === target)
-        return true;
-    if (seen.has(from))
-        return false;
-    seen.add(from);
-    const writer = writerOf(m, from);
-    return !!writer && writer.args.some((ref) => reaches(m, ref, target, seen));
-}
-function unlinkDimension(asset, a) {
-    const m = asset.document.model;
-    const path = `${a.part}.${a.axis}`;
-    if (!(Number.isFinite(a.mm) && a.mm > 0))
-        fail('GEOMETRY_DOMAIN', path, 'a positive length is required');
-    stableDimension(m, a.part, a.axis, path);
-    if (!followsAlready(m, a.part, a.axis))
-        fail('EDIT_TARGET', path, `${a.part}'s ${a.axis} does not follow anything`);
-    const id = `${a.part}.size.${a.axis}`;
-    /*
-      The part's own field may still be there: the declared room was measured from it and still reads it, so it stayed
-      when the measure began to follow (ADR-0097). Setting the measure back to fixed takes that field back -- it is the
-      part's own number -- rather than refusing (found 2026-09-27: 「고정으로 되돌리기」 failed on any figure with a room).
-      Only a field of the part's own kind: anything else by that name is refused as before.
-    */
-    const kept = m.inputs.find((i) => i.id === id);
-    if (kept && !(kept.role === 'design' && kept.unit === 'mm'))
-        fail('DUPLICATE_WRITER', path, `${id} already exists`);
-    if (!kept)
-        m.inputs.push({ id, unit: 'mm', min: Number.MIN_VALUE, max: Number.MAX_VALUE, role: 'design' });
-    asset.designInputs[id] = a.mm;
-    const node = nodeById(m, `${a.part}.dimension.${a.axis}`);
-    const was = node.args[0];
-    node.args = [id, node.args[1]];
-    if (asset.joints?.length)
-        rewriteJoints(asset);
-    dropIfUnused(asset, was);
-    return asset;
-}
-/**
- * Remove a value nothing reads any more, and whatever fed only it. An input is removed only when it is the one
- * this command owns — the part's own dimension control. A shared input, such as the instance's size, stays even
- * when the command that stopped reading it was the last reader: it is the author's, not this command's.
- */
-function dropIfUnused(asset, ref, ownedInput) {
-    const m = asset.document.model;
-    /* The graph, the declared room, the face it is mounted on and the places things are held all read values. */
-    // Joint records are consumers too. Their generated nodes are temporarily removed
-    // during a rewrite; alignment inputs must survive until those nodes are rebuilt.
-    const declared = new Set([...stringsIn(asset.occupancy), ...stringsIn(asset.document.capabilities), ...stringsIn(asset.joints)]);
-    const referenced = (r) => m.nodes.some((n) => n.args.includes(r) || Object.values(n.params ?? {}).includes(r)) || declared.has(r);
-    if (referenced(ref))
-        return;
-    const input = m.inputs.findIndex((i) => i.id === ref);
-    if (input >= 0) {
-        if (ref !== ownedInput)
-            return;
-        m.inputs.splice(input, 1);
-        delete asset.designInputs[ref];
-        delete asset.stateDefaults[ref];
-        return;
-    }
-    const writer = writerOf(m, ref);
-    if (!writer || writer.op === 'place@1' || Object.values(writer.outputs).some((r) => r !== ref && referenced(r)))
-        return;
-    m.nodes = m.nodes.filter((n) => n !== writer);
-    for (const arg of writer.args)
-        dropIfUnused(asset, arg);
-}
-/** Which part each part is fastened to, read from the frames rather than from a second record of it. */
-function parentOf(m, id) {
-    /* A row's template has no chain of its own -- its copies are composed by the row -- but it is fastened all the same. */
-    if (!nodeById(m, `${id}.chain`) && !nodeById(m, `${id}.repeat`))
-        return null;
-    // The seat rigid carries the part into the frame it is fastened to, moving or not (an old asset may have only a motion).
-    const above = nodeById(m, `${id}.seat.rigid`) ?? nodeById(m, `${id}.motion`);
-    const match = /^(.*)\.local$/.exec(String(above?.params?.to));
-    return match && match[1] !== id ? match[1] : null;
-}
-function attach(asset, a, twist) {
-    const m = asset.document.model;
-    const to = a.to;
-    const path = `${a.part} to ${to?.plane ?? to?.part}`;
-    if (!to || typeof to !== 'object')
-        fail('SCHEMA', path, 'a target face, or the plane the figure is mounted on, is required');
-    if (to.plane !== undefined)
-        return standOnPlane(asset, a, path);
-    if (a.part === to.part)
-        fail('ATTACH_CYCLE', path, 'a part cannot be fastened to itself');
-    const byCentre = a.face === 'centre';
-    if (!byCentre && !Object.hasOwn(FIGURE_FACES, String(a.face)))
-        fail('SCHEMA', path, `${String(a.face)} is not a face`);
-    /* The target's faces are the ones its shape declares: a portal's opening as well as its outer faces. */
-    const target = facesOfPart(m, to.part, path);
-    const theirFace = Object.hasOwn(target.faces, String(to.face)) ? target.faces[to.face] : undefined;
-    if (!theirFace)
-        fail('SCHEMA', path, `${to.part} has no face ${String(to.face)}; it has ${Object.keys(target.faces).join(', ')}`);
-    const facing = a.facing ?? 'meet';
-    if (facing !== 'meet' && facing !== 'flush')
-        fail('SCHEMA', path, `${String(facing)} is neither meet nor flush`);
-    const axis = theirFace.axis;
-    const sign = theirFace.normal;
-    if (byCentre && facing !== 'meet')
-        fail('ATTACH_FACE', path, `${a.part} fastened by its centre sits on ${to.face}; flush has no meaning for a centre`);
-    /* By its centre, the part is measured as the face that would meet the target's; only its offset differs. */
-    if (byCentre)
-        a = { ...a, face: Object.keys(FIGURE_FACES).find(f => FIGURE_FACES[f] === axis && SIGN[f] === -sign) };
-    if (FIGURE_FACES[a.face] !== axis)
-        fail('ATTACH_FACE', path, `${a.face} faces along ${FIGURE_FACES[a.face]} and ${to.face} along ${axis}; fastening them would need a turn, which this command does not do`);
-    const wanted = Object.keys(FIGURE_FACES).find(f => FIGURE_FACES[f] === axis && SIGN[f] === (facing === 'meet' ? -sign : sign));
-    if (facing === 'meet' && a.face !== wanted)
-        fail('ATTACH_FACE', path, `to meet ${to.face}, ${a.part} offers its ${wanted}; pass flush to lay ${a.face} in the same plane instead`);
-    if (facing === 'flush' && a.face !== wanted)
-        fail('ATTACH_FACE', path, `to lie flush with ${to.face}, ${a.part} offers its ${wanted}`);
-    if (parentOf(m, a.part) && !a.replace)
-        fail('ATTACH_REPLACED', path, `${a.part} is already fastened to ${parentOf(m, a.part)}; pass replace to move it, or detach it first`);
-    // A part cannot end up its own ancestor.
-    for (let up = to.part; up; up = parentOf(m, up))
-        if (up === a.part)
-            fail('ATTACH_CYCLE', path, `${to.part} already hangs from ${a.part}`);
-    /*
-      Measured in the target's own frame, where its faces are the planes its shape declares: the seat is written into
-      that frame. A target standing turned is met there too -- the joint record's words are turned into that frame
-      before this runs (`writeJoint`).
-    */
-    const theirs = ownSpansOf(m, to.part, path);
-    const mine = standingSpansOf(m, asset, a.part, path);
-    const mineAlong = mine[axis];
-    if ((!mineAlong || !Object.hasOwn(facesOfPart(m, a.part, path).faces, a.face)) && !byCentre)
-        fail('EDIT_TARGET', path, `${a.part} has no flat ${a.face} face`);
-    const name = namer(m, `${a.part}.on.${to.part}`);
-    /*
-      Along the face's own axis. `meet`: the part's centre is half its own depth past the target's face, plus the
-      gap. `flush`: the part's centre is half its own depth back from that face, so its named face lies in it.
-    */
-    const outward = facing === 'meet' ? sign : -sign;
-    const gap = measureRef(m, asset, name, a.gap, `gap.${axis}`, path);
-    /*
-      Split at the point fastened at: the seat is on the target's face (its centre, or level with an edge), the part's
-      centre is half its own depth and the gap past it. A turn added later turns about that point.
-    */
-    const zero = constantOf(m, 'mm', 0, 'd');
-    const translation = { x: '', y: '', z: '' };
-    const offset = { x: zero, y: zero, z: zero };
-    /* By its centre, the gap goes into the seat: the point fastened at -- and turned about -- is the part's middle. */
-    translation[axis] = sumOf(m, name, [...planeOf(target.shape, theirFace), ...(byCentre ? [{ ref: gap, k: outward }] : [])], `seat.${axis}`);
-    const ownFace = byCentre ? mineAlong && !mineAlong.centred ? [...half(mineAlong.lo), ...half(mineAlong.hi)] : [] : SIGN[a.face] > 0 ? mineAlong.hi : mineAlong.lo;
-    offset[axis] = byCentre ? ownFace.length ? sumOf(m, name, neg(ownFace), `along.${axis}`) : zero : sumOf(m, name, [...neg(ownFace), { ref: gap, k: outward }], `along.${axis}`);
-    /*
-      Across the face. Centred by default; min and max keep the two parts' edges level as either is resized -- and the
-      point fastened at is where those edges meet: the seat on the target's edge, the part's own edge on it. A door
-      fastened level with the frame's min edge turns about that edge, as a hinge does (2026-09-25); centred, the point
-      is the middle of the face. A shape not centred on its origin (a portal stands on its bottom) is centred by its
-      faces, not by its origin.
-    */
-    for (const other of AXES.filter(x => x !== axis)) {
-        const how = a.align?.[other] ?? 'centre';
-        const t = theirs[other], o = mine[other];
-        const middle = (span) => (span && !span.centred ? [...half(span.lo), ...half(span.hi)] : []);
-        const centreOf = (span, hint) => middle(span).length ? sumOf(m, name, middle(span), hint) : constantOf(m, 'mm', 0, 'd');
-        const ownCentre = () => (middle(o).length ? sumOf(m, name, neg(middle(o)), `own-centre.${other}`) : zero);
-        if (how === 'centre') {
-            translation[other] = centreOf(t, `centre.${other}`);
-            offset[other] = ownCentre();
-        }
-        else if (typeof how === 'object' && how && Object.hasOwn(how, 'mm')) {
-            const mm = measureRef(m, asset, name, how.mm, `align.${other}`, path);
-            translation[other] = middle(t).length ? sumOf(m, name, [...middle(t), { ref: mm, k: 1 }], `align.${other}.from-centre`) : mm;
-            offset[other] = ownCentre();
-        }
-        else if (how === 'min' || how === 'max') {
-            if (!t)
-                fail('ATTACH_FACE', path, `${to.part} has no edges along ${other} to line ${a.part} up with; give the centre or a measured offset`);
-            if (!o)
-                fail('ATTACH_FACE', path, `${a.part} has no edges along ${other} to line up; give the centre or a measured offset`);
-            translation[other] = sumOf(m, name, how === 'min' ? t.lo : t.hi, `edge.${other}`);
-            offset[other] = sumOf(m, name, neg(how === 'min' ? o.lo : o.hi), `own-edge.${other}`);
-        }
-        else
-            fail('SCHEMA', path, `${String(how)} is not an alignment`);
-    }
-    /*
-      Twisted about the face's normal: the seat is the face's centre, and the part's own offset across the face -- its
-      distance and its own centre -- turns with it, so a blade set out along X and twisted 120° stands out along the
-      blade, about the hub. With no twist this is the same place written as before.
-    */
-    if (twist && twist.deg) {
-        const [p, q] = ACROSS[axis];
-        for (const other of [p, q]) {
-            const how = a.align?.[other] ?? 'centre';
-            if (how === 'min' || how === 'max')
-                fail('ATTACH_FACE', path, `${a.part} is twisted ${round6(twist.deg)}° about ${axis}; its sides are not level with ${to.part}'s edges -- place it by the centre or a distance`);
-        }
-        const across = (other) => {
-            const how = a.align?.[other] ?? 'centre';
-            const o = mine[other];
-            const own = o && !o.centred ? neg([...half(o.lo), ...half(o.hi)]) : [];
-            return typeof how === 'object' && how && Object.hasOwn(how, 'mm') ? [{ ref: measureRef(m, asset, name, how.mm, `twist.${other}`, path), k: 1 }, ...own] : own;
-        };
-        const [vp, vq] = [across(p), across(q)];
-        /*
-          The turn's factors are named by the angle, as the record gives it -- not by their value, which may carry float
-          noise that depends on how it was computed, so a rewrite named them apart (JOINT_DRIFT, the architect's fan,
-          2026-09-25). Their values are rounded to twelve places, which is the second defence.
-        */
-        const exact = (v) => {
-            const r = Math.round(v * 1e12) / 1e12;
-            return r === 0 ? 0 : r;
-        };
-        const tag = String(round6(twist.deg)).replace('-', 'm').replace('.', '_');
-        const factor = (fn) => {
-            const id = `twist.${fn}.${tag}`;
-            const rad = (twist.deg * Math.PI) / 180;
-            if (!m.constants.some((c) => c.id === id))
-                m.constants.push({ id, unit: 'ratio', value: exact(fn === 'cos' ? Math.cos(rad) : fn === 'sin' ? Math.sin(rad) : -Math.sin(rad)) });
-            return id;
-        };
-        const times = (ref, k, hint) => {
-            const id = name(hint);
-            m.nodes.push({ id, op: 'mul@1', args: [ref, k], outputs: { value: `${id}.value` } });
-            return `${id}.value`;
-        };
-        const plus = (a, b, hint) => {
-            const id = name(hint);
-            m.nodes.push({ id, op: 'add@1', args: [a, b], outputs: { value: `${id}.value` } });
-            return `${id}.value`;
-        };
-        for (const other of [p, q]) {
-            const t = theirs[other];
-            translation[other] = t && !t.centred ? sumOf(m, name, [...half(t.lo), ...half(t.hi)], `twist-centre.${other}`) : constantOf(m, 'mm', 0, 'd');
-        }
-        const sp = sumOf(m, name, vp, `twist-own.${p}`), sq = sumOf(m, name, vq, `twist-own.${q}`);
-        offset[p] = plus(times(sp, factor('cos'), `twisted.${p}.cos`), times(sq, factor('nsin'), `twisted.${p}.sin`), `twisted.${p}`);
-        offset[q] = plus(times(sp, factor('sin'), `twisted.${q}.sin`), times(sq, factor('cos'), `twisted.${q}.cos`), `twisted.${q}`);
-    }
-    reseat(asset, a.part, `${to.part}.local`, { seat: [translation.x, translation.y, translation.z], pose: [offset.x, offset.y, offset.z] });
-    return asset;
-}
-/**
- * Standing a part on the plane the figure is mounted on. The plane has no width and no depth, so there is
- * nothing to line the part's edges up with: across the plane, only the centre or a measured offset.
- */
-/** The faces a part is fastened to the mounting plane by, for a figure placed so (ADR-0093). */
-function planeFacesOf(placement) {
-    return placement === 'wall' ? ['back'] : ['bottom', 'top'];
-}
-function standOnPlane(asset, a, path) {
-    const m = asset.document.model;
-    const to = a.to;
-    if (to.plane !== 'mounting-plane')
-        fail('SCHEMA', path, `${String(to.plane)} is not a plane a part can stand on`);
-    if (a.facing !== undefined && a.facing !== 'meet')
-        fail('SCHEMA', path, 'a part standing on the plane meets it; flush says nothing here');
-    /* Which plane it is, the figure's placement says: the floor or the ceiling is Y = 0, a wall is Z = 0 (ADR-0093). */
-    const placement = figurePlacementOf(asset);
-    const takes = planeFacesOf(placement);
-    const normal = placement === 'wall' ? 'z' : 'y';
-    if (!takes.includes(a.face))
-        fail('ATTACH_FACE', path, placement === 'wall'
-            ? `${String(a.face)} faces along ${FIGURE_FACES[a.face] ?? 'no axis'}; the figure hangs on a wall, the plane Z = 0, so a part is fastened to it by its back`
-            : `${String(a.face)} faces along ${FIGURE_FACES[a.face] ?? 'no axis'}; the plane faces along y, so a part stands on it by its bottom or hangs from it by its top`);
-    if (parentOf(m, a.part) && !a.replace)
-        fail('ATTACH_REPLACED', path, `${a.part} is already fastened to ${parentOf(m, a.part)}; pass replace to stand it on the plane instead`);
-    const mine = standingSpansOf(m, asset, a.part, path);
-    if (!mine[normal] || !Object.hasOwn(facesOfPart(m, a.part, path).faces, a.face))
-        fail('EDIT_TARGET', path, `${a.part} has no flat ${a.face} face`);
-    const name = namer(m, `${a.part}.on.plane`);
-    /* Out of the plane: a bottom stands up from the floor, a back comes out of the wall, a top hangs down. */
-    const outward = a.face === 'top' ? -1 : 1;
-    const gap = measureRef(m, asset, name, a.gap, `gap.${normal}`, path);
-    const translation = { x: '', y: '', z: '' };
-    translation[normal] = sumOf(m, name, [...neg(outward > 0 ? mine[normal].lo : mine[normal].hi), { ref: gap, k: outward }], `stand.${normal}`);
-    const zero = constantOf(m, 'mm', 0, 'd');
-    const pose = { x: zero, y: zero, z: zero };
-    pose[normal] = translation[normal];
-    for (const other of AXES.filter(x => x !== normal)) {
-        const how = a.align?.[other] ?? 'centre';
-        const span = mine[other];
-        if (how === 'centre')
-            translation[other] = constantOf(m, 'mm', 0, 'd');
-        else if (typeof how === 'object' && how && Object.hasOwn(how, 'mm'))
-            translation[other] = measureRef(m, asset, name, how.mm, `align.${other}`, path);
-        else if ((how === 'min' || how === 'max') && sizeInputOf(m, other)) {
-            /*
-              The plane has no edges, but a figure that declares its size has a box on it: its sides are half the size
-              either way of the origin. A part level with one keeps to it when the figure is resized -- a door's post at
-              the figure's left, a gantry's legs at its corners (2026-09-25).
-            */
-            if (!span)
-                fail('ATTACH_FACE', path, `${a.part} has no edges along ${other} to line up with the figure's side`);
-            const s = how === 'min' ? -1 : 1;
-            translation[other] = sumOf(m, name, [{ ref: sourceRef(m, asset, { of: 'instance', axis: other }, path), k: s * 0.5 }], `figure-edge.${other}`);
-            pose[other] = sumOf(m, name, neg(how === 'min' ? span.lo : span.hi), `own-edge.${other}`);
-            continue;
-        }
-        else
-            fail('SCHEMA', path, `the plane has no edges to line ${a.part} up with on ${other}; declare the figure's size, or give the centre or a measured offset`);
-        /* A shape not centred on its origin stands centred by its faces. */
-        if (span && !span.centred)
-            pose[other] = sumOf(m, name, neg([...half(span.lo), ...half(span.hi)]), `own-centre.${other}`);
-    }
-    // The point it stands on is on the plane, under its centre: a turn about the plane's normal turns it where it stands.
-    const seat = AXES.map(x => (x === normal ? zero : translation[x]));
-    reseat(asset, a.part, asset.document.capabilities.assetFrame, { seat: [seat[0], seat[1], seat[2]], pose: [pose.x, pose.y, pose.z] });
-    return asset;
-}
-function detach(asset, a) {
-    const m = asset.document.model;
-    const path = a.part;
-    const parent = parentOf(m, a.part);
-    if (!parent)
-        fail('EDIT_TARGET', path, `${a.part} is not fastened to anything`);
-    /*
-      Detaching keeps the part where it stands, and keeps it moving the way it moved. Taking the world pose and
-      writing it in as the part's own pose did neither: the part's motion was already in that pose and was then
-      applied a second time, so a part with 20 mm of travel jumped to 40 (designer's counterexample
-      2026-09-23).
-  
-      What the part's pose has to gain is exactly what the parent's chain was contributing — and that is a plain
-      translation only while nothing above the part is turned. Where something is, the two cannot be separated
-      into a translation the pose can absorb, and this refuses rather than moving the part.
-    */
-    for (let up = parent; up; up = parentOf(m, up))
-        requireUnturned(m, asset, up, path);
-    const evaluated = compileFigureAssetUnjointed(asset).evaluate();
-    const above = evaluated.values?.[nodeById(m, `${parent}.world`)?.outputs?.pose ?? nodeById(m, `${parent}.chain`)?.outputs?.pose ?? nodeById(m, `${parent}.pose`).outputs.pose];
-    if (!above || !above.t)
-        fail('TARGET_ABSENT', path, `${parent} has no pose to read`);
-    const turned = above.r.some((row, i) => row.some((v, j) => Math.abs(v - (i === j ? 1 : 0)) > 1e-9));
-    if (turned)
-        fail('EDIT_TARGET', path, `${parent} is turned; taking ${a.part} off it would move it, and this command does not move a part`);
-    const { pose } = partOf(m, a.part, path);
-    const own = evaluated.values?.[pose.outputs.pose];
-    if (!own || !own.t)
-        fail('TARGET_ABSENT', path, `${a.part} has no pose to read`);
-    /*
-      Where it stands, as plain numbers: what the parent was contributing plus what the part's own pose was. Its
-      motion is left out, because the motion node stays and would otherwise be counted twice. Numbers rather than
-      references, because a part that is no longer fastened to the plate should not still grow with it.
-    */
-    /*
-      The part gets its own position numbers back, as a part made in the modeller has them, so it can be moved again
-      by hand or by the gizmo. Where one of those names is taken, that axis stays a plain number.
-    */
-    /*
-      A part that moves keeps turning about the point it was fastened at: that point becomes its seat in the asset, its
-      own numbers the offset from it. A part that does not move gets its place back as plain position numbers.
-    */
-    const seatAt = evaluated.values?.[`${a.part}.seat.value`]?.t ?? [0, 0, 0];
-    const moving = !!nodeById(m, `${a.part}.motion`);
-    const pivot = AXES.map((_, i) => round6(above.t[i] + seatAt[i]));
-    const translation = AXES.map((axis, i) => {
-        const value = moving ? round6(own.t[i]) : round6(pivot[i] + own.t[i]);
-        const id = `${a.part}.position.${axis}`;
-        if (m.inputs.some((input) => input.id === id) || m.nodes.some((n) => Object.values(n.outputs).includes(id)))
-            return constantOf(m, 'mm', value, 'd');
-        m.inputs.push({ id, unit: 'mm', min: -Number.MAX_VALUE, max: Number.MAX_VALUE, role: 'design' });
-        asset.designInputs[id] = value;
-        return id;
-    });
-    const seat = AXES.map((_, i) => constantOf(m, 'mm', moving ? pivot[i] : 0, 'd'));
-    reseat(asset, a.part, asset.document.capabilities.assetFrame, { seat, pose: translation });
-    return asset;
-}
-const round6 = (v) => Math.round(v * 1e6) / 1e6;
-/**
- * Put a part's pose on a new frame with a new translation, and rebuild the chain that carries it to the asset.
- * The part's own id, its shape and its `placed` reference all stay as they were.
- */
-/**
- * Where a part is fastened, in two translations that are never merged: `seat` is the point it is fastened at, in the
- * frame it is fastened to -- a point on the target's face; `pose` is the part's centre from that point, in its own
- * seat frame. A motion sits between the two, so a turn turns about the point the part is fastened at: a hinge, a
- * joint, a lid (chief architect's ruling 2026-09-25; before this the seat was the target's centre and a fastened
- * part swung about the middle of what it was fastened to).
- *
- *     <id>.local --pose--> <id>.seat [--motion--> <id>.joint] --seat.rigid--> <to>
- *
- * Without `place` the part keeps both translations and only its frames are rewired (a motion added or taken away).
- */
-function reseat(asset, id, to, place) {
-    const m = asset.document.model;
-    const { place: placed, pose } = partOf(m, id, id);
-    const old = place ? pose.args.slice(0, 3) : [];
-    if (place)
-        pose.args = [...place.pose, ...pose.args.slice(3)];
-    pose.params = { ...pose.params, to: `${id}.seat` };
-    const motion = nodeById(m, `${id}.motion`);
-    const zero = constantOf(m, 'mm', 0, 'd');
-    const noTurn = constantOf(m, 'deg', 0, 'a');
-    let seat = nodeById(m, `${id}.seat.rigid`);
-    if (!seat) {
-        seat = { id: `${id}.seat.rigid`, op: 'rigid@1', args: [zero, zero, zero, noTurn, noTurn, noTurn], outputs: { pose: `${id}.seat.value` }, params: {} };
-        m.nodes.push(seat);
-    }
-    const oldSeat = place ? seat.args.slice(0, 3) : [];
-    if (place)
-        seat.args = [...place.seat, ...seat.args.slice(3)];
-    seat.params = { from: motion ? `${id}.joint` : `${id}.seat`, to };
-    // The motion turns the seat frame about its origin -- the point fastened at -- into the joint frame.
-    let turned = nodeById(m, `${id}.turned`);
-    if (motion) {
-        motion.params = { ...motion.params, from: `${id}.seat`, to: `${id}.joint` };
-        if (!turned) {
-            turned = { id: `${id}.turned`, op: 'compose@1', args: [motion.outputs.pose, pose.outputs.pose], outputs: { pose: `${id}.turned.value` } };
-            m.nodes.push(turned);
-        }
-        else
-            turned.args = [motion.outputs.pose, pose.outputs.pose];
-    }
-    else if (turned)
-        m.nodes = m.nodes.filter((n) => n !== turned);
-    let chain = nodeById(m, `${id}.chain`);
-    if (!chain) {
-        chain = { id: `${id}.chain`, op: 'compose@1', args: ['', ''], outputs: { pose: `${id}.chain.value` } };
-        m.nodes.push(chain);
-    }
-    chain.args = [seat.outputs.pose, motion ? turned.outputs.pose : pose.outputs.pose];
-    const parent = /^(.*)\.local$/.exec(to);
-    let world = nodeById(m, `${id}.world`);
-    if (parent && parent[1] !== id) {
-        /* A row's template has no chain of its own: what hangs from it hangs in its copy's frame, turned as it turns. */
-        const above = nodeById(m, `${parent[1]}.world`)?.outputs?.pose ??
-            nodeById(m, `${parent[1]}.chain`)?.outputs?.pose ??
-            nodeById(m, `${parent[1]}.turned`)?.outputs?.pose ??
-            nodeById(m, `${parent[1]}.pose`).outputs.pose;
-        if (!world) {
-            world = { id: `${id}.world`, op: 'compose@1', args: [above, chain.outputs.pose], outputs: { pose: `${id}.world.value` } };
-            m.nodes.push(world);
-        }
-        else
-            world.args = [above, chain.outputs.pose];
-        placed.args = [placed.args[0], world.outputs.pose];
-    }
-    else {
-        if (world)
-            m.nodes = m.nodes.filter((n) => n !== world);
-        placed.args = [placed.args[0], chain.outputs.pose];
-    }
-    /*
-      The part's own position numbers, once nothing reads them, go with the old pose: a fastened part left its
-      position fields in the editor, and typing into them changed nothing (seen on :3300, 2026-09-24).
-    */
-    for (const ref of [...old, ...oldSeat])
-        dropIfUnused(asset, ref, ownInput(m, id, ref) ? ref : undefined);
-}
+import { fail, clone, dropIfUnused, sizeInputOf } from "./authoring-nodes.js";
+import { jointAbove, rewriteJoints, setJoint, applyFaceRemap, removeJoint, fastenAsJoint, setRepeat } from "./joint-writing.js";
+import { linkDimension, unlinkDimension } from "./authoring-dimensions.js";
+import { declareInstanceSize, narrowDeclaredSize, holdsOverDeclaredSize } from "./authoring-size.js";
+import { nudgePart, scaleUniformly, followSizeInProportion, scalePosition, fixPosition } from "./authoring-proportion.js";
+import { setPlacement, declareOccupancy, setMountingFace, clearMountingFace } from "./authoring-occupancy.js";
+import { addBinding, removeBinding, setSlotLayout, removeSlotLayout } from "./authoring-bindings.js";
 /** Apply one authoring command. Throws on any refusal, leaving the asset it was given untouched. */
 export function applyFigureAuthoring(source, action, consent) {
     /*
@@ -1085,8 +124,18 @@ function authoring(source, action) {
             if (!j)
                 fail('EDIT_TARGET', `${action.part}.repeat`, `${action.part} is not fastened to anything; fasten it to the part it repeats across first`);
             const count = action.count === undefined || action.count === 'fills' ? undefined : action.count;
-            const rise = action.rise ? { rise: { axis: String(action.rise.axis).toUpperCase(), mm: action.rise.mm } } : {};
-            setJoint(asset, { ...j, repeat: { axis: String(action.axis).toUpperCase(), pitch: action.pitch, ...(count !== undefined ? { count } : {}), ...rise } });
+            const rise = action.rise
+                ? { rise: { axis: String(action.rise.axis).toUpperCase(), mm: action.rise.mm } }
+                : {};
+            setJoint(asset, {
+                ...j,
+                repeat: {
+                    axis: String(action.axis).toUpperCase(),
+                    pitch: action.pitch,
+                    ...(count !== undefined ? { count } : {}),
+                    ...rise
+                }
+            });
             break;
         }
         case 'remove-repeat': {
@@ -1126,14 +175,22 @@ function authoring(source, action) {
             const path = `inputs.${String(action.id)}`;
             if (typeof action.id !== 'string' || !/^[a-zA-Z][a-zA-Z0-9_.-]*$/.test(action.id))
                 fail('SCHEMA', path, 'an id of letters, digits, dot, dash or underscore');
-            if (m.inputs.some((i) => i.id === action.id) || m.constants.some((c) => c.id === action.id) || m.nodes.some((n) => n.id === action.id || Object.values(n.outputs).includes(action.id)))
+            if (m.inputs.some((i) => i.id === action.id) ||
+                m.constants.some((c) => c.id === action.id) ||
+                m.nodes.some((n) => n.id === action.id || Object.values(n.outputs).includes(action.id)))
                 fail('DUPLICATE_WRITER', path, `${action.id} is already a name in the figure`);
             if (!['mm', 'ratio', 'deg', 'count'].includes(action.unit))
                 fail('SCHEMA', `${path}.unit`, 'mm, ratio, deg or count');
             if (![action.min, action.max, action.value].every(Number.isFinite) || !(action.min < action.max))
                 fail('INPUT_RANGE', path, 'a finite range, its least below its most');
             if (action.value < action.min || action.value > action.max)
-                fail('INPUT_RANGE', path, `${action.value} is outside ${action.min}…${action.max}`);
+                fail('INPUT_RANGE', path, `${action.value} is outside ${action.min}…${action.max}`, {
+                    reason: 'value-outside-range',
+                    input: action.id,
+                    value: action.value,
+                    min: action.min,
+                    max: action.max
+                });
             m.inputs.push({ id: action.id, unit: action.unit, min: action.min, max: action.max, role: 'design' });
             asset.designInputs[action.id] = action.value;
             break;
@@ -1149,14 +206,24 @@ function authoring(source, action) {
                 fail('INPUT_RANGE', path, 'a finite range, its least below its most');
             const value = asset.designInputs[action.input];
             if (value < action.min || value > action.max)
-                fail('INPUT_RANGE', path, `the value now, ${value}, is outside ${action.min}…${action.max}`);
+                fail('INPUT_RANGE', path, `the value now, ${value}, is outside ${action.min}…${action.max}`, {
+                    reason: 'value-outside-range',
+                    input: action.input,
+                    value,
+                    min: action.min,
+                    max: action.max
+                });
             input.min = action.min;
             input.max = action.max;
             break;
         }
         case 'publish-input': {
             checkPublicInput(asset.document.model.inputs, action.input, `publicInputs.${String(action.input)}`);
-            const entry = { input: action.input, label: typeof action.label === 'string' ? action.label.trim() : action.label, ...(action.hint !== undefined ? { hint: action.hint } : {}) };
+            const entry = {
+                input: action.input,
+                label: typeof action.label === 'string' ? action.label.trim() : action.label,
+                ...(action.hint !== undefined ? { hint: action.hint } : {})
+            };
             const list = (asset.publicInputs ?? []).filter(p => p.input !== action.input);
             asset.publicInputs = [...list, entry];
             break;
@@ -1216,7 +283,8 @@ function authoring(source, action) {
       pays for the second compile.
     */
     let result = asset;
-    if ((action.kind === 'link-dimension' || action.kind === 'make-repeat' || action.kind === 'set-joint') && action.narrowRange) {
+    if ((action.kind === 'link-dimension' || action.kind === 'make-repeat' || action.kind === 'set-joint') &&
+        action.narrowRange) {
         compileFigureAsset(asset);
         result = clone(asset);
         narrowDeclaredSize(result);
@@ -1225,7 +293,6 @@ function authoring(source, action) {
     holdsOverDeclaredSize(result, source);
     return result;
 }
-/* ----------------------------------------------------------- instance size */
 function followSize(source, a) {
     const path = `${a.part}.follow-size`;
     const shape = source.document.model.nodes.find((n) => n.id === `${a.part}.shape`);
@@ -1244,9 +311,17 @@ function followSize(source, a) {
         const at = figurePartsExtentOf(asset);
         const start = defaultInstanceSizeRange(at);
         const range = foldInstanceSizeRange(start, figureInstanceSizeLimitsOf(asset, start)).range;
-        asset = applyFigureAuthoring(asset, { kind: 'declare-instance-size', range, at, replace: AXES.some(axis => sizeInputOf(m, axis)) });
+        asset = applyFigureAuthoring(asset, {
+            kind: 'declare-instance-size',
+            range,
+            at,
+            replace: AXES.some(axis => sizeInputOf(m, axis))
+        });
     }
-    const values = compileFigureGraph(asset.document.model).evaluate({ ...asset.designInputs, ...asset.stateDefaults }).values;
+    const values = compileFigureGraph(asset.document.model).evaluate({
+        ...asset.designInputs,
+        ...asset.stateDefaults
+    }).values;
     const shapeNow = asset.document.model.nodes.find((n) => n.id === `${a.part}.shape`);
     const argsNow = shapeNow.args;
     const editNow = figureShapeProviderOf(shapeNow)?.edit;
@@ -1256,2773 +331,16 @@ function followSize(source, a) {
         const size = asset.designInputs[FIGURE_INSTANCE_SIZE_INPUTS[axis]];
         if (!(typeof measure === 'number' && measure > 0 && typeof size === 'number' && size > 0))
             fail('EDIT_TARGET', `${path}.${axis}`, `${a.part}'s ${axis} or the figure's size is not a length to follow`);
-        asset = applyFigureAuthoring(asset, { kind: 'link-dimension', part: a.part, axis, source: { of: 'instance', axis }, times: measure / size, replace: true, narrowRange: true });
-    }
-    return asset;
-}
-const sizeInputOf = (m, axis) => m.inputs.find((i) => i.id === FIGURE_INSTANCE_SIZE_INPUTS[axis]);
-function declareInstanceSize(asset, a) {
-    const m = asset.document.model;
-    const declared = AXES.filter(axis => sizeInputOf(m, axis));
-    if (declared.length && !a.replace)
-        fail('INSTANCE_SIZE_DECLARED', 'size', `the instance size is already declared (${declared.map(x => FIGURE_INSTANCE_SIZE_INPUTS[x]).join(', ')}); pass replace to change its range`);
-    if (!a.range || typeof a.range !== 'object')
-        fail('SCHEMA', 'size', 'a range per axis is required');
-    let measured;
-    const authoredOf = (axis) => {
-        const given = a.at?.[axis];
-        if (given !== undefined)
-            return given;
-        const existing = asset.designInputs[FIGURE_INSTANCE_SIZE_INPUTS[axis]];
-        if (typeof existing === 'number')
-            return existing;
-        /* The parts as they rest, not the room their joints carry them through (a door's swing). */
-        if (!measured)
-            measured = figurePartsExtentOf(asset);
-        return measured[axis];
-    };
-    for (const axis of AXES) {
-        const r = a.range[axis];
-        const at = authoredOf(axis);
-        const path = FIGURE_INSTANCE_SIZE_INPUTS[axis];
-        if (!r || ![r.min, r.max, at].every(Number.isFinite))
-            fail('SCHEMA', path, 'finite min, max and size required');
-        if (!(r.min > 0))
-            fail('INSTANCE_SIZE_RANGE', path, `the smallest size must be above zero; got ${r.min}`);
-        if (!(r.min <= at && at <= r.max))
-            fail('INSTANCE_SIZE_RANGE', path, `the authored size ${at} mm must lie within ${r.min}…${r.max} mm`);
-        const input = sizeInputOf(m, axis);
-        if (input)
-            Object.assign(input, { min: r.min, max: r.max });
-        else
-            m.inputs.push({ id: path, unit: 'mm', min: r.min, max: r.max, role: 'design' });
-        asset.designInputs[path] = at;
-    }
-    return asset;
-}
-/**
- * Every command leaves a figure that can take each size it declares: the kernel is asked at the ends of the declared
- * range, and a size the figure cannot take is refused by name with the size it can go to. This is where a link that
- * makes a part 200 mm shorter than the instance is caught when the instance may be 1 mm wide — the kernel alone
- * accepts it, and the board then fails to draw the figure at small sizes.
- */
-/** Where the declared size range reaches past what the figure holds: per axis, the bound it would need, and who sets it. */
-function sizeRangeGaps(asset) {
-    const m = asset.document.model;
-    if (!AXES.every(axis => sizeInputOf(m, axis)))
-        return [];
-    const range = Object.fromEntries(AXES.map(axis => [axis, { min: sizeInputOf(m, axis).min, max: sizeInputOf(m, axis).max }]));
-    const limits = figureInstanceSizeLimitsOf(asset, range);
-    const { range: holds } = foldInstanceSizeRange(range, limits);
-    const gaps = [];
-    for (const axis of AXES) {
-        const who = limits.find(l => l.axis === axis)?.part;
-        if (holds[axis].min > range[axis].min)
-            gaps.push({ axis, bound: 'min', need: holds[axis].min, declared: range[axis].min, who });
-        if (holds[axis].max < range[axis].max)
-            gaps.push({ axis, bound: 'max', need: holds[axis].max, declared: range[axis].max, who });
-    }
-    return gaps;
-}
-/** The declared size range folded to what the figure allows, as asked; the authored size must stay inside. */
-function narrowDeclaredSize(asset) {
-    const m = asset.document.model;
-    /* A figure that declares no size has no range to reach past: there is nothing to narrow, and the link stands as it is. */
-    if (!AXES.every(axis => sizeInputOf(m, axis)))
-        return;
-    for (const gap of sizeRangeGaps(asset)) {
-        const input = sizeInputOf(m, gap.axis);
-        const at = asset.designInputs[FIGURE_INSTANCE_SIZE_INPUTS[gap.axis]];
-        if (gap.bound === 'min' ? at < gap.need : at > gap.need)
-            fail('INSTANCE_SIZE_RANGE', FIGURE_INSTANCE_SIZE_INPUTS[gap.axis], `the figure is authored at ${at} mm, where a length is already gone; change the link or the size`);
-        if (gap.bound === 'min')
-            input.min = gap.need;
-        else
-            input.max = gap.need;
-    }
-}
-/**
- * After a command, the declared size range must still hold at its ends. A gap the figure already had before the
- * command -- a range the conversion declared too wide (FORMATION_TRAY: X from 1 mm, its cells gone below 8.8 mm) -- is
- * not the command's doing: it is refused only if it made a gap or widened one. Refusing every command for it had
- * blocked even choosing a detail level (user, 2026-09-24).
- */
-function holdsOverDeclaredSize(asset, before) {
-    const now = sizeRangeGaps(asset);
-    if (!now.length)
-        return;
-    const was = before ? sizeRangeGaps(before) : [];
-    for (const gap of now) {
-        const prior = was.find(g => g.axis === gap.axis && g.bound === gap.bound);
-        const worse = !prior || (gap.bound === 'min' ? gap.need > prior.need + 1e-9 || gap.declared < prior.declared : gap.need < prior.need - 1e-9 || gap.declared > prior.declared);
-        if (!worse)
-            continue;
-        const path = FIGURE_INSTANCE_SIZE_INPUTS[gap.axis];
-        const by = gap.who ? ` (${gap.who})` : '';
-        if (gap.bound === 'min')
-            fail('INSTANCE_SIZE_RANGE', path, `below ${round6(gap.need)} mm a length goes to zero${by}; declare the smallest size at ${round6(gap.need)} mm or more`);
-        fail('INSTANCE_SIZE_RANGE', path, `above ${round6(gap.need)} mm the figure cannot be drawn${by}; declare the largest size at ${round6(gap.need)} mm or less`);
-    }
-}
-/** What each part is fastened to, for a reader that wants the structure rather than the graph. */
-export function figureAttachmentsOf(asset) {
-    const m = asset.document.model;
-    const out = {};
-    for (const n of m.nodes)
-        if (n.op === 'place@1')
-            out[n.id] = parentOf(m, n.id);
-    return out;
-}
-/* ------------------------------------------------------------------ joints */
-/** The joint whose child is this part, if any. */
-function jointAbove(asset, part) {
-    return asset.joints?.find(j => j.body1.part === part);
-}
-const stateIdOf = (j) => j.state?.id ?? j.id;
-/** 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;
-    const path = `joints.${String(j?.id)}`;
-    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);
-    if (!j.body0 || (!('plane' in j.body0) && typeof j.body0.part !== 'string'))
-        fail('JOINT_SCHEMA', path, 'a joint hangs from a part or the mounting plane (body0)');
-    if ('part' in j.body0)
-        partOf(m, j.body0.part, path);
-    const others = (asset.joints ?? []).filter(o => o.id !== j.id);
-    const above = others.find(o => o.body1.part === j.body1.part);
-    if (above)
-        fail('JOINT_TREE', path, `${j.body1.part} already hangs from ${'part' in above.body0 ? above.body0.part : 'the mounting plane'} by ${above.id}; a part has one joint above it`);
-    if ('part' in j.body0) {
-        const parentOfPart = (part) => others.find(o => o.body1.part === part)?.body0;
-        for (let up = j.body0.part; up;) {
-            if (up === j.body1.part)
-                fail('ATTACH_CYCLE', path, `${j.body0.part} already hangs from ${j.body1.part}; ${j.body1.part} would hang from itself`);
-            const next = parentOfPart(up);
-            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))
-        fail('JOINT_SCHEMA', path, `a ${j.type} joint has an axis, X, Y or 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");
-    }
-    if (j.origin?.twist !== undefined && !Number.isFinite(j.origin.twist))
-        fail('JOINT_SCHEMA', `${path}.origin.twist`, 'a twist is a number of degrees');
-    if (j.origin?.turn && Object.values(j.origin.turn).some(t => !Number.isFinite(t) || Math.abs(t / 90 - Math.round(t / 90)) > 1e-9))
-        fail('JOINT_SCHEMA', `${path}.origin.turn`, "a turn is in quarter turns; an angle about the face's normal is its twist");
-    /*
-      A row repeats its part and everything fastened to it (ADR-0093, 2026-09-26): a part fastened to a part in a row is
-      on every copy. A row inside a row is a grid; it runs along another axis than the rows around it.
-    */
-    const all = [...others, j];
-    const upOf = (part) => all.find(o => o.body1.part === part && 'part' in o.body0);
-    const rowAbove = (part) => {
-        for (let up = upOf(part); up; up = upOf(up.body0.part))
-            if (up.repeat)
-                return up;
-        return undefined;
-    };
-    if (j.repeat) {
-        const below = (part) => all.filter(o => 'part' in o.body0 && o.body0.part === part).flatMap(o => [o.body1.part, ...below(o.body1.part)]);
-        const around = [];
-        for (let up = ('part' in j.body0) ? rowAbove(j.body0.part) : undefined; up; up = 'part' in up.body0 ? rowAbove(up.body0.part) : undefined)
-            around.push(up);
-        const inside = below(j.body1.part).map(p => all.find(o => o.body1.part === p)).filter(o => o.repeat);
-        const same = [...around, ...inside].find(o => o.repeat.axis === j.repeat.axis);
-        if (same)
-            fail('JOINT_SCHEMA', `${path}.repeat`, `${same.body1.part}'s row runs along ${same.repeat.axis} too; a row inside a row runs along another axis`);
-    }
-    if (j.repeat) {
-        const r = j.repeat;
-        const row = `${path}.repeat`;
-        if (!('part' in j.body0))
-            fail('JOINT_SCHEMA', row, 'a row fills the part it is fastened to; the mounting plane has no length to fill');
-        if (!['X', 'Y', 'Z'].includes(r.axis))
-            fail('JOINT_SCHEMA', row, `a row runs along X, Y or Z, not ${String(r.axis)}`);
-        if (r.axis.toLowerCase() === FIGURE_FACES[childFaceOf(asset.document.model, j)])
-            fail('JOINT_SCHEMA', row, `a row runs across the face it is fastened to; ${r.axis} is out of that face`);
-        if (typeof r.pitch === 'number' ? !(Number.isFinite(r.pitch) && r.pitch > 0) : !followsSomething(r.pitch))
-            fail('GEOMETRY_DOMAIN', row, 'a row has a positive pitch, or one that follows a length');
-        if (r.count !== undefined && !(Number.isSafeInteger(r.count) && r.count >= 1 && r.count <= REPEAT_LIMIT))
-            fail('GEOMETRY_DOMAIN', row, `a row has 1 to ${REPEAT_LIMIT} copies`);
-        if (r.rise !== undefined) {
-            if (!r.rise || !['X', 'Y', 'Z'].includes(r.rise.axis) || r.rise.axis === r.axis)
-                fail('JOINT_SCHEMA', `${row}.rise`, `a row rises along X, Y or Z other than the one it runs along (${r.axis})`);
-            if (!(Number.isFinite(r.rise.mm) && r.rise.mm !== 0))
-                fail('GEOMETRY_DOMAIN', `${row}.rise`, 'a rise is a length in mm, not zero');
-        }
-    }
-}
-/**
- * Write a joint's nodes from its record: the child's quarter turn, the fastening (the seat on the parent's face and
- * the child's offset from it), and for a moving joint the turn or slide at the seat. The node ids are the child's and
- * are chosen the same way each time, so writing a record again gives the same nodes.
- */
-function writeJoint(asset, j) {
-    const m = asset.document.model;
-    const child = j.body1.part;
-    const { pose } = partOf(m, child, child);
-    /*
-      The record speaks as the parts stand: `top` is up, the axis is the figure's. The seat is written in the parent's
-      own frame, so under a parent standing a quarter turn the record's words are turned into that frame, and the child
-      is given the turn back so it keeps its own (빈틈 A, 2026-09-25: a body on a pipe laid on its side).
-    */
-    const parent = 'part' in j.body0 ? j.body0.part : undefined;
-    const path = `joints.${j.id}`;
-    const back = parent ? transpose3(standingTurnOf(asset, parent, path)) : IDENTITY;
-    const turned = !isIdentity(back);
-    const own = AXES.map(a => j.origin?.turn?.[a] ?? 0);
-    /* The child as it stands: its quarter turn, then its twist about the normal of the face it is fastened by. */
-    const childFace = childFaceOf(m, j);
-    const normal = FIGURE_FACES[childFace];
-    const standing = j.origin?.twist ? mul3(axisTurn(normal, j.origin.twist), turnMatrix(own)) : turnMatrix(own);
-    /* In the parent's frame: its twist about the face's normal there, and the quarter turn that is left. */
-    const inParent = mul3(back, standing);
-    const localNormal = axisOf(mv3(back, FACE_VECTOR[childFace]), `${j.body1.part}'s ${childFace}`, parent ?? '', back, path);
-    /* The record's twist, about the normal as it lies in the parent's frame; what is left is a quarter turn. */
-    /*
-      In the parent's frame the child stands twisted about the face's normal -- by its own twist, and back by its
-      parent's -- after a quarter turn. The twist is the one nearest what the record asks for.
-    */
-    const alongNormal = mv3(back, AXES.map(a => (a === normal ? 1 : 0)));
-    const asked = (j.origin?.twist ?? 0) * Math.sign(alongNormal[AXES.indexOf(localNormal.axis)]);
-    const { quarter, deg } = splitTwist(inParent, localNormal.axis, asked, path);
-    const old = pose.args.slice(3, 6);
-    pose.args = [...pose.args.slice(0, 3), ...(turned || j.origin?.twist ? eulerOf(quarter) : own).map(t => constantOf(m, 'deg', t, 'a'))];
-    for (const ref of old)
-        dropIfUnused(asset, ref, ownInput(m, child, ref) ? ref : undefined);
-    const face = (name) => turned && Object.hasOwn(FACE_VECTOR, name) ? faceAlong(axisOf(mv3(back, FACE_VECTOR[name]), name, parent ?? '', back, path).vector) : name;
-    attach(asset, {
-        kind: 'attach',
-        part: child,
-        face: face(j.body1.face),
-        to: 'plane' in j.body0 ? { plane: 'mounting-plane' } : { part: j.body0.part, face: face(j.body0.face) },
-        ...(j.origin?.facing ? { facing: j.origin.facing } : {}),
-        ...(j.origin?.gap !== undefined ? { gap: j.origin.gap } : {}),
-        /*
-          A distance across the face is measured in the twisted frame (see `attach`), so under a twisted parent it is
-          carried by the parent's quarter turn only; the twists turn it after.
-        */
-        ...(j.origin?.align ? { align: turned ? alignInto(parent ? transpose3(standingQuarterOf(asset, parent, path)) : back, j.origin.align, path) : j.origin.align } : {}),
-        replace: true
-    }, deg ? { axis: localNormal.axis, deg } : undefined);
-    /* The measuring was done on the quarter turn; the part stands with its twist. */
-    if (deg) {
-        const now = pose.args.slice(3, 6);
-        pose.args = [...pose.args.slice(0, 3), ...eulerOfAny(inParent).map(t => constantOf(m, 'deg', t, 'a'))];
-        for (const ref of now)
-            dropIfUnused(asset, ref);
-    }
-    if (j.repeat && turned)
-        fail('JOINT_SCHEMA', `joints.${j.id}.repeat`, `${parent} stands turned; a row across a turned part is not covered yet`);
-    /* 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 along = mv3(back, AXES.map(a => (a === j.axis.toLowerCase() ? 1 : 0)));
-    const axisIndex = 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`);
-    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.
-    */
-    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, along[axisIndex] > 0 ? 1 : -1);
-    if (j.repeat)
-        repeatPart(asset, j);
-}
-const IDENTITY = [[1, 0, 0], [0, 1, 0], [0, 0, 1]];
-const isIdentity = (r) => r.every((row, i) => row.every((v, k) => Math.abs(v - (i === k ? 1 : 0)) < 1e-12));
-const transpose3 = (r) => r[0].map((_, i) => r.map(row => row[i]));
-const mv3 = (r, v) => r.map(row => row.reduce((sum, x, k) => sum + x * v[k], 0));
-const FACE_VECTOR = { left: [-1, 0, 0], right: [1, 0, 0], bottom: [0, -1, 0], top: [0, 1, 0], back: [0, 0, -1], front: [0, 0, 1] };
-const faceAlong = (v) => Object.keys(FACE_VECTOR).find(f => FACE_VECTOR[f].every((x, i) => x === v[i]));
-/**
- * How a part stands, as a signed axis permutation: its own quarter turn, which its joint record keeps (the pose may
- * carry the turn back given under a turned parent). A part with no joint stands as its pose turns it. Any turn but
- * quarter turns is refused and says the angle: nothing can be fastened level with its faces.
- */
-function standingTurnOf(asset, part, path) {
-    const record = (asset.joints ?? []).find(o => o.body1.part === part);
-    const turn = record ? AXES.map(a => record.origin?.turn?.[a] ?? 0) : turnOf(asset.document.model, asset, part, path);
-    if (turn.some(t => t === null || !Number.isFinite(t) || Math.abs(t / 90 - Math.round(t / 90)) > 1e-9))
-        fail('EDIT_TARGET', path, `${part} is turned (${saidTurn(turn)}); fastening to a turned part by its faces is covered only for quarter turns`);
-    const quarter = turn.every(t => t === 0) ? IDENTITY : turnMatrix(turn);
-    /* A twisted part stands twisted about the normal of the face it is fastened by. */
-    return record?.origin?.twist ? mul3(axisTurn(FIGURE_FACES[childFaceOf(asset.document.model, record)], record.origin.twist), quarter) : quarter;
-}
-/** How a part stands before its twist: its quarter turn only. */
-function standingQuarterOf(asset, part, path) {
-    const record = (asset.joints ?? []).find(o => o.body1.part === part);
-    if (!record?.origin?.twist)
-        return standingTurnOf(asset, part, path);
-    const turn = AXES.map(a => record.origin?.turn?.[a] ?? 0);
-    return turn.every(t => t === 0) ? IDENTITY : turnMatrix(turn);
-}
-/** A quarter-turn matrix back as degrees about X, Y and Z in the order `rigid@1` turns. */
-function eulerOf(r) {
-    const deg = (a) => {
-        const d = Math.round((a * 180) / Math.PI / 90) * 90;
-        return d === 0 ? 0 : d;
-    };
-    /*
-      About Y by a quarter turn, X and Z turn about the same axis and only their sum counts; Z is taken as 0. At +90 the X
-      turn reads off as atan2(r10, r11), at -90 as atan2(-r10, r11) -- the -90 case had used the +90 reading, so two of the 24
-      quarter turns (Y at -90 with X at +-90) did not come back and a host turned that way refused every fastening.
-    */
-    const out = Math.abs(r[0][2]) < 1
-        ? [deg(Math.atan2(-r[1][2], r[2][2])), deg(Math.asin(r[0][2])), deg(Math.atan2(-r[0][1], r[0][0]))]
-        : [deg(Math.atan2(Math.sign(r[0][2]) * r[1][0], r[1][1])), deg(Math.asin(r[0][2])), 0];
-    if (!turnMatrix(out).every((row, i) => row.every((v, k) => v === r[i][k])))
-        fail('EDIT_TARGET', 'turn', `${JSON.stringify(r)} is not a quarter turn; a fastening is covered only for quarter turns`);
-    return out;
-}
-/** The two axes across a face along `axis`, in the order a right-handed turn about it takes one into the other. */
-const ACROSS = { x: ['y', 'z'], y: ['z', 'x'], z: ['x', 'y'] };
-/** A turn of `deg` degrees about one axis. */
-function axisTurn(axis, deg) {
-    const c = Math.cos((deg * Math.PI) / 180), s = Math.sin((deg * Math.PI) / 180);
-    const [p, q] = ACROSS[axis].map(a => AXES.indexOf(a));
-    const r = [[1, 0, 0], [0, 1, 0], [0, 0, 1]];
-    r[p][p] = c;
-    r[p][q] = -s;
-    r[q][p] = s;
-    r[q][q] = c;
-    return r;
-}
-/** A direction that must lie along an axis to name a face or an edge there; otherwise refused with the parent's twist. */
-function axisOf(v, what, parent, back, path) {
-    const k = v.findIndex(x => Math.abs(Math.abs(x) - 1) < 1e-9);
-    if (k < 0)
-        fail('ATTACH_FACE', path, `${parent} stands twisted (${saidTurn(eulerOfAny(transpose3(back)))}); ${what} is not level with an axis in it`);
-    return { axis: AXES[k], vector: v.map(x => (Math.abs(x) < 1e-9 ? 0 : Math.sign(x))) };
-}
-/**
- * A turn as a twist about one axis after a quarter turn: r = twist(axis, deg) · quarter, with the twist nearest
- * `asked`. A turn that is no such thing (a face not level with the axis) is refused.
- */
-function splitTwist(r, axis, asked, path) {
-    const k = AXES.indexOf(axis);
-    const [p, q] = ACROSS[axis].map(a => AXES.indexOf(a));
-    let best;
-    for (const quarter of QUARTER_TURNS) {
-        const t = mul3(r, transpose3(quarter));
-        if (Math.abs(t[k][k] - 1) > 1e-9)
-            continue;
-        const d = (Math.atan2(t[q][p], t[p][p]) * 180) / Math.PI;
-        const off = Math.abs(((((d - asked) % 360) + 540) % 360) - 180);
-        if (!best || off < best.off - 1e-9)
-            best = { quarter, deg: Math.abs(d) < 1e-9 ? 0 : d, off };
-    }
-    if (!best)
-        fail('ATTACH_FACE', path, `the part would stand turned about more than the face's normal (${saidTurn(eulerOfAny(r))})`);
-    /*
-      The angle as asked when that is what the turn is: taken back out of a matrix it carries float noise that depends
-      on the path it was computed by, and the numbers made from it are named by their value -- the first write and the
-      parse's rewrite then named them apart (JOINT_DRIFT, the architect's fan, 2026-09-25).
-    */
-    return { quarter: best.quarter, deg: best.off < 1e-6 ? asked : round6(best.deg) };
-}
-const QUARTER_TURNS = (() => {
-    const out = [];
-    for (const x of [0, 90, 180, 270])
-        for (const y of [0, 90, 180, 270])
-            for (const z of [0, 90, 180, 270]) {
-                const r = turnMatrix([x, y, z]);
-                if (!out.some(o => o.every((row, i) => row.every((v, j) => v === r[i][j]))))
-                    out.push(r);
-            }
-    return out;
-})();
-/** Any turn back as degrees about X, Y and Z in the order `rigid@1` turns (X, then Y, then Z). */
-function eulerOfAny(r) {
-    const deg = (a) => {
-        const d = round6((a * 180) / Math.PI);
-        return d === 0 ? 0 : d;
-    };
-    const sy = Math.max(-1, Math.min(1, r[0][2]));
-    if (Math.abs(sy) < 1 - 1e-12)
-        return [deg(Math.atan2(-r[1][2], r[2][2])), deg(Math.asin(sy)), deg(Math.atan2(-r[0][1], r[0][0]))];
-    return [deg(Math.atan2(r[1][0], r[1][1])), deg(Math.asin(sy)), 0];
-}
-/** Where a part sits across a face, said on the standing axes, turned onto the parent's own: an edge flips where an axis does. */
-function alignInto(back, align, path) {
-    const out = {};
-    for (const [a, how] of Object.entries(align)) {
-        const v = mv3(back, AXES.map(x => (x === a ? 1 : 0)));
-        const k = v.findIndex(x => Math.abs(Math.abs(x) - 1) < 1e-9);
-        if (k < 0)
-            fail('ATTACH_FACE', path, `the parent stands twisted; placing along ${a} is not level with an axis in it -- place it by the centre`);
-        const s = Math.sign(v[k]);
-        const to = AXES[k];
-        if (how === 'centre' || s > 0)
-            out[to] = how;
-        else if (how === 'min' || how === 'max')
-            out[to] = how === 'min' ? 'max' : 'min';
-        else if (typeof how.mm === 'number')
-            out[to] = { mm: -how.mm };
-        else
-            fail('SCHEMA', path, `an offset that follows another value cannot be turned over onto ${to}; give it as a number`);
-    }
-    return out;
-}
-/**
- * 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
- * copy stands as the fastening put the part, moved along the axis. The part keeps its id, as the row's template.
- */
-function repeatPart(asset, j) {
-    const m = asset.document.model;
-    const part = j.body1.part;
-    const parent = j.body0.part;
-    const path = `joints.${j.id}.repeat`;
-    const axis = j.repeat.axis.toLowerCase();
-    const k = AXES.indexOf(axis);
-    const theirs = ownSpansOf(m, parent, path)[axis];
-    if (!theirs)
-        fail('EDIT_TARGET', path, `${parent} has no two faces along ${axis}; there is no length to fill`);
-    const mine = standingSpansOf(m, asset, part, path)[axis];
-    /* A frustum has no faces across its axis; it is as wide there as its wider end (G6). */
-    const widest = mine ? undefined : frustumWidthAlong(m, asset, part, axis, path);
-    if (!mine && !widest)
-        fail('EDIT_TARGET', path, `${part} has no two faces along ${axis}; its copies cannot be spaced`);
-    const { place, pose } = partOf(m, part, path);
-    const seat = nodeById(m, `${part}.seat.rigid`);
-    const name = namer(m, `${part}.row`);
-    const zero = constantOf(m, 'mm', 0, 'd');
-    /* The seat moves to the row's start; each copy's centre is where the layout puts it from there. */
-    seat.args = seat.args.map((ref, i) => (i === k ? sumOf(m, name, theirs.lo, 'start') : ref));
-    const own = widest || mine.centred ? zero : sumOf(m, name, neg([...half(mine.lo), ...half(mine.hi)]), 'own-centre');
-    pose.args = pose.args.map((ref, i) => (i === k ? own : ref));
-    const length = sumOf(m, name, [...theirs.hi, ...neg(theirs.lo)], 'length');
-    const extent = widest ?? sumOf(m, name, [...mine.hi, ...neg(mine.lo)], 'extent');
-    const centred = constantOf(m, 'ratio', 0.5, 'k');
-    const limit = constantOf(m, 'count', REPEAT_LIMIT, 'limit');
-    const count = j.repeat.count;
-    m.nodes.push(count === undefined
-        ? { id: `${part}.layout`, op: 'fit-pitch@1', args: [length, zero, zero, extent, measureRef(m, asset, name, j.repeat.pitch, 'pitch', path), centred, limit], outputs: { layout: `${part}.layout.value` } }
-        : { id: `${part}.layout`, op: 'fixed-count@1', args: [constantOf(m, 'count', count, 'count'), length, zero, zero, extent, centred, limit], outputs: { layout: `${part}.layout.value` } });
-    /* The part is the row's template now: a member, drawn only through the row -- turned by its motion, if it moves. */
-    place.op = 'member@1';
-    place.args = [place.args[0], nodeById(m, `${part}.turned`)?.outputs?.pose ?? pose.outputs.pose];
-    m.nodes.push({ id: `${part}.assembly`, op: 'assembly@1', args: [place.outputs.placed], outputs: { assembly: `${part}.assembly.value` } });
-    /* Where the parent stands, as `attach` finds it: fastened (its world or chain), or placed by its own numbers. */
-    const above = nodeById(m, `${parent}.world`)?.outputs?.pose ??
-        nodeById(m, `${parent}.chain`)?.outputs?.pose ??
-        nodeById(m, `${parent}.turned`)?.outputs?.pose ??
-        nodeById(m, `${parent}.pose`)?.outputs?.pose;
-    let root = seat.outputs.pose;
-    if (above) {
-        m.nodes.push({ id: `${part}.row`, op: 'compose@1', args: [above, seat.outputs.pose], outputs: { pose: `${part}.row.value` } });
-        root = `${part}.row.value`;
-    }
-    m.nodes = m.nodes.filter((n) => n.id !== `${part}.chain` && n.id !== `${part}.world`);
-    const rise = j.repeat.rise;
-    m.nodes.push({
-        id: `${part}.repeat`,
-        op: 'repeat@1',
-        args: [`${part}.layout.value`, `${part}.assembly.value`, root, ...(rise ? [constantOf(m, 'mm', rise.mm, 'rise')] : [])],
-        outputs: { collection: `${part}.repeat.value` },
-        params: { axis, ...(rise ? { riseAxis: rise.axis.toLowerCase() } : {}) }
-    });
-}
-/**
- * Everything fastened to a row's part, however far down, goes into the row's assembly: each copy carries it (ADR-0093,
- * 2026-09-26). Its placement already reads its copy's frame -- it hangs from the part's pose, not from a chain.
- */
-function gatherRows(asset, joints) {
-    const m = asset.document.model;
-    for (const row of joints.filter(j => j.repeat)) {
-        const assembly = nodeById(m, `${row.body1.part}.assembly`);
-        /* Down to the next row: a row inside this one joins as its copies, and what hangs from its part is its own. */
-        const gather = (part) => {
-            for (const o of joints.filter(o => 'part' in o.body0 && o.body0.part === part)) {
-                if (o.repeat) {
-                    const inner = nodeById(m, `${o.body1.part}.repeat`);
-                    inner.params = { ...inner.params, within: `${row.body1.part}.repeat` };
-                    assembly.args.push(inner.outputs.collection);
-                    continue;
-                }
-                const place = nodeById(m, o.body1.part);
-                place.op = 'member@1';
-                assembly.args.push(place.outputs.placed);
-                gather(o.body1.part);
-            }
-        };
-        gather(row.body1.part);
-    }
-}
-/**
- * How wide a frustum is across its own axis, where the row runs: the larger of its two diameters, as the bounds of two
- * candidates (\`affine-bounds@1\`) -- the room's own way to take the larger of sums, so the gate still reads it as a sum
- * (chief architect, 2026-09-26). Undefined for any other shape, or a row along the frustum's own axis.
- */
-function frustumWidthAlong(m, asset, part, axis, path) {
-    const { shape } = partOf(m, part, path);
-    /* A taper's two radii, end then start -- read from the node, not assumed. */
-    const taper = shape.op === 'revolve@1' && shape.params?.profile === 'taper' ? { along: shape.params.axis, radii: [shape.args[3], shape.args[2]] } : undefined;
-    if (!taper)
-        return undefined;
-    const r = quarterTurnOf(m, asset, part, path, true);
-    const own = AXES[r[AXES.indexOf(axis)].findIndex(v => v !== 0)];
-    if (own === taper.along)
-        return undefined;
-    const id = `${part}.width.${own}`;
-    if (!nodeById(m, id)) {
-        const zero = constantOf(m, 'mm', 0, 'd');
-        const two = constantOf(m, 'ratio', 2, 'k');
-        const [top, bottom] = taper.radii;
-        /* xmin, xmax, ymin, ymax, zmin, zmax: only the one maximum is read; the others hold a zero each. */
-        m.nodes.push({
-            id,
-            op: 'affine-bounds@1',
-            args: [zero, zero, top, two, zero, bottom, two, zero, zero, zero, zero],
-            outputs: { xmin: `${id}.unused.xmin`, xmax: `${id}.value`, ymin: `${id}.unused.ymin`, ymax: `${id}.unused.ymax`, zmin: `${id}.unused.zmin`, zmax: `${id}.unused.zmax` },
-            params: { layout: 'L0.1_1.0.0.0.0' }
-        });
-    }
-    return `${id}.value`;
-}
-/** A row made back into its one part, so its fastening can be taken away or written again. */
-function unrepeatPart(asset, part) {
-    const m = asset.document.model;
-    const template = nodeById(m, part);
-    if (template?.op !== 'member@1' || !nodeById(m, `${part}.repeat`))
-        return;
-    const layout = nodeById(m, `${part}.layout`);
-    const rise = nodeById(m, `${part}.repeat`)?.args[3];
-    const row = new Set([`${part}.layout`, `${part}.assembly`, `${part}.repeat`, `${part}.row`]);
-    const gone = m.nodes.filter((n) => row.has(n.id) || n.id.startsWith(`${part}.row.`));
-    m.nodes = m.nodes.filter((n) => !gone.includes(n));
-    template.op = 'place@1';
-    for (const ref of [...(layout?.args ?? []), ...(rise ? [rise] : [])])
-        dropIfUnused(asset, ref);
-}
-/** Take a joint's nodes away, leaving its child standing in the asset frame at the origin. */
-function stripJoint(asset, j) {
-    const m = asset.document.model;
-    const child = j.body1.part;
-    unrepeatPart(asset, child);
-    if (nodeById(m, `${child}.motion`))
-        removeMotion(asset, { kind: 'remove-motion', part: child });
-    const { pose, place } = partOf(m, child, child);
-    const owned = new Set([`${child}.seat.rigid`, `${child}.chain`, `${child}.world`, `${child}.turned`]);
-    m.nodes = m.nodes.filter((n) => !owned.has(n.id) && !n.id.startsWith(`${child}.on.`));
-    const zero = constantOf(m, 'mm', 0, 'd');
-    const old = pose.args.slice(0, 3);
-    pose.args = [zero, zero, zero, ...pose.args.slice(3)];
-    pose.params = { ...pose.params, to: asset.document.capabilities.assetFrame };
-    // Its own position numbers, if it still had them, place nothing now: the joint places it.
-    for (const ref of old)
-        dropIfUnused(asset, ref, ownInput(m, child, ref) ? ref : undefined);
-    place.args = [place.args[0], pose.outputs.pose];
-}
-/**
- * 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)
- * and each offset across the face. Renaming a part and taking one away read and write them all alike.
- */
-function jointMeasures(j) {
-    const out = [];
-    if (j.origin?.gap !== undefined)
-        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 axis of Object.keys(j.origin?.align ?? {})) {
-        const how = j.origin.align[axis];
-        if (how && typeof how === 'object' && Object.hasOwn(how, 'mm'))
-            out.push({ at: `align.${axis}`, get: () => how.mm, set: v => (how.mm = v) });
-    }
-    return out;
-}
-/** The same measure with each term's source put through `to`, in the form it was written. */
-function mapMeasureSources(measure, to) {
-    const f = followedTermsOf(measure);
-    if (!f)
-        return measure;
-    if (f.sum)
-        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. */
-function writingOrder(joints) {
-    const done = new Set();
-    const out = [];
-    const byChild = new Map(joints.map(j => [j.body1.part, j]));
-    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));
+        asset = applyFigureAuthoring(asset, {
+            kind: 'link-dimension',
+            part: a.part,
+            axis,
+            source: { of: 'instance', axis },
+            times: measure / size,
+            replace: true,
+            narrowRange: true
         });
-        if (!ready.length)
-            fail('JOINT_TREE', 'joints', 'the joints do not make a tree');
-        for (const j of ready) {
-            done.add(j.id);
-            out.push(j);
-        }
-    }
-    return out;
-}
-/** Every joint's nodes again, from the records: the ones below first away, then all written parents first. */
-function rewriteJoints(asset) {
-    const joints = (asset.joints ?? []);
-    /*
-      A stroke that follows a part's length reads that length by its stable name (`<part>.dimension.<axis>`), and naming
-      it rewires the shape to read it. Done in the middle of the writing, the joints already written measured the part by
-      its old reference and the parse's rewrite measured it by the new one (JOINT_DRIFT, the telescopic conveyor,
-      2026-09-25). The names are made first, so every joint measures the same references.
-    */
-    for (const j of joints)
-        for (const { at, get } of jointMeasures(j))
-            for (const t of followedTermsOf(get())?.terms ?? [])
-                if (t?.from?.of === 'part')
-                    stableDimension(asset.document.model, t.from.part, t.from.axis, `joints.${j.id}.${at}`);
-    const order = writingOrder(joints);
-    const keep = { ...asset.stateDefaults };
-    /* What hangs from a row's part is drawn through the row; it is a part of its own again while the joints are written. */
-    for (const n of asset.document.model.nodes)
-        if (n.op === 'member@1' && !nodeById(asset.document.model, `${n.id}.repeat`))
-            n.op = 'place@1';
-    for (const j of [...order].reverse())
-        stripJoint(asset, j);
-    for (const j of order)
-        writeJoint(asset, j);
-    gatherRows(asset, joints);
-    // 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)];
-}
-/*
- * A part edit that renames or removes a part reads the joint records first: the records are the canon and the joint
- * nodes are made from them (ADR-0093). Renaming or deleting a part in the graph alone left records naming a part that
- * was no longer there, and the author could not save (TARGET_ABSENT on joints.*, 2026-09-25).
- */
-/**
- * The records follow a part's new name -- as a joint's parent, as its child, and as the joint a follower follows -- and
- * the nodes are made again from them. Nothing is frozen: a length that followed the part still follows it, and the
- * stored design inputs keep their values under the carried names, so the figure stands as it did at every size.
- */
-export function renameFigurePartInJoints(asset, from, to) {
-    const joints = asset.joints;
-    if (!joints?.length)
-        return;
-    const name = (id) => (id === from ? to : id);
-    /*
-      A joint's nodes carry its parent's name (`leg-2.on.top.*`); what reads them -- the space declared from the parts,
-      a size that follows a fastened place -- follows them to the new name (빈틈 H, 2026-09-25).
-    */
-    const infix = `.on.${from}.`;
-    const carried = (value) => typeof value === 'string'
-        ? value.includes(infix)
-            ? value.split(infix).join(`.on.${to}.`)
-            : value
-        : Array.isArray(value)
-            ? value.map(carried)
-            : value && typeof value === 'object'
-                ? Object.fromEntries(Object.entries(value).map(([k, v]) => [k, carried(v)]))
-                : value;
-    const out = asset;
-    out.document = carried(out.document);
-    if (out.occupancy)
-        out.occupancy = carried(out.occupancy);
-    out.designInputs = Object.fromEntries(Object.entries(out.designInputs ?? {}).map(([k, v]) => [carried(k), v]));
-    /* A length that follows the part's measure follows it under its new name, in each term of a sum too. */
-    const source = (s) => (s?.of === 'part' ? { ...s, part: name(s.part) } : s);
-    asset.joints = joints.map(was => {
-        const j = structuredClone(was);
-        for (const { get, set } of jointMeasures(j))
-            set(mapMeasureSources(get(), source));
-        return {
-            ...j,
-            id: name(j.id),
-            body0: 'part' in j.body0 ? { ...j.body0, part: name(j.body0.part) } : j.body0,
-            body1: { ...j.body1, part: name(j.body1.part) },
-            ...(j.mimic
-                ? { mimic: Object.hasOwn(j.mimic, 'sum') ? { ...j.mimic, sum: figureMimicLeadersOf(j).map(t => ({ ...t, joint: name(t.joint) })) } : { ...j.mimic, joint: name(j.mimic.joint) } }
-                : {}),
-            ...(j.state?.id !== undefined ? { state: { ...j.state, id: name(j.state.id) } } : {})
-        };
-    });
-    rewriteJoints(asset);
-}
-/**
- * What reads a part that is to be taken away, said in the author's words: the space declared from the parts, another
- * part's size or place that follows it. Taking it would leave them reading nothing (빈틈 H, 2026-09-25).
- */
-/** `spaceFittedAgain`: the space is declared again once the part is gone, so its reading the part is no refusal. */
-function refuseIfRead(asset, part, spaceFittedAgain = false) {
-    const m = asset.document.model;
-    const own = (id) => id === part || id.startsWith(`${part}.`);
-    const mine = new Set([
-        ...m.nodes.filter((n) => own(n.id)).flatMap((n) => Object.values(n.outputs)),
-        ...m.inputs.filter((i) => own(i.id)).map((i) => i.id),
-        ...m.constants.filter((c) => own(c.id)).map((c) => c.id)
-    ]);
-    const readsOf = (refs) => (n) => [...n.args, ...Object.values(n.params ?? {})].some((r) => typeof r === 'string' && refs.has(r));
-    const readers = m.nodes.filter((n) => !own(n.id) && readsOf(mine)(n));
-    const space = spaceOnlyNodesOf(asset);
-    if (!spaceFittedAgain && (readers.some((n) => space.has(n.id)) || stringsIn(asset.occupancy).some(r => mine.has(r))))
-        fail('PART_REFERENCED', part, `${part} is in the space the figure declares; declare the space again, or fit it to the parts, without it first`);
-}
-/**
- * A copied part is fastened as the original is: its own record, the same faces and place, so it is not held by nodes
- * no record makes. A moving joint gets its own control -- a copy is a second thing, not the original's shadow.
- */
-export function copyFigurePartJoint(asset, from, to) {
-    const joints = (asset.joints ?? []);
-    const j = joints.find(o => o.body1.part === from);
-    if (!j)
-        return;
-    const m = asset.document.model;
-    const ids = new Set(joints.map(o => o.id));
-    const inputs = new Set(m.inputs.map((i) => i.id));
-    const fresh = (base, taken) => {
-        let id = base;
-        for (let n = 2; taken.has(id); n++)
-            id = `${base}-${n}`;
-        return id;
-    };
-    const id = fresh(j.id === from ? to : `${j.id}-copy`, ids);
-    const copy = { ...structuredClone(j), id, body1: { ...j.body1, part: to } };
-    if (j.type !== 'fixed' && !j.mimic)
-        copy.state = { ...(j.state ?? {}), id: fresh(j.state?.id ? `${j.state.id}-copy` : id, inputs) };
-    asset.joints = [...joints, copy];
-    rewriteJoints(asset);
-}
-/** XYZ angles in degrees of a rotation written as rigid@1 writes it, Rx·Ry·Rz. */
-function eulerXYZ(r) {
-    const deg = (v) => round6((v * 180) / Math.PI) + 0;
-    const sy = Math.max(-1, Math.min(1, r[0][2]));
-    const ry = Math.asin(sy);
-    if (Math.abs(Math.cos(ry)) < 1e-9)
-        return [deg(Math.atan2(r[2][1], r[1][1])), deg(ry), 0];
-    return [deg(Math.atan2(-r[1][2], r[2][2])), deg(ry), deg(Math.atan2(-r[0][1], r[0][0]))];
-}
-/** The unit a value of this type is written in, as the graph keeps it (base units), or undefined for a pose and the rest. */
-function baseUnitOf(type) {
-    const t = JSON.stringify(type);
-    if (t === '[1,0,0]')
-        return 'mm';
-    if (t === '[0,1,0]')
-        return 'rad';
-    if (t === '[0,0,1]')
-        return 's';
-    if (t === '[0,0,0]')
-        return 'ratio';
-    if (t === '{"kind":"count"}')
-        return 'count';
-    return undefined;
-}
-/**
- * Before a part is taken away (chief architect's ruling 2026-09-27, replacing the refusals of 2026-09-25). What hung
- * from it stays where it stood at rest -- every control at zero -- fastened to nothing: its joint, and the motion and
- * control the joint gave it, go. A part that moved with its joint gets a control of its own, named after the part,
- * over the leader's range put through the multiplier and offset, starting where it stood. A value that followed its
- * size or place becomes the number it is now. One thing is refused, by name: a row laid along it, or hanging in it --
- * a row is made from its record, and a record needs the part (ADR-0093).
- */
-export function releaseFigurePartJoints(asset, part, options = {}) {
-    const a = asset;
-    const m = a.document.model;
-    const notice = { released: [], fixed: [], controls: [] };
-    refuseIfRead(a, part, options.spaceFittedAgain);
-    let joints = (a.joints ?? []);
-    const rows = joints.filter(j => 'part' in j.body0 && j.body0.part === part && j.repeat).map(j => j.body1.part);
-    if (rows.length)
-        fail('PART_ROW', part, `${rows.join(', ')} ${rows.length > 1 ? 'are rows' : 'is a row'} laid along ${part}; fasten ${rows.length > 1 ? 'them' : 'it'} to another part, or make ${rows.length > 1 ? 'them' : 'it'} one part, first`);
-    const own = joints.find(j => j.body1.part === part);
-    const children = joints.filter(j => 'part' in j.body0 && j.body0.part === part);
-    if (own?.repeat && children.length)
-        fail('PART_ROW', part, `${children.map(j => j.body1.part).join(', ')} ${children.length > 1 ? 'hang' : 'hangs'} in the row ${part}, on every copy; take ${children.length > 1 ? 'them' : 'it'} off first`);
-    /*
-      Every number frozen below -- a follower's range and start, a measure that followed the part, a value read from it --
-      is evaluated at the asset's stored design inputs and state defaults: the figure as it is authored, so its placement
-      there is what it was. At another instance size the frozen numbers no longer follow.
-    */
-    const inputs = (over = {}) => ({ ...a.designInputs, ...a.stateDefaults, ...over });
-    const controls = m.inputs.filter((i) => i.role === 'state');
-    const rest = Object.fromEntries(controls.map((i) => [i.id, Math.min(i.max, Math.max(i.min, 0))]));
-    const graph = compileFigureGraph(m);
-    const atRest = graph.evaluate(inputs(rest)).values;
-    const now = graph.evaluate(inputs()).values;
-    /* A part moving with a joint that goes: its own control, over what the leader's distance or angle came to. */
-    const going = new Set([...(own ? [own.id] : []), ...children.map(j => j.id)]);
-    /* A follower has no control of its own, so its own record's nominal id is not taken. */
-    const taken = new Set([...m.inputs.map((i) => i.id), ...joints.filter(j => !j.mimic).map(stateIdOf)]);
-    for (const f of joints.filter(o => figureMimicLeadersOf(o).some(t => going.has(t.joint)) && !going.has(o.id))) {
-        /*
-          A sum whose leaders all go is a control of its own over what the sum came to, as one leader's follower is. One
-          whose other leaders stay would follow them and stand still by the rest -- what it should then be is not said, so
-          it is refused by name rather than made up.
-        */
-        const staying = figureMimicLeadersOf(f).filter(t => !going.has(t.joint));
-        if (staying.length)
-            fail('PART_FOLLOWED', part, `${f.id} follows ${staying.map(t => t.joint).join(', ')} as well as a joint that goes with ${part}; make ${f.id} follow only the joints that stay first`);
-        const terms = figureMimicLeadersOf(f).map(t => {
-            const leader = joints.find(o => o.id === t.joint);
-            const quantity = nodeById(m, `${leader.body1.part}.motion`)?.args[3] ?? stateIdOf(leader);
-            const state = m.inputs.find((i) => i.id === stateIdOf(leader));
-            const distance = (value) => Number(graph.evaluate(inputs({ [stateIdOf(leader)]: value })).values[quantity]);
-            const [a, b] = [distance(state?.min ?? 0) * t.multiplier, distance(state?.max ?? 1) * t.multiplier];
-            return { lo: Math.min(a, b), hi: Math.max(a, b), now: Number(now[quantity]) * t.multiplier };
-        });
-        const turn = f.type === 'revolute';
-        const toUnit = (base) => round6(turn ? (base * 180) / Math.PI : base);
-        const offset = (f.mimic.offset ?? 0) * (turn ? Math.PI / 180 : 1);
-        /*
-          Each leader moves on its own control, so the sum's least and greatest are each term's, added (a negative multiplier
-          swaps a term's ends, above). When leaders are driven by one upstream input -- not the case today, a leader leads
-          itself -- the summed range is conservative: it holds every value the sum can take, not the exact reach.
-        */
-        const total = (pick) => toUnit(terms.reduce((sum, t, i) => (i ? sum + pick(t) : pick(t)), 0) + offset);
-        const [lo, hi] = [total(t => t.lo), total(t => t.hi)];
-        let id = f.body1.part;
-        for (let n = 2; taken.has(id); n++)
-            id = `${f.body1.part}-${n}`;
-        taken.add(id);
-        const start = Math.min(hi, Math.max(lo, total(t => t.now)));
-        const { mimic: _led, travel: _share, ...alone } = f;
-        joints = joints.map(o => o.id === f.id ? { ...alone, lowerLimit: lo, upperLimit: hi, state: { ...(f.state ?? {}), id, start } } : o);
-        notice.controls.push({ part: f.body1.part, control: id, min: lo, max: hi });
-    }
-    /*
-      A value in a record that followed the part: the number it is now -- at the stored design inputs (above). In a sum, each term that reads the part becomes
-      its number, added to the margin, and the terms that read something else still follow; no term left, the number.
-    */
-    const freezeMeasure = (measure, where) => {
-        const f = followedTermsOf(measure);
-        if (!f || !f.terms.some(t => t.from?.of === 'part' && t.from.part === part))
-            return measure;
-        const probe = structuredClone(m);
-        let frozen = 0;
-        const rest = [];
-        for (const t of f.terms) {
-            if (!(t.from.of === 'part' && t.from.part === part)) {
-                rest.push(t);
-                continue;
-            }
-            const ref = stableDimension(probe, part, t.from.axis, where);
-            frozen += Number(compileFigureGraph(probe).evaluate(inputs()).values[ref]) * (t.times ?? 1);
-        }
-        if (!rest.length) {
-            const value = round6(frozen + f.plus);
-            notice.fixed.push({ part: where, value, unit: 'mm' });
-            return value;
-        }
-        notice.fixed.push({ part: where, value: round6(frozen), unit: 'mm' });
-        return { sum: rest, ...(round6(frozen + f.plus) ? { plus: round6(frozen + f.plus) } : {}) };
-    };
-    joints = joints.map(j => {
-        if (j.id === own?.id || children.includes(j))
-            return j;
-        const out = structuredClone(j);
-        for (const { get, set } of jointMeasures(out)) {
-            const was = get();
-            const fixed = freezeMeasure(was, j.body1.part);
-            if (fixed !== was)
-                set(fixed);
-        }
-        return out;
-    });
-    /*
-      What reads a value that goes -- where the part, or a part let go of, is fastened (its joint's nodes), or where it is
-      drawn -- and is not the space (fitted again, or refused above): the number it is now. Values the part shares with
-      another (a shape two placements draw) stay, as before; they do not go.
-    */
-    const jointNodes = (p) => (n) => n.id.startsWith(`${p}.on.`) || n.id.startsWith(`${p}.row`) || [`${p}.seat.rigid`, `${p}.chain`, `${p}.world`, `${p}.turned`, `${p}.motion`, `${p}.layout`, `${p}.assembly`, `${p}.repeat`].includes(n.id);
-    const leaving = [part, ...children.map(j => j.body1.part)];
-    const goingNodes = new Set(m.nodes.filter(n => leaving.some(p => jointNodes(p)(n))).map(n => n.id));
-    const goingRefs = new Set(m.nodes.filter(n => goingNodes.has(n.id)).flatMap(n => Object.values(n.outputs)));
-    const types = graph.outputTypes;
-    const live = liveRefsOf(a);
-    const space = spaceOnlyNodesOf(a);
-    const partOf = (id) => String(id).split('.')[0];
-    for (const n of m.nodes) {
-        /* The parts leaving are released below; a row's copies are gathered again from the records. */
-        if (goingNodes.has(n.id) || leaving.includes(partOf(n.id)) || n.op === 'assembly@1' || space.has(n.id) || !Object.values(n.outputs).some(o => live.has(o)))
-            continue;
-        /* A joint's own nodes are made again from its record, from where its parent stands then. */
-        if (joints.some(j => jointNodes(j.body1.part)(n)))
-            continue;
-        n.args = n.args.map((ref, i) => {
-            if (!goingRefs.has(ref))
-                return ref;
-            const unit = baseUnitOf(types[ref]);
-            const value = now[ref];
-            if (typeof value === 'number' && unit) {
-                notice.fixed.push({ part: partOf(n.id), value: round6(unit === 'rad' ? (value * 180) / Math.PI : value), unit: unit === 'rad' ? 'deg' : unit });
-                return constantOf(m, unit, round6(value) + 0, 'fixed');
-            }
-            const pose = value;
-            const type = types[ref];
-            if (pose?.r && pose.t && type?.kind === 'transform') {
-                const id = namer(m, `${n.id}.fixed`)(`pose.${i}`);
-                const [rx, ry, rz] = eulerXYZ(pose.r);
-                m.nodes.push({ id, op: 'rigid@1', args: [...pose.t.map(v => constantOf(m, 'mm', round6(v) + 0, 'fixed')), ...[rx, ry, rz].map(v => constantOf(m, 'rad', round6((v * Math.PI) / 180), 'fixed'))], outputs: { pose: `${id}.value` }, params: { from: type.from, to: type.to } });
-                notice.fixed.push({ part: partOf(n.id), value: 0, unit: 'pose' });
-                return `${id}.value`;
-            }
-            fail('PART_REFERENCED', part, `${partOf(n.id)} reads ${part}'s ${ref}, which cannot be written as a number`);
-        });
-    }
-    /* What hung from it: where it stood at rest, fastened to nothing. */
-    const standing = new Map(children.map(j => [j.body1.part, atRest[nodeById(m, j.body1.part).args[1]]]));
-    a.joints = joints.filter(j => j.id !== own?.id && !children.includes(j));
-    if (!a.joints.length)
-        delete a.joints;
-    for (const j of children) {
-        const child = j.body1.part;
-        const control = j.type !== 'fixed' && !j.mimic ? stateIdOf(j) : undefined;
-        stripJoint(a, j);
-        const at = standing.get(child);
-        const pose = nodeById(m, `${child}.pose`);
-        const turn = eulerXYZ(at.r);
-        const values = [...at.t.map(v => round6(v) + 0), ...turn];
-        const old = pose.args.slice(0, 6);
-        pose.args = [...AXES.map(axis => `${child}.position.${axis}`), ...AXES.map(axis => `${child}.rotation.${axis}`)].map((id, i) => {
-            if (!m.inputs.some((n) => n.id === id))
-                m.inputs.push({ id, unit: i < 3 ? 'mm' : 'deg', min: -Number.MAX_VALUE, max: Number.MAX_VALUE, role: 'design' });
-            a.designInputs[id] = values[i];
-            return id;
-        });
-        for (const ref of old)
-            if (!pose.args.includes(ref))
-                dropIfUnused(a, ref, ownInput(m, child, ref) ? ref : undefined);
-        notice.released.push({ part: child, ...(control ? { control } : {}) });
-    }
-    /*
-      A control goes with its joint once nothing reads it -- read only after every part is let go of: a lamp and the shade
-      that followed it, both released, left the lamp's control behind while the shade still read it (2026-09-27).
-    */
-    const readAnywhere = (id) => m.nodes.some((n) => n.args.includes(id) || stringsIn(n.params).includes(id)) || stringsIn(a.occupancy).includes(id) || stringsIn(a.document.capabilities).includes(id);
-    for (const r of notice.released) {
-        if (!r.control)
-            continue;
-        if (readAnywhere(r.control)) {
-            delete r.control;
-            continue;
-        }
-        const id = r.control;
-        m.inputs = m.inputs.filter((i) => i.id !== id);
-        delete a.stateDefaults[id];
-        delete a.designInputs[id];
-        /* Its clip and its label go with it, as a motion's do (removeMotion). */
-        if (a.drivers)
-            a.drivers = a.drivers.filter((d) => d.state !== id);
-        if (a.drivers && !a.drivers.length)
-            delete a.drivers;
-        if (a.stateInputs?.[id]) {
-            const { [id]: _gone, ...rest } = a.stateInputs;
-            if (Object.keys(rest).length)
-                a.stateInputs = rest;
-            else
-                delete a.stateInputs;
-        }
-    }
-    if (own)
-        stripJoint(a, own);
-    dropDeadDanglers(a);
-    if (a.joints?.length)
-        rewriteJoints(a);
-    return notice;
-}
-/**
- * The nodes that make the declared space and nothing else: reached from what \`occupancy\` names, not from any drawn
- * body, record or binding. Named by what they do, not by their names -- an older fitting named them \`occ.*\`
- * (FORKLIFT), a still older one left some the declaration no longer reaches (WALL_LAMP), and a part's own chain the
- * space also reads is the part's (2026-09-27).
- */
-export function spaceOnlyNodesOf(asset) {
-    const a = asset;
-    const m = a.document.model;
-    const reach = (from) => {
-        const seen = new Set();
-        for (const pending = [...from]; pending.length;) {
-            const writer = writerOf(m, pending.pop());
-            if (!writer || seen.has(writer.id))
-                continue;
-            seen.add(writer.id);
-            pending.push(...writer.args, ...stringsIn(writer.params));
-        }
-        return seen;
-    };
-    const drawn = reach([
-        ...m.nodes.filter((n) => n.op === 'place@1' || n.op === 'repeat@1').flatMap((n) => Object.values(n.outputs)),
-        ...stringsIn(a.appearance),
-        ...stringsIn(a.document.capabilities),
-        ...stringsIn(a.drivers),
-        ...stringsIn(a.publicInputs),
-        ...stringsIn(a.joints)
-    ]);
-    return new Set([...reach(stringsIn(a.occupancy))].filter(id => !drawn.has(id)));
-}
-/**
- * A node no drawn body, declaration or record reaches, reading a value that is gone: an earlier fitting's space left
- * reading a joint's node that went with its part (WALL_LAMP's shade, 2026-09-27). It was read by nothing before, and it
- * goes with what it read. A node something does reach is left, and the figure is refused as broken.
- */
-export function dropDeadDanglers(asset) {
-    const model = asset.document.model;
-    const strings = (v) => typeof v === 'string' ? [v] : Array.isArray(v) ? v.flatMap(strings) : v && typeof v === 'object' ? Object.values(v).flatMap(strings) : [];
-    for (;;) {
-        const written = new Set([...model.nodes.flatMap(n => Object.values(n.outputs)), ...model.inputs.map(i => i.id), ...model.constants.map(c => c.id)]);
-        const live = new Set();
-        const pending = [
-            ...model.nodes.filter(n => n.op === 'place@1' || n.op === 'repeat@1').flatMap(n => Object.values(n.outputs)),
-            ...strings(asset.appearance),
-            ...strings(asset.occupancy),
-            ...strings(asset.document.capabilities),
-            ...strings(asset.drivers),
-            ...strings(asset.publicInputs),
-            ...strings(asset.joints)
-        ];
-        while (pending.length) {
-            const ref = pending.pop();
-            if (live.has(ref))
-                continue;
-            live.add(ref);
-            const writer = model.nodes.find(n => Object.values(n.outputs).includes(ref));
-            if (writer)
-                pending.push(...writer.args, ...strings(writer.params));
-        }
-        const dead = model.nodes.filter(n => n.args.some(a => !written.has(a)) && !Object.values(n.outputs).some(o => live.has(o)));
-        if (!dead.length)
-            return;
-        model.nodes = model.nodes.filter(n => !dead.includes(n));
-    }
-}
-/** Every value a drawn body, a declaration or a record reaches, however far up. */
-export function liveRefsOf(asset) {
-    const a = asset;
-    const m = a.document.model;
-    const live = new Set();
-    const pending = [
-        ...m.nodes.filter((n) => n.op === 'place@1' || n.op === 'repeat@1').flatMap((n) => Object.values(n.outputs)),
-        ...stringsIn(a.appearance),
-        ...stringsIn(a.occupancy),
-        ...stringsIn(a.document.capabilities),
-        ...stringsIn(a.drivers),
-        ...stringsIn(a.publicInputs),
-        ...stringsIn(a.joints)
-    ];
-    while (pending.length) {
-        const ref = pending.pop();
-        if (live.has(ref))
-            continue;
-        live.add(ref);
-        const writer = writerOf(m, ref);
-        if (writer)
-            pending.push(...writer.args, ...stringsIn(writer.params));
-    }
-    return live;
-}
-function setJoint(asset, joint) {
-    // As JSON: a field left undefined is a field not there, which is how the asset stores it.
-    const j = JSON.parse(JSON.stringify(joint ?? null));
-    checkJoint(asset, j);
-    /* The child's own quarter turn becomes the record's, the first time it is fastened. */
-    if (!jointAbove(asset, j.body1.part) && !j.origin?.turn) {
-        const turn = turnOf(asset.document.model, asset, j.body1.part, j.body1.part);
-        /* A part turned by any angle about the normal of the face it is fastened by keeps that angle as its twist. */
-        const n = AXES.indexOf(FIGURE_FACES[childFaceOf(asset.document.model, j)]);
-        const quarter = (t) => t !== null && Number.isFinite(t) && Math.abs(t / 90 - Math.round(t / 90)) < 1e-9;
-        const twist = !quarter(turn[n]) && turn.every((t, i) => i === n || t === 0) ? turn[n] : undefined;
-        if (twist !== undefined && !j.origin?.twist)
-            j.origin = { ...(j.origin ?? {}), twist };
-        else if (turn.some(t => t !== 0))
-            j.origin = { ...(j.origin ?? {}), turn: Object.fromEntries(AXES.map((a, i) => [a, turn[i]])) };
-    }
-    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`);
-    asset.joints = [...joints, j];
-    rewriteJoints(asset);
-}
-/** The joint goes; its child keeps where it stands now, as plain position numbers. */
-/**
- * Where what refers to a face an edit takes away goes instead (ADR-0100 A8): a joint re-pointed to another face of
- * the part, or let go where it stands (`detach`, a joint only); a named face moved to another face -- a capability
- * hangs on it, so it is never let go. Applied before the edit, in the same command: one step of the history. The new
- * faces must be the part's after the edit; `keepReferencedFaces` refuses one that is not.
- */
-function applyFaceRemap(asset, part, remap) {
-    if (!remap?.length)
-        return;
-    const faces = new Set();
-    const shapeOutput = asset.document.model.nodes.find((o) => o.id === `${part}.shape`)?.outputs?.shape;
-    const faceOf = (to, path) => {
-        const face = typeof to?.face === 'string' ? to.face.trim() : '';
-        if (!face)
-            fail('SCHEMA', `${path}.to`, `a face of ${part}, or 'detach'`);
-        return face;
-    };
-    for (const [i, r] of remap.entries()) {
-        const path = `remap.${i}`;
-        if (r?.ref?.kind === 'joint') {
-            const j = (asset.joints ?? []).find(o => o.id === r.ref.id);
-            if (!j || !(j.body0?.part === part || j.body1?.part === part))
-                fail('EDIT_TARGET', path, `${r.ref.id} is not a joint on ${part}`);
-            if (r.to === 'detach') {
-                removeJoint(asset, j.id);
-                continue;
-            }
-            const face = faceOf(r.to, path);
-            if (j.body0?.part === part)
-                j.body0.face = face;
-            else
-                j.body1.face = face;
-            faces.add(face);
-        }
-        else if (r?.ref?.kind === 'feature') {
-            const n = asset.document.model.nodes.find((o) => o.id === r.ref.id && o.op === 'feature@1');
-            if (!n || n.args[0] !== shapeOutput)
-                fail('EDIT_TARGET', path, `${r.ref.id} is not a named face of ${part}`);
-            if (r.to === 'detach')
-                fail('SCHEMA', `${path}.to`, `a named face moves to another face; a capability hangs on it, so it is not let go`);
-            const face = faceOf(r.to, path);
-            n.params = { ...n.params, name: face };
-            faces.add(face);
-        }
-        else
-            fail('SCHEMA', `${path}.ref`, `{ kind: 'joint' | 'feature', id }`);
-    }
-    remappedFaces.set(asset, faces);
-}
-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));
-    if (followers.length)
-        fail('JOINT_SCHEMA', `joints.${id}`, `${followers.map(f => f.id).join(', ')} follow ${id}; remove them first`);
-    const m = asset.document.model;
-    const child = j.body1.part;
-    const evaluated = compileFigureAssetUnjointed(asset).evaluate();
-    const placed = nodeById(m, child);
-    const at = evaluated.values?.[placed.args[1]];
-    if (!at?.t)
-        fail('TARGET_ABSENT', child, `${child} has no pose to read`);
-    const own = m.nodes.find((n) => n.id === `${child}.pose`);
-    const turned = (r, want) => r.some((row, i) => row.some((v, k) => Math.abs(v - want[i][k]) > 1e-9));
-    const ownTurn = evaluated.values?.[own.outputs.pose]?.r;
-    if (ownTurn && turned(at.r, ownTurn))
-        fail('EDIT_TARGET', child, `${child} stands turned by what it hangs from; taking the joint away would turn it`);
-    asset.joints = joints.filter(o => o.id !== id);
-    stripJoint(asset, j);
-    const translation = AXES.map((axis, i) => {
-        const input = `${child}.position.${axis}`;
-        const value = round6(at.t[i]);
-        if (!m.inputs.some((n) => n.id === input))
-            m.inputs.push({ id: input, unit: 'mm', min: -Number.MAX_VALUE, max: Number.MAX_VALUE, role: 'design' });
-        asset.designInputs[input] = value;
-        return input;
-    });
-    own.args = [...translation, ...own.args.slice(3)];
-    // Parts hanging from it are written again: they hang from where it stands now.
-    rewriteJoints(asset);
-}
-/** `attach` is the modeller's word for a fixed joint: the record says it, whatever joint was there keeps its id and motion. */
-function fastenAsJoint(asset, a) {
-    const was = jointAbove(asset, a.part);
-    if (was && !a.replace)
-        fail('ATTACH_REPLACED', a.part, `${a.part} is already fastened by ${was.id}; pass replace to move it, or detach it first`);
-    const to = a.to;
-    /*
-      A new record is named after its part -- unless another joint already has that name: a robot arm's finger joint
-      was named `gripper`, and fastening the gripper wrote over it (2026-09-25). The first free name after it is taken.
-    */
-    const taken = new Set((asset.joints ?? []).map(j => j.id));
-    let id = a.part;
-    for (let k = 2; !was && taken.has(id); k++)
-        id = `${a.part}-${k}`;
-    setJoint(asset, {
-        ...(was ?? { id, type: 'fixed' }),
-        body0: to?.plane !== undefined ? { plane: to.plane } : { part: to?.part, face: to?.face },
-        body1: { part: a.part, face: a.face },
-        origin: {
-            ...(was?.origin?.turn ? { turn: was.origin.turn } : {}),
-            ...(a.twist !== undefined ? a.twist ? { twist: a.twist } : {} : was?.origin?.twist ? { twist: was.origin.twist } : {}),
-            ...(a.facing ? { facing: a.facing } : {}),
-            ...(a.gap !== undefined ? { gap: a.gap } : {}),
-            ...(a.align ? { align: a.align } : {})
-        }
-    });
-}
-/**
- * The records are the canon: made again from them, the joints' nodes must be the nodes the asset holds. An asset
- * whose nodes or records were edited apart is refused, not quietly rebuilt (ADR-0093, chief architect's condition).
- */
-export function checkFigureJoints(asset) {
-    const joints = asset.joints;
-    if (!joints?.length)
-        return;
-    const again = structuredClone(asset);
-    for (const j of joints)
-        checkJoint({ ...again, joints: joints.filter(o => o.id !== j.id).concat(j) }, j);
-    rewriteJoints(again);
-    const canon = (model) => JSON.stringify({
-        nodes: [...model.nodes].sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0)),
-        inputs: [...model.inputs].sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0))
-    });
-    if (canon(again.document.model) !== canon(asset.document.model))
-        fail('JOINT_DRIFT', 'joints', "the joints' nodes are not what their records make; the asset was edited apart from its joints");
-}
-/** The frame a part is fastened into: its parent's, or the asset's. */
-const attachmentFrameOf = (asset, id) => {
-    const parent = parentOf(asset.document.model, id);
-    return parent ? `${parent}.local` : asset.document.capabilities.assetFrame;
-};
-function addMotion(asset, a, follow, sign = 1) {
-    const m = asset.document.model;
-    const path = a.part;
-    partOf(m, a.part, path);
-    if (!a.motion || (a.motion.kind !== 'slide' && a.motion.kind !== 'turn'))
-        fail('SCHEMA', path, 'a slide or a turn is required');
-    if (!AXES.includes(a.motion.axis))
-        fail('SCHEMA', path, `${String(a.motion.axis)} is not an axis`);
-    if (nodeById(m, `${a.part}.motion`) && !a.replace)
-        fail('MOTION_REPLACED', path, `${a.part} already moves; pass replace to change how, or remove the motion first`);
-    if (nodeById(m, `${a.part}.motion`))
-        removeMotion(asset, { kind: 'remove-motion', part: a.part });
-    const frame = a.motion.frame ?? 'attachment';
-    const seatedIn = attachmentFrameOf(asset, a.part);
-    if (frame === 'asset' && seatedIn !== asset.document.capabilities.assetFrame)
-        fail('MOTION_FRAME', path, `${a.part} is fastened into ${seatedIn}; an axis in the asset frame would have to be re-expressed there, which this command does not do`);
-    else if (frame !== 'attachment' && frame !== 'asset')
-        fail('SCHEMA', path, `${String(frame)} is not a frame for the axis`);
-    const st = a.state;
-    const name = namer(m, `${a.part}.motion`);
-    let quantity = st?.id;
-    if (follow) {
-        /*
-          A mimic: the leader's value times k plus c, and no control of its own. A sum is each leader's value times its own
-          k, added up, then c -- written with the same mul@1 and add@1 a one-leader mimic is, so a pose step runs it as it
-          runs that (ADR-0108), and the gate reads it by the same operators.
-        */
-        if (!follow.sum) {
-            const scaledId = name('mimic');
-            m.nodes.push({ id: scaledId, op: 'mul@1', args: [follow.terms[0].of, constantOf(m, 'ratio', follow.terms[0].k, 'k')], outputs: { value: `${scaledId}.value` } });
-            quantity = `${scaledId}.value`;
-        }
-        else
-            for (const [i, t] of follow.terms.entries()) {
-                const scaledId = name(`mimic.${i}`);
-                m.nodes.push({ id: scaledId, op: 'mul@1', args: [t.of, constantOf(m, 'ratio', t.k, 'k')], outputs: { value: `${scaledId}.value` } });
-                if (!i)
-                    quantity = `${scaledId}.value`;
-                else {
-                    const added = name(`mimic.${i}.sum`);
-                    m.nodes.push({ id: added, op: 'add@1', args: [quantity, `${scaledId}.value`], outputs: { value: `${added}.value` } });
-                    quantity = `${added}.value`;
-                }
-            }
-        if (follow.c) {
-            const plus = name('mimic.offset');
-            /* The offset is in the follower's own unit: millimetres for a slide, degrees for a turn. */
-            const unitOf = a.motion.kind === 'slide' ? 'mm' : 'deg';
-            m.nodes.push({ id: plus, op: 'add@1', args: [quantity, constantOf(m, unitOf, follow.c, 'd')], outputs: { value: `${plus}.value` } });
-            quantity = `${plus}.value`;
-        }
-    }
-    else {
-        if (!st || typeof st.id !== 'string' || !st.id.trim())
-            fail('SCHEMA', path, 'a state input id is required');
-        const same = m.inputs.find((i) => i.id === st.id && i.role === 'state' && i.unit === st.unit && i.min === st.min && i.max === st.max);
-        if (same) {
-            /*
-              The same control, written again: the joint's nodes are made again from its record, and the control stays -- a
-              lamp shown while it is at least so much still reads it, and a value a board wrote keeps its meaning.
-            */
-        }
-        else if (m.inputs.some((i) => i.id === st.id)) {
-            /*
-              A control nothing reads any more -- its part re-made, its lamp moved to another -- is taken over under its name,
-              so what a connector or a board writes to it keeps arriving. One something still reads is refused.
-            */
-            const read = m.nodes.some((n) => n.args.includes(st.id)) ||
-                (asset.drivers ?? []).some((d) => d.state === st.id) ||
-                asset.appearance.some((look) => look.visibility === st.id);
-            if (read)
-                fail('DUPLICATE_WRITER', path, `${st.id} already exists`);
-            m.inputs = m.inputs.filter((i) => i.id !== st.id);
-            delete asset.stateDefaults[st.id];
-            if (asset.stateInputs?.[st.id]) {
-                const { [st.id]: _gone, ...rest } = asset.stateInputs;
-                asset.stateInputs = rest;
-            }
-        }
-        const wanted = a.motion.kind === 'turn' ? ['deg'] : ['mm', 'ratio'];
-        if (!wanted.includes(st.unit))
-            fail('SCHEMA', path, `a ${a.motion.kind} takes a ${wanted.join(' or ')} control, not ${String(st.unit)}`);
-        if (!(Number.isFinite(st.min) && Number.isFinite(st.max) && st.max > st.min))
-            fail('SCHEMA', path, 'a range with max above min is required');
-        const start = st.start ?? st.min;
-        if (!(start >= st.min && start <= st.max))
-            fail('SCHEMA', path, 'the starting value is outside the range');
-        if (!same) {
-            m.inputs.push({ id: st.id, unit: st.unit, min: st.min, max: st.max, role: 'state' });
-            asset.stateDefaults[st.id] = start;
-        }
-        if (st.label !== undefined || st.sweep !== undefined) {
-            asset.stateInputs = { ...(asset.stateInputs ?? {}) };
-            asset.stateInputs[st.id] = { ...(st.label !== undefined ? { label: st.label } : {}), ...(st.sweep !== undefined ? { sweep: st.sweep } : {}) };
-        }
-    }
-    if (a.motion.kind === 'slide' && st.unit === 'ratio') {
-        if (!a.travel)
-            fail('SCHEMA', path, 'a ratio control needs travel: how far the part goes at 1');
-        const travel = a.travel;
-        let length;
-        if (Object.hasOwn(travel, 'sum')) {
-            /* A stroke that is a sum of lengths: the terms added, then the margin, as any followed length (ADR-0107). */
-            const plus = travel.plus ?? 0;
-            length = scaled(m, name, sumOf(m, name, termRefs(m, asset, travel.sum, plus, `${path}.travel`), 'travel.sum'), 1, plus, 'travel');
-        }
-        else {
-            const base = travel.source ? sourceRef(m, asset, travel.source, path) : constantOf(m, 'mm', travel.plus ?? 0, 'd');
-            length = travel.source ? scaled(m, name, base, travel.times ?? 1, travel.plus ?? 0, 'travel') : base;
-        }
-        const id = name('distance');
-        m.nodes.push({ id, op: 'mul@1', args: [quantity, length], outputs: { value: `${id}.value` } });
-        quantity = `${id}.value`;
-    }
-    else if (a.motion.kind === 'slide' && a.travel)
-        fail('SCHEMA', path, 'a mm control is the distance; travel would say it twice');
-    const unit = AXES.map(x => constantOf(m, 'ratio', x === a.motion.axis ? sign : 0, 'axis'));
-    m.nodes.push({
-        id: `${a.part}.motion`,
-        op: a.motion.kind === 'slide' ? 'axis-slide@1' : 'axis-turn@1',
-        args: [...unit, quantity],
-        outputs: { pose: `${a.part}.motion.value` },
-        params: { from: `${a.part}.seat`, to: seatedIn }
-    });
-    reseat(asset, a.part, seatedIn);
-    if (a.clip) {
-        const c = a.clip;
-        if (typeof c.name !== 'string' || !c.name.trim())
-            fail('SCHEMA', path, 'a clip is named');
-        if (!(Number.isFinite(c.duration) && c.duration > 0))
-            fail('SCHEMA', path, 'a clip runs for a positive number of seconds');
-        asset.drivers = [...(asset.drivers ?? []), { id: `${a.part}/${c.name}`, clip: c.name, state: st.id, time: { unit: 's', duration: c.duration }, keys: structuredClone(c.keys), interpolation: 'linear', loop: c.loop ?? 'wrap', accumulates: c.accumulates ?? false }];
-    }
-    return asset;
-}
-/** "This part does not move any more." The control it created goes with it, and so does its clip. */
-function removeMotion(asset, a) {
-    const m = asset.document.model;
-    const motion = nodeById(m, `${a.part}.motion`);
-    if (!motion)
-        fail('EDIT_TARGET', a.part, `${a.part} does not move`);
-    const quantity = motion.args[3];
-    const to = nodeById(m, `${a.part}.seat.rigid`)?.params?.to ?? motion.params.to;
-    // Which control this motion introduced, read before the nodes that name it are taken away.
-    const state = m.inputs.find((i) => i.id === quantity && i.role === 'state')
-        ?? m.inputs.find((i) => i.role === 'state' && (writerOf(m, quantity)?.args ?? []).includes(i.id));
-    m.nodes = m.nodes.filter((n) => n !== motion);
-    reseat(asset, a.part, to);
-    dropIfUnused(asset, quantity, quantity);
-    if (state && !m.nodes.some((n) => n.args.includes(state.id))) {
-        m.inputs = m.inputs.filter((i) => i !== state);
-        delete asset.stateDefaults[state.id];
-        if (asset.stateInputs)
-            delete asset.stateInputs[state.id];
-        if (asset.drivers)
-            asset.drivers = asset.drivers.filter((d) => d.state !== state.id);
-        if (asset.drivers && !asset.drivers.length)
-            delete asset.drivers;
-        if (asset.stateInputs && !Object.keys(asset.stateInputs).length)
-            delete asset.stateInputs;
-    }
-    return asset;
-}
-/** A figure as one value, for saying "this is the figure I read". The declaration itself is left out of it. */
-function fingerprintOf(asset) {
-    /* The room and the placement are left out: neither changes what the room would measure (ADR-0097). */
-    const text = JSON.stringify({ ...asset, placement: undefined, occupancy: asset.occupancy ? { ...asset.occupancy, bounds: null } : undefined });
-    let h1 = 0x811c9dc5;
-    let h2 = 0x01000193;
-    for (let i = 0; i < text.length; i++) {
-        h1 = Math.imul(h1 ^ text.charCodeAt(i), 0x01000193) >>> 0;
-        h2 = Math.imul(h2 + text.charCodeAt(i), 0x85ebca6b) >>> 0;
-    }
-    return `${h1.toString(16).padStart(8, '0')}${h2.toString(16).padStart(8, '0')}:${text.length}`;
-}
-const linAdd = (a, b, k = 1) => ({ terms: [...a.terms, ...b.terms.map(t => ({ ref: t.ref, k: t.k * k }))], c: a.c + b.c * k });
-/** The same sum with each reference once. */
-const linNorm = (a) => {
-    const by = new Map();
-    for (const t of a.terms)
-        by.set(t.ref, (by.get(t.ref) ?? 0) + t.k);
-    return { terms: [...by].filter(([, k]) => k !== 0).map(([ref, k]) => ({ ref, k })), c: a.c };
-};
-/** A sum at least as large as either, where every reference is a size (never below zero): term by term, the larger. */
-const linAtLeast = (a, b) => {
-    const by = new Map();
-    for (const t of [...linNorm(a).terms, ...linNorm(b).terms])
-        by.set(t.ref, Math.max(by.get(t.ref) ?? 0, t.k));
-    return { terms: [...by].map(([ref, k]) => ({ ref, k })), c: Math.max(a.c, b.c) };
-};
-const linOf = (m, ref) => {
-    const constant = m.constants.find((c) => c.id === ref);
-    return constant ? { terms: [], c: constant.value } : { terms: [{ ref, k: 1 }], c: 0 };
-};
-/**
- * The same sum read back through the sums and scalings that make it up, down to what no command rewrites: the inputs,
- * and values that are not a sum (a row's count). A declared room that read a node a joint writes -- where a leg stands,
- * a share of the figure's depth -- was broken by the next fastening, which writes that joint's nodes afresh: the gantry
- * could not be re-fastened once its room was declared (UNKNOWN_REFERENCE, 2026-09-25).
- */
-function linThroughSums(m, lin) {
-    const constant = (ref) => m.constants.find((c) => c.id === ref)?.value;
-    const ratio = (ref) => m.constants.find((c) => c.id === ref && c.unit === 'ratio')?.value;
-    const expand = (ref, k, depth) => {
-        const c = constant(ref);
-        if (c !== undefined)
-            return { terms: [], c: c * k };
-        const w = depth < 256 ? writerOf(m, ref) : undefined;
-        if (w?.op === 'add@1')
-            return w.args.reduce((sum, arg) => linAdd(sum, expand(arg, k, depth + 1)), { terms: [], c: 0 });
-        /* Only a length times a ratio: what is left is then a length, as each term of the room must be. */
-        if (w?.op === 'mul@1') {
-            const [a, b] = w.args;
-            if (ratio(b) !== undefined)
-                return expand(a, k * ratio(b), depth + 1);
-            if (ratio(a) !== undefined)
-                return expand(b, k * ratio(a), depth + 1);
-        }
-        return { terms: [{ ref, k }], c: 0 };
-    };
-    return linNorm(lin.terms.reduce((sum, t) => linAdd(sum, expand(t.ref, t.k, 0)), { terms: [], c: lin.c }));
-}
-/**
- * How far a slide has gone when its control is at one end of its range, as a sum: each control at that end, what the
- * figure's sizes make of the rest. A mimic of a leader whose stroke follows a length is the leader's ratio times that
- * length times its multiplier -- read through, not refused: the telescopic conveyor's second and third stages were
- * left out of its declared room, 2600 and 5200 mm past it (2026-09-25).
- */
-function travelAt(m, asset, motion, bound) {
-    const pick = (i) => bound === 'start' ? (asset.stateDefaults[i.id] ?? i.min) : bound === 'min' ? i.min : i.max;
-    const constant = (r) => m.constants.find((c) => c.id === r)?.value;
-    const stateOf = (r) => m.inputs.find((i) => i.id === r && i.role === 'state');
-    /* A value no control reaches: it is the same at either end, so it stays a term of the sum. */
-    const still = (ref, depth = 0) => {
-        if (stateOf(ref))
-            return false;
-        const w = depth < 256 ? writerOf(m, ref) : undefined;
-        return !w || w.args.every((a) => typeof a !== 'string' || still(a, depth + 1));
-    };
-    const read = (ref, depth = 0) => {
-        const c = constant(ref);
-        if (c !== undefined)
-            return { terms: [], c };
-        const state = stateOf(ref);
-        if (state)
-            return { terms: [], c: pick(state) };
-        const w = depth < 256 ? writerOf(m, ref) : undefined;
-        if (w?.op === 'add@1') {
-            let out = { terms: [], c: 0 };
-            for (const arg of w.args) {
-                const l = read(arg, depth + 1);
-                if (!l)
-                    return null;
-                out = linAdd(out, l);
-            }
-            return out;
-        }
-        if (w?.op === 'mul@1' && w.args.length === 2) {
-            /* A ratio times a length (the one ratio's size, u × x₀) is kept whole: the sum's terms stay lengths. */
-            const known = (arg) => m.constants.find((c) => c.id === arg);
-            if (!w.args.every(known) && w.args.some(arg => known(arg) && known(arg).unit !== 'ratio'))
-                return still(ref) ? { terms: [{ ref, k: 1 }], c: 0 } : null;
-            const [a, b] = w.args.map(arg => read(arg, depth + 1));
-            if (!a || !b)
-                return null;
-            // One side a number: a product of two sizes is not a length.
-            if (!a.terms.length)
-                return linAdd({ terms: [], c: 0 }, b, a.c);
-            if (!b.terms.length)
-                return linAdd({ terms: [], c: 0 }, a, b.c);
-            return null;
-        }
-        return still(ref) ? { terms: [{ ref, k: 1 }], c: 0 } : null;
-    };
-    return read(motion.args[3]);
-}
-const zeroVec = () => ({ x: { terms: [], c: 0 }, y: { terms: [], c: 0 }, z: { terms: [], c: 0 } });
-/** A vector of sums turned by a quarter turn (a signed axis permutation). */
-const turnVec = (r, v) => Object.fromEntries(AXES.map((a, i) => [a, AXES.reduce((sum, b, j) => (r[i][j] ? linAdd(sum, v[b], r[i][j]) : sum), { terms: [], c: 0 })]));
-const isQuarter = (t) => t !== null && Number.isFinite(t) && Math.abs(t / 90 - Math.round(t / 90)) < 1e-9;
-/** A part's own turn: none, a quarter turn, or one this command cannot add up (any other angle, or not a number). */
-function poseTurnOf(m, asset, part) {
-    const pose = nodeById(m, `${part}.pose`);
-    const turn = (pose?.args.slice(3, 6) ?? []).map((ref) => angleOf(m, asset, ref));
-    if (turn.every((t) => t === 0))
-        return null;
-    return turn.every(isQuarter) ? turnMatrix(turn) : 'other';
-}
-/** Whether a part, or anything carrying it, turns on a joint or stands turned by other than quarter turns. */
-function carriedByATurn(m, asset, id) {
-    for (let part = id; part; part = parentOf(m, part)) {
-        if (nodeById(m, `${part}.motion`)?.op === 'axis-turn@1')
-            return true;
-        if (poseTurnOf(m, asset, part) === 'other')
-            return true;
-    }
-    return false;
-}
-/** How a part's own axes lie in the figure's: the quarter turns of it and everything carrying it, composed. */
-function worldTurnOf(m, asset, id) {
-    let c = IDENTITY;
-    for (let part = id; part; part = parentOf(m, part)) {
-        const r = poseTurnOf(m, asset, part);
-        if (r === 'other')
-            return null;
-        if (r)
-            c = mul3(r, c);
-    }
-    return c;
-}
-/**
- * Where a point of a part lies in the figure, as sums, following whatever it is fastened to: its centre, or `from` in
- * its own frame. A part standing a quarter turned turns what it carries -- a valve body on a lying pipe, a hub on its
- * post -- and was refused, those figures left without a room (2026-09-25); another angle still is.
- */
-function centreVec(m, asset, id, bound, from) {
-    let v = from ?? zeroVec();
-    for (let part = id; part; part = parentOf(m, part)) {
-        const pose = nodeById(m, `${part}.pose`);
-        if (!pose)
-            return `${part} has no pose this command can read`;
-        /* A part's own turn turns it about its centre: its centre does not move by it. */
-        if (part !== id || from) {
-            const r = poseTurnOf(m, asset, part);
-            if (r === 'other')
-                return `${part} is turned by other than quarter turns, so what it carries is not a box this command can add up`;
-            if (r)
-                v = turnVec(r, v);
-        }
-        for (const [i, a] of AXES.entries())
-            v[a] = linAdd(v[a], linOf(m, pose.args[i]));
-        const motion = nodeById(m, `${part}.motion`);
-        if (motion) {
-            if (motion.op !== 'axis-slide@1')
-                return `${part} turns, so its reach is not a box this command can add up`;
-            const unit = motion.args.slice(0, 3).map((ref) => m.constants.find((k) => k.id === ref)?.value ?? null);
-            if (unit.some((u) => u === null))
-                return `${part}'s slide axis is not a constant`;
-            if (unit.some((u) => u !== 0)) {
-                const travel = travelAt(m, asset, motion, bound);
-                if (!travel)
-                    return `${part}'s travel is not a distance this command can read`;
-                for (const [i, a] of AXES.entries())
-                    if (unit[i])
-                        v[a] = linAdd(v[a], travel, unit[i]);
-            }
-        }
-        const seat = nodeById(m, `${part}.seat.rigid`);
-        if (seat) {
-            if (seat.args.slice(3, 6).some((ref) => angleOf(m, asset, ref) !== 0))
-                return `${part} is seated turned, which this command does not add up`;
-            for (const [i, a] of AXES.entries())
-                v[a] = linAdd(v[a], linOf(m, seat.args[i]));
-        }
-    }
-    return v;
-}
-/** Where a part's centre is on one axis, as a sum, following whatever it is fastened to. */
-function centreLin(m, asset, id, axis, bound) {
-    const v = centreVec(m, asset, id, bound);
-    return typeof v === 'string' ? v : v[axis];
-}
-/** A value written as a sum of design inputs times constants, or null where it is anything else. */
-function affineOf(m, ref, seen = 0) {
-    if (seen > 64)
-        return null;
-    const constant = m.constants.find((c) => c.id === ref);
-    if (constant)
-        return { terms: [], c: constant.value };
-    if (m.inputs.some((i) => i.id === ref))
-        return { terms: [{ ref, k: 1 }], c: 0 };
-    const writer = writerOf(m, ref);
-    if (writer?.op === 'add@1') {
-        let out = { terms: [], c: 0 };
-        for (const arg of writer.args) {
-            const part = affineOf(m, arg, seen + 1);
-            if (!part)
-                return null;
-            out = linAdd(out, part);
-        }
-        return out;
-    }
-    if (writer?.op === 'mul@1' && writer.args.length === 2) {
-        /* A ratio times a length is kept whole: its terms must stay lengths (the one ratio's size, u × x₀). */
-        const constant = (arg) => m.constants.find((c) => c.id === arg);
-        const ratioTimesLength = !writer.args.every(constant) && writer.args.some((arg) => constant(arg) && constant(arg).unit !== 'ratio');
-        if (ratioTimesLength)
-            return sizeValue(m, ref) ? { terms: [{ ref, k: 1 }], c: 0 } : null;
-        const [a, b] = writer.args.map((arg) => affineOf(m, arg, seen + 1));
-        if (!a || !b)
-            return null;
-        if (!a.terms.length)
-            return linAdd({ terms: [], c: 0 }, b, a.c);
-        if (!b.terms.length)
-            return linAdd({ terms: [], c: 0 }, a, b.c);
-    }
-    /* Not a sum, but a size all the same: the one ratio a figure grows by, read as it is. */
-    if (sizeValue(m, ref))
-        return { terms: [{ ref, k: 1 }], c: 0 };
-    return null;
-}
-/**
- * A value never below zero that is not a sum of inputs: the mean of sizes, or it over a positive number -- the ratio
- * a figure that grows by one ratio grows by (`scaleUniformly`). A turntable made to follow it had its platter and
- * clamps left out of the room, their reach no longer a sum of inputs (2026-09-25).
- */
-function sizeValue(m, ref, seen = 0) {
-    if (seen > 64)
-        return false;
-    const input = m.inputs.find((i) => i.id === ref);
-    if (input)
-        return input.role !== 'state' && input.min >= 0;
-    const w = writerOf(m, ref);
-    const positive = (r) => (m.constants.find((c) => c.id === r)?.value ?? -1) > 0;
-    if (w?.op === 'geomean@1')
-        return w.args.every((a) => sizeValue(m, a, seen + 1));
-    if (w?.op === 'div@1')
-        return sizeValue(m, w.args[0], seen + 1) && positive(w.args[1]);
-    if (w?.op === 'mul@1')
-        return (w.args.length === 2 && ((sizeValue(m, w.args[0], seen + 1) && positive(w.args[1])) || (positive(w.args[0]) && sizeValue(m, w.args[1], seen + 1))));
-    return false;
-}
-/**
- * How long a value can be, at most, as a sum that holds at every design size: each input's coefficient taken
- * positive. Sound only over inputs that are never below zero (sizes), so any other input makes it unreadable.
- */
-function magnitudeOf(m, lin) {
-    let out = { terms: [], c: 0 };
-    for (const t of lin.terms) {
-        const a = affineOf(m, t.ref);
-        if (!a)
-            return null;
-        for (const u of a.terms) {
-            if (!sizeValue(m, u.ref))
-                return null;
-            out = linAdd(out, { terms: [{ ref: u.ref, k: Math.abs(u.k * t.k) }], c: 0 });
-        }
-        out.c += Math.abs(a.c * t.k);
-    }
-    out.c += Math.abs(lin.c);
-    return out;
-}
-/**
- * Where a part carried by a turn can reach: a ball about the point the first turn above it turns about, as wide as
- * every step from there to the part laid end to end, plus the part's own half size on each axis (the triangle
- * inequality -- it holds at every angle and every design size, so it is a bound, not a sample). As a box, that
- * ball is the pivot plus and minus its radius on each axis. Read by the proposal; the release gate still checks
- * the parts against it.
- */
-function reachOf(m, asset, id, ends, freezeless = true) {
-    const chain = [];
-    for (let part = id; part; part = parentOf(m, part))
-        chain.push(part);
-    /* The topmost part that turns on a joint, or stands turned by an angle a box cannot follow (a fan's blade at 120°). */
-    const top = chain.reduce((found, part, i) => nodeById(m, `${part}.motion`)?.op === 'axis-turn@1' || poseTurnOf(m, asset, part) === 'other' ? i : found, -1);
-    if (top < 0)
-        return `${id} is carried by no turn`;
-    let radius = { terms: [], c: 0 };
-    const grow = (lin, what) => {
-        const size = lin && magnitudeOf(m, lin);
-        if (!size)
-            return `${what} is not a sum of sizes, so how far it reaches cannot be bounded`;
-        radius = linAdd(radius, size);
-        return null;
-    };
-    /* Its half size on every axis of its own, whichever way it stands: the ball holds it at any angle. */
-    const sizes = sizeRefsOf(m, id, id);
-    void freezeless;
-    for (const axis of AXES) {
-        const bad = grow({ terms: [{ ref: sizes[axis].ref, k: 0.5 * sizes[axis].k }], c: 0 }, `${id}'s size`);
-        if (bad)
-            return bad;
-    }
-    for (let i = 0; i <= top; i++) {
-        const part = chain[i];
-        const pose = nodeById(m, `${part}.pose`);
-        if (!pose)
-            return `${part} has no pose this command can read`;
-        for (const ref of pose.args.slice(0, 3)) {
-            const bad = grow(linOf(m, ref), `${part}'s place`);
-            if (bad)
-                return bad;
-        }
-        if (i < top) {
-            const seat = nodeById(m, `${part}.seat.rigid`);
-            for (const ref of seat?.args.slice(0, 3) ?? []) {
-                const bad = grow(linOf(m, ref), `where ${part} is fastened`);
-                if (bad)
-                    return bad;
-            }
-            const motion = nodeById(m, `${part}.motion`);
-            if (motion?.op === 'axis-slide@1')
-                for (const end of ['min', 'max']) {
-                    const bad = grow(travelAt(m, asset, motion, end), `${part}'s travel`);
-                    if (bad)
-                        return bad;
-                }
-        }
-    }
-    /*
-      The pivot: where the topmost turn is fastened, and everything above it. Above it nothing turns, but a slide may
-      carry it -- the telescopic conveyor's nose turns at the end of its third stage -- so the pivot is read at each
-      end of the controls, a ball at each: a slide is a straight line, so the balls at its two ends bound it all the
-      way (it had been refused, and the nose left out of the room).
-    */
-    const pivotPart = chain[top];
-    const parent = parentOf(m, pivotPart);
-    const seat = nodeById(m, `${pivotPart}.seat.rigid`);
-    const seatAt = Object.fromEntries(AXES.map((a, i) => [a, seat ? linOf(m, seat.args[i]) : { terms: [], c: 0 }]));
-    const centres = [];
-    for (const end of ends) {
-        /* The point it turns about, in the frame of what carries it, carried there -- turned with it if that stands turned. */
-        const at = parent ? centreVec(m, asset, parent, end, structuredClone(seatAt)) : seatAt;
-        if (typeof at === 'string')
-            return at;
-        centres.push(at);
-    }
-    return { centres, radius };
-}
-/** A sum written as graph nodes: each term scaled, then added up, then the constant. */
-function emitLin(m, name, l, hint) {
-    if (!l.terms.length)
-        return constantOf(m, 'mm', round6(l.c), 'd');
-    let out = '';
-    for (const t of l.terms) {
-        const piece = scaled(m, name, t.ref, t.k, 0, hint);
-        if (!out)
-            out = piece;
-        else {
-            const id = name(`${hint}.sum`);
-            m.nodes.push({ id, op: 'add@1', args: [out, piece], outputs: { value: `${id}.value` } });
-            out = `${id}.value`;
-        }
-    }
-    if (l.c !== 0) {
-        const id = name(`${hint}.offset`);
-        m.nodes.push({ id, op: 'add@1', args: [out, constantOf(m, 'mm', round6(l.c), 'd')], outputs: { value: `${id}.value` } });
-        out = `${id}.value`;
-    }
-    return out;
-}
-/** The bounds the parts come to, as sums, with what could not be read named. */
-function occupancyLins(asset, over) {
-    const m = asset.document.model;
-    const parts = [];
-    const skipped = [];
-    const low = { x: [], y: [], z: [] };
-    const high = { x: [], y: [], z: [] };
-    /* Parts carried by the same turn share one ball: its radius the larger of theirs, term by term. */
-    const balls = new Map();
-    /* A row's template stands for its copies (`repeatPart`): leaving it out left a conveyor's rollers out of its room. */
-    const rowOf = (id) => nodeById(m, `${id}.repeat`);
-    const ends = over === 'rest' ? ['start'] : ['min', 'max'];
-    /* A part's size along the figure's axes, whichever quarter turns it and what carries it stand in. */
-    const sizesOf = (id, turns) => {
-        /* A turned chain's reach is read from one size per axis (reachOf), so a part there must have one. */
-        const own = occupiedExtentsOf(m, id, id, turns);
-        const c = turns ? IDENTITY : worldTurnOf(m, asset, id);
-        if (!c)
-            throw new FigureContractError('EDIT_TARGET', id, `${id} is turned by other than quarter turns`);
-        return Object.fromEntries(AXES.map((axis, i) => {
-            const j = c[i].findIndex(v => v !== 0);
-            const e = own[AXES[j]];
-            /* A size is the same either way round; a reach turned half about flips: its offsets change sign. */
-            return [axis, isReach(e) && c[i][j] < 0 ? { offsets: e.offsets.map(o => ({ ...o, k: -o.k })) } : e];
-        }));
-    };
-    /*
-      A row runs from its parent's one edge to the other along its axis, every copy inside (fit-pitch and fixed-count lay
-      them out within that length). What it spans there, how long its part is along it, and how far a rising row climbs.
-    */
-    const runOf = (part) => {
-        const row = rowOf(part);
-        const axis = String(row.params?.axis ?? '').toLowerCase();
-        const parent = parentOf(m, part);
-        const straight = parent && worldTurnOf(m, asset, parent);
-        if (!parent || !AXES.includes(axis) || !straight || AXES.some((_, i) => straight[i][i] !== 1))
-            return `${part} is a row whose run this command cannot read`;
-        const theirs = standingRefsOf(m, asset, parent, parent, false)[axis];
-        const half = { terms: [{ ref: theirs.ref, k: 0.5 * theirs.k }], c: 0 };
-        const centres = ends.map(end => centreLin(m, asset, parent, axis, end));
-        const bad = centres.find(c => typeof c === 'string');
-        if (bad)
-            return String(bad);
-        const along = sizesOf(part, false)[axis];
-        if (isReach(along))
-            return `${part} is a row of a drawn section along its section; how far each copy reaches is not added up`;
-        const mine = along[0];
-        const extent = { terms: [{ ref: mine.ref, k: mine.k }], c: 0 };
-        const record = (asset.joints ?? []).find(o => o.body1.part === part && o.repeat)?.repeat;
-        let climb;
-        if (record?.rise) {
-            /*
-              The last copy is (count − 1) rises past the first. A row that fills its length has at most
-              (length − one copy) / pitch copies past the first, so that many rises bound it and follow the parent's size;
-              a counted row has exactly count − 1.
-            */
-            const per = record.rise.mm;
-            let reach;
-            if (record.count !== undefined)
-                reach = { terms: [], c: (record.count - 1) * per };
-            else if (typeof record.pitch === 'number')
-                reach = { terms: [{ ref: theirs.ref, k: (theirs.k * per) / record.pitch }, { ref: mine.ref, k: (-mine.k * per) / record.pitch }], c: 0 };
-            else
-                return `${part} is a rising row whose pitch follows a length; how far it rises is not added up`;
-            climb = { axis: record.rise.axis.toLowerCase(), up: per > 0, reach };
-        }
-        return { axis, lows: centres.map(c => linAdd(c, half, -1)), highs: centres.map(c => linAdd(c, half, 1)), extent, climb };
-    };
-    /* A part in a row, or fastened to one: each copy carries it (ADR-0093, 2026-09-26). */
-    for (const place of m.nodes.filter((n) => n.op === 'place@1' || (n.op === 'member@1' && (rowOf(n.id) || rowHolding(m, n.id))))) {
-        const turns = carriedByATurn(m, asset, place.id);
-        let sizes = {};
-        try {
-            sizes = sizesOf(place.id, turns);
-        }
-        catch (e) {
-            skipped.push({ part: place.id, reason: e instanceof FigureContractError ? e.message : 'not a part whose size this command can read' });
-            continue;
-        }
-        /*
-          The rows around this part, nearest first: its own if it is a row's part, then the row of each part it hangs from
-          (a grid is a row inside a row, each along its own axis).
-        */
-        const rows = [];
-        let unread;
-        for (let up = place.op === 'member@1' ? place.id : null; up; up = parentOf(m, up)) {
-            if (!rowOf(up))
-                continue;
-            const run = runOf(up);
-            if (typeof run === 'string') {
-                unread = run;
-                break;
-            }
-            rows.push({ part: up, run });
-        }
-        if (unread) {
-            skipped.push({ part: place.id, reason: unread });
-            continue;
-        }
-        const rowAxes = new Set(rows.map(r => r.run.axis));
-        /* How far the rows around it climb, along an axis and a way, added up: each copy of each row is further up. */
-        const climbed = (at, side, onto, axis) => {
-            const climbs = rows.map(r => r.run.climb).filter(c => c && c.axis === axis && (c.up ? 1 : -1) === side);
-            if (climbs.length)
-                onto[axis].push(climbs.reduce((sum, c) => linAdd(sum, c.reach), at));
-        };
-        if (turns) {
-            const reach = reachOf(m, asset, place.id, ends);
-            if (typeof reach === 'string') {
-                skipped.push({ part: place.id, reason: reach });
-                continue;
-            }
-            parts.push(place.id);
-            if (rows.length) {
-                /*
-                  Each copy turns about its own pivot, which lies on its rows' runs: along a row the copies reach the run's
-                  ends and the turn's reach past them; across them, the turn's reach about the pivot.
-                */
-                for (const { run } of rows) {
-                    for (const l of run.lows)
-                        low[run.axis].push(linAdd(l, reach.radius, -1));
-                    for (const h of run.highs)
-                        high[run.axis].push(linAdd(h, reach.radius, 1));
-                }
-                for (const at of reach.centres)
-                    for (const axis of AXES.filter(a => !rowAxes.has(a))) {
-                        const lo = linAdd(at[axis], reach.radius, -1);
-                        const hi = linAdd(at[axis], reach.radius, 1);
-                        low[axis].push(lo);
-                        high[axis].push(hi);
-                        climbed(lo, -1, low, axis);
-                        climbed(hi, 1, high, axis);
-                    }
-                continue;
-            }
-            for (const at of reach.centres) {
-                const centre = Object.fromEntries(AXES.map(a => [a, linNorm(at[a])]));
-                const key = JSON.stringify(centre);
-                const ball = balls.get(key);
-                balls.set(key, { centre, radius: ball ? linAtLeast(ball.radius, reach.radius) : linNorm(reach.radius) });
-            }
-            continue;
-        }
-        /*
-          Both ends of every control are candidates, and which one is the low end is not decided here: a travel of
-          −40 mm puts the low end at the control's maximum (designer's counterexample 2026-09-23, where the
-          proposal read −50..10 for a part that needs −90..50). Both candidates go into the same min and the same
-          max, so the answer holds whichever way the travel runs, and holds at every design size, because the
-          choice is made when the graph is evaluated rather than when the proposal is written.
-        */
-        const readings = AXES.map(axis => ({ axis, at: ends.map(end => centreLin(m, asset, place.id, axis, end)) }));
-        const bad = readings.flatMap(r => r.at).find(v => typeof v === 'string');
-        if (bad) {
-            skipped.push({ part: place.id, reason: String(bad) });
-            continue;
-        }
-        let offRun;
-        for (const { part: template, run } of rows) {
-            if (template === place.id) {
-                /* The row's own part: along the row it takes the run. */
-                low[run.axis].push(...run.lows);
-                high[run.axis].push(...run.highs);
-                continue;
-            }
-            /*
-              Carried by a row's part: its copies stand where that part's copies do, offset as it is from it. That part's
-              centres lie half its length in from the run's ends.
-            */
-            const theirs = ends.map(end => centreLin(m, asset, template, run.axis, end));
-            const bad = theirs.find(c => typeof c === 'string');
-            if (bad) {
-                offRun = String(bad);
-                break;
-            }
-            const along = readings.find(r => r.axis === run.axis).at;
-            const inset = linAdd({ terms: [], c: 0 }, run.extent, 0.5);
-            const across = sizes[run.axis];
-            if (isReach(across)) {
-                offRun = `${place.id} is a drawn section carried along a row; how far each copy reaches is not added up`;
-                break;
-            }
-            for (const [i, mine] of along.entries()) {
-                const offset = linAdd(mine, theirs[i], -1);
-                for (const e of across) {
-                    const half = { terms: [{ ref: e.ref, k: 0.5 * e.k }], c: 0 };
-                    for (const l of run.lows)
-                        low[run.axis].push(linAdd(linAdd(linAdd(l, inset), offset), half, -1));
-                    for (const h of run.highs)
-                        high[run.axis].push(linAdd(linAdd(linAdd(h, inset, -1), offset), half));
-                }
-            }
-        }
-        if (offRun) {
-            skipped.push({ part: place.id, reason: offRun });
-            continue;
-        }
-        parts.push(place.id);
-        for (const r of readings) {
-            if (rowAxes.has(r.axis))
-                continue;
-            const extent = sizes[r.axis];
-            const seen = new Set();
-            for (const centre of r.at) {
-                const key = JSON.stringify([centre.terms.map(t => [t.ref, t.k]).sort(), centre.c]);
-                if (seen.has(key))
-                    continue; // a part that does not move gives the same candidate twice
-                seen.add(key);
-                if (isReach(extent)) {
-                    /* Every point is a candidate for both ends: the least is the low end, the greatest the high one. */
-                    for (const o of extent.offsets) {
-                        const at = linAdd(centre, { terms: [{ ref: o.ref, k: o.k }], c: 0 });
-                        low[r.axis].push(at);
-                        high[r.axis].push(at);
-                        climbed(at, -1, low, r.axis);
-                        climbed(at, 1, high, r.axis);
-                    }
-                    continue;
-                }
-                const halves = extent.map(e => ({ terms: [{ ref: e.ref, k: 0.5 * e.k }], c: 0 }));
-                for (const half of halves) {
-                    const lo = linAdd(centre, half, -1);
-                    const hi = linAdd(centre, half, 1);
-                    low[r.axis].push(lo);
-                    high[r.axis].push(hi);
-                    climbed(lo, -1, low, r.axis);
-                    climbed(hi, 1, high, r.axis);
-                }
-            }
-        }
-    }
-    return { parts, skipped, low, high, balls: [...balls.values()] };
-}
-const valueOfLin = (values, l) => l.terms.reduce((s, t) => s + t.k * (values[t.ref] ?? NaN), l.c);
-/** What the parts come to, and what a person is being asked to confirm. Reads the asset; changes nothing. */
-export function proposeFigureOccupancy(asset, options = {}) {
-    asset = upgradeFigurePlacement(asset);
-    const over = options.over ?? 'range';
-    if (over !== 'rest' && over !== 'range')
-        fail('SCHEMA', 'over', `${String(over)} is neither rest nor range`);
-    const source = structuredClone(asset);
-    const { parts, skipped, low, high, balls } = occupancyLins(source, over);
-    for (const ball of balls)
-        for (const axis of AXES) {
-            low[axis].push(linAdd(ball.centre[axis], ball.radius, -1));
-            high[axis].push(linAdd(ball.centre[axis], ball.radius, 1));
-        }
-    if (!parts.length)
-        fail('OCCUPANCY_NO_PARTS', 'occupancy', `no part could be measured${skipped.length ? `: ${skipped.map(s => `${s.part} — ${s.reason}`).join('; ')}` : ''}`);
-    const values = compileFigureGraph(source.document.model).evaluate({ ...source.designInputs, ...source.stateDefaults }).values;
-    const at = Object.fromEntries(AXES.map(axis => [axis, { min: round6(Math.min(...low[axis].map(l => valueOfLin(values, l)))), max: round6(Math.max(...high[axis].map(l => valueOfLin(values, l)))) }]));
-    return { over, at, parts, skipped, basis: fingerprintOf(source) };
-}
-/**
- * The placement says which plane the mounting plane is. A part already fastened to it by a face the new plane does not
- * take -- a bottom on the floor, when the figure is to hang on a wall -- is named, not seated again without a word
- * (chief architect's condition, 2026-09-25): fasten it again by the face the new plane takes.
- */
-function setPlacement(asset, a) {
-    if (!FIGURE_PLACEMENTS.includes(a.placement))
-        fail('SCHEMA', 'placement', `${String(a.placement)} is not a placement`);
-    const takes = planeFacesOf(a.placement);
-    const misfit = (asset.joints ?? []).filter(j => 'plane' in j.body0 && !takes.includes(j.body1.face));
-    if (misfit.length)
-        fail('PLACEMENT_PLANE', 'placement', `${misfit.map(j => `${j.body1.part} (${j.body1.face})`).join(', ')} ${misfit.length > 1 ? 'are' : 'is'} fastened to the mounting plane by a face a ${a.placement} does not take (${takes.join(' or ')}); detach ${misfit.length > 1 ? 'them' : 'it'} or fasten ${misfit.length > 1 ? 'them' : 'it'} by ${takes.join(' or ')} first`);
-    asset.placement = a.placement;
-    return asset;
-}
-function declareOccupancy(asset, a) {
-    const m = asset.document.model;
-    if (!a.proposal || (a.proposal.over !== 'rest' && a.proposal.over !== 'range'))
-        fail('SCHEMA', 'occupancy', 'a proposal is required; propose first, then confirm');
-    const now = fingerprintOf(asset);
-    if (a.proposal.basis !== now)
-        fail('OCCUPANCY_STALE', 'occupancy', 'the figure changed since this was proposed, so the volume it would declare is not the one that was looked at; propose again and confirm that');
-    /* Declared with a placement, the placement is set by the same command as on its own: one value, one check. */
-    if (a.placement !== undefined)
-        setPlacement(asset, { kind: 'set-placement', placement: a.placement });
-    const padding = {};
-    for (const axis of AXES) {
-        const pad = a.padding?.[axis] ?? 0;
-        if (!(Number.isFinite(pad) && pad >= 0))
-            fail('OCCUPANCY_PADDING', `occupancy.${axis}`, `padding is millimetres, zero or more; got ${String(pad)}`);
-        padding[axis] = pad;
-    }
-    const { parts, low, high, balls } = occupancyLins(asset, a.proposal.over);
-    /* A turning chain's ball, its reach either way about its pivot on each axis. */
-    for (const ball of balls)
-        for (const axis of AXES) {
-            low[axis].push(linAdd(ball.centre[axis], ball.radius, -1));
-            high[axis].push(linAdd(ball.centre[axis], ball.radius, 1));
-        }
-    for (const axis of AXES) {
-        if (!padding[axis])
-            continue;
-        low[axis] = low[axis].map((l) => ({ ...l, c: l.c - padding[axis] }));
-        high[axis] = high[axis].map((l) => ({ ...l, c: l.c + padding[axis] }));
-    }
-    if (parts.join('|') !== a.proposal.parts.join('|'))
-        fail('OCCUPANCY_STALE', 'occupancy', `the figure changed since the proposal was made (${a.proposal.parts.join(', ')} then, ${parts.join(', ')} now); propose again and confirm that`);
-    /* One node for the six bounds (affine-bounds@1): each candidate its constant, then a value and a ratio per term. */
-    const args = [];
-    const layout = AXES.flatMap(axis => [low[axis], high[axis]]).map(side => side
-        .map((l) => {
-        const n = linThroughSums(m, l);
-        args.push(constantOf(m, 'mm', round6(n.c), 'd'));
-        for (const t of n.terms)
-            args.push(t.ref, constantOf(m, 'ratio', t.k, 'k'));
-        return n.terms.length;
-    })
-        .join('_'));
-    const id = namer(m, 'occupancy')('bounds');
-    const port = (p) => `${id}.${p}`;
-    m.nodes.push({ id, op: 'affine-bounds@1', args, params: { layout: `L${layout.join('.')}` }, outputs: Object.fromEntries(['xmin', 'xmax', 'ymin', 'ymax', 'zmin', 'zmax'].map(p => [p, port(p)])) });
-    const bounds = Object.fromEntries(AXES.map(axis => [axis, { min: port(`${axis}min`), max: port(`${axis}max`) }]));
-    const was = stringsIn(asset.occupancy?.bounds);
-    asset.occupancy = { ...(asset.occupancy?.contact ? { contact: asset.occupancy.contact } : {}), bounds };
-    /*
-      The room declared before goes with what fed only it. Left in the graph, it kept reading where parts had been
-      fastened, and the next fastening was refused over a room no one read (the gantry, 2026-09-25).
-    */
-    for (const ref of was)
-        dropIfUnused(asset, ref);
-    /*
-      A part's own measure the old room alone still read -- the part follows something else now -- goes too: kept, it
-      was a dial that changed nothing (the turntable after every part followed the one ratio, 2026-09-25). So does its
-      own position or turn, once a fastening places it: a floor part's height position stayed as a field that moved
-      nothing (browser check, ADR-0097, 2026-09-27). The room's refit names them before it is confirmed (figureRoomRefitOf).
-    */
-    const placed = new Set(m.nodes.filter((n) => n.op === 'place@1' || n.op === 'member@1').map((n) => n.id));
-    for (const input of [...m.inputs])
-        if (input.role === 'design' && placed.has(String(input.id).split('.')[0]) && /\.(dimension|size|position|rotation)\.[a-z]+$/.test(input.id))
-            dropIfUnused(asset, input.id, input.id);
-    return asset;
-}
-/** "This face is what the figure is mounted on." Kept apart from how much room the figure takes up. */
-function setMountingFace(asset, a) {
-    const m = asset.document.model;
-    if (!asset.occupancy)
-        fail('OCCUPANCY_UNDECLARED', 'occupancy', 'declare the room the figure takes up before naming the face it stands on');
-    if (!Object.hasOwn(FIGURE_FACES, String(a.face)))
-        fail('SCHEMA', a.part, `${String(a.face)} is not a face`);
-    const { place } = partOf(m, a.part, a.part);
-    const id = `${a.part}.mount.${a.face}`;
-    if (!nodeById(m, id))
-        m.nodes.push({ id, op: 'feature@1', args: [place.args[0]], outputs: { pose: `${id}.value` }, params: { frame: `${id}.frame`, name: a.face } });
-    asset.occupancy.contact = { plane: 'mounting-plane', surface: { placement: place.outputs.placed, feature: `${id}.value` } };
-    return asset;
-}
-/** Every string inside a declaration -- the references it may hold, with its names and labels (which name nothing). */
-const stringsIn = (value) => {
-    const out = [];
-    const walk = (v) => {
-        if (typeof v === 'string')
-            out.push(v);
-        else if (Array.isArray(v))
-            for (const one of v)
-                walk(one);
-        else if (v && typeof v === 'object')
-            for (const one of Object.values(v))
-                walk(one);
-    };
-    walk(value);
-    return out;
-};
-/** The feature node for one face of a placed part: the one already there, or a new one. */
-function faceFeatureOf(m, place, face) {
-    const found = m.nodes.find((n) => n.op === 'feature@1' && n.args[0] === place.args[0] && n.params?.name === face);
-    if (found)
-        return found;
-    const id = `${place.id}.face.${face}`;
-    if (nodeById(m, id))
-        fail('SCHEMA', place.id, `${id} is already a node that is not this face`);
-    const node = { id, op: 'feature@1', args: [place.args[0]], outputs: { pose: `${id}.value` }, params: { frame: `${id}.frame`, name: face } };
-    m.nodes.push(node);
-    return node;
-}
-function addBinding(asset, a) {
-    const m = asset.document.model;
-    const bindings = asset.document.capabilities.bindings;
-    const id = typeof a.id === 'string' ? a.id.trim() : '';
-    if (!id)
-        fail('SCHEMA', 'binding', 'a place needs an id');
-    const label = typeof a.label === 'string' ? a.label.trim() : '';
-    if (!label)
-        fail('SCHEMA', id, 'a place needs a name a person reads');
-    const at = bindings.findIndex(b => b.id === id);
-    if (at >= 0 && !a.replace)
-        fail('DUPLICATE_BINDING', id, 'a place with this id exists; replace it explicitly');
-    if (a.role !== 'seat' && a.role !== 'grip')
-        fail('ROLE', id, 'a place is a seat or a grip');
-    if (!Object.hasOwn(FIGURE_FACES, String(a.face)))
-        fail('SCHEMA', id, `${String(a.face)} is not a face`);
-    const place = nodeById(m, a.part);
-    if (!place || place.op !== 'place@1')
-        fail('TARGET_ABSENT', id, `${String(a.part)} is not a placed part`);
-    const accepts = [...new Set((Array.isArray(a.accepts) ? a.accepts : []).map(one => String(one).trim()).filter(Boolean))];
-    if (!accepts.length)
-        fail('SCHEMA', id, 'name at least one type it takes');
-    if (!Number.isSafeInteger(a.capacity) || a.capacity < 1)
-        fail('CAPACITY', id, 'how many it holds is a whole number from 1');
-    const feature = faceFeatureOf(m, place, a.face);
-    const binding = {
-        id,
-        label,
-        role: a.role,
-        frame: feature.params.frame,
-        pose: { placement: place.outputs.placed, feature: feature.outputs.pose },
-        accepts,
-        capacity: a.capacity
-    };
-    if (a.region) {
-        const sizes = AXES.map(axis => a.region[axis]);
-        if (sizes.some(mm => typeof mm !== 'number' || !Number.isFinite(mm) || mm <= 0))
-            fail('REGION', id, 'the room is three lengths above 0 mm');
-        binding.region = { kind: 'centered-box', dimensions: sizes.map((mm, i) => constantOf(m, 'mm', mm, `${id}.region.${AXES[i]}`)) };
-    }
-    const before = at >= 0 ? bindings[at] : null;
-    if (at >= 0)
-        bindings[at] = binding;
-    else
-        bindings.push(binding);
-    if (before)
-        dropBindingRefs(asset, before);
-    return asset;
-}
-function removeBinding(asset, a) {
-    const bindings = asset.document.capabilities.bindings;
-    const at = bindings.findIndex(b => b.id === a.id);
-    if (at < 0)
-        fail('TARGET_ABSENT', String(a.id), 'no place has this id');
-    const [gone] = bindings.splice(at, 1);
-    dropBindingRefs(asset, gone);
-    return asset;
-}
-function setSlotLayout(asset, a) {
-    const m = asset.document.model;
-    const label = typeof a.label === 'string' ? a.label.trim() : '';
-    if (!label)
-        fail('SCHEMA', 'slotLayout', 'a slot layout needs a name a person reads');
-    if (a.role !== 'seat' && a.role !== 'grip')
-        fail('ROLE', 'slotLayout', 'its slots are seats or grips');
-    if (!Array.isArray(a.anchors) || !a.anchors.length)
-        fail('SCHEMA', 'slotLayout', 'name at least one anchor');
-    const seen = new Set();
-    const anchors = a.anchors.map(w => {
-        const id = typeof w?.id === 'string' ? w.id.trim() : '';
-        if (!id)
-            fail('SCHEMA', 'slotLayout', 'an anchor needs an id');
-        if (seen.has(id))
-            fail('SCHEMA', 'slotLayout', `two anchors are called ${id}`);
-        seen.add(id);
-        if (!Object.hasOwn(FIGURE_FACES, String(w.face)))
-            fail('SCHEMA', 'slotLayout', `${String(w.face)} is not a face`);
-        if (FIGURE_FACES[w.face] !== 'y')
-            fail('SLOT_LAYOUT_FACE', 'slotLayout', 'an anchor is the top or the bottom of a part');
-        const place = nodeById(m, w.part);
-        if (!place || place.op !== 'place@1')
-            fail('TARGET_ABSENT', 'slotLayout', `${String(w.part)} is not a placed part`);
-        return { id, place, face: w.face };
-    });
-    const layout = structuredClone(a.layout);
-    const issues = validateSlotLayout(layout, { anchors: seen });
-    const problems = issues.length ? issues : persistenceIssues(layout);
-    if (problems.length)
-        fail('SLOT_LAYOUT', `slotLayout.layout.${problems[0].path}`, problems.map(i => `${i.code} at ${i.path}`).join('; '));
-    const declaration = {
-        label,
-        role: a.role,
-        anchors: anchors.map(x => ({ id: x.id, frame: '', pose: { placement: x.place.outputs.placed, feature: '' } })),
-        layout
-    };
-    const taken = new Set(asset.document.capabilities.bindings.map((b) => b.id));
-    for (const slot of figureSlotPlacesOf(declaration)) {
-        if (!slot.accepts.length)
-            fail('SCHEMA', slot.id, 'name at least one type each slot takes');
-        if (taken.has(slot.id))
-            fail('DUPLICATE_BINDING', slot.id, 'a place with this id exists');
-    }
-    // The faces are added to the graph only once the layout is sound, so a refused one leaves the figure as it was.
-    anchors.forEach((x, i) => {
-        const feature = faceFeatureOf(m, x.place, x.face);
-        declaration.anchors[i].frame = feature.params.frame;
-        declaration.anchors[i].pose.feature = feature.outputs.pose;
-    });
-    const before = asset.document.capabilities.slotLayout;
-    asset.document.capabilities.slotLayout = declaration;
-    const kept = new Set(declaration.anchors.map(x => x.pose.feature));
-    for (const old of (before?.anchors ?? []))
-        if (!kept.has(old.pose.feature))
-            dropIfUnused(asset, old.pose.feature);
-    return asset;
-}
-function removeSlotLayout(asset) {
-    const before = asset.document.capabilities.slotLayout;
-    if (!before)
-        fail('TARGET_ABSENT', 'slotLayout', 'this figure has no slot layout');
-    delete asset.document.capabilities.slotLayout;
-    for (const old of before.anchors)
-        dropIfUnused(asset, old.pose.feature);
-    return asset;
-}
-/** The face and the room a place read, once nothing else reads them. */
-function dropBindingRefs(asset, binding) {
-    const m = asset.document.model;
-    const refs = [binding.pose?.feature, ...(binding.contacts ?? []).map((c) => c.feature)].filter(Boolean);
-    for (const ref of refs)
-        dropIfUnused(asset, ref);
-    const declared = new Set([...stringsIn(asset.occupancy), ...stringsIn(asset.document.capabilities)]);
-    for (const ref of binding.region?.dimensions ?? [])
-        if (!declared.has(ref) && !m.nodes.some((n) => n.args.includes(ref)))
-            m.constants = m.constants.filter((c) => c.id !== ref);
-}
-/** The places a figure has: its declared bindings, then the slots its slot layout unfolds into. */
-export function figureBindingsOf(asset) {
-    const m = asset.document.model;
-    const constant = (ref) => m.constants.find((c) => c.id === ref)?.value;
-    const declared = asset.document.capabilities.bindings.map((b) => {
-        const surface = typeof b.pose === 'string' ? null : b.pose;
-        const place = surface ? m.nodes.find((n) => n.op === 'place@1' && n.outputs.placed === surface.placement) : null;
-        const feature = surface ? writerOf(m, surface.feature) : null;
-        const sizes = (b.region?.dimensions ?? []).map(constant);
-        return {
-            id: b.id,
-            label: b.label,
-            role: b.role,
-            part: place?.id ?? null,
-            face: feature?.params?.name ?? null,
-            accepts: [...b.accepts],
-            capacity: b.capacity,
-            region: sizes.length === 3 && sizes.every((v) => typeof v === 'number') ? { x: sizes[0], y: sizes[1], z: sizes[2] } : null
-        };
-    });
-    const slots = figureSlotPlacesOf(asset.document.capabilities.slotLayout).map(p => {
-        const place = m.nodes.find((n) => n.op === 'place@1' && n.outputs.placed === p.pose.placement);
-        const feature = writerOf(m, p.pose.feature);
-        return {
-            id: p.id,
-            label: p.label,
-            role: p.role,
-            part: place?.id ?? null,
-            face: feature?.params?.name ?? null,
-            accepts: [...p.accepts],
-            capacity: p.capacity,
-            region: { x: p.allowed.width, y: p.allowed.height, z: p.allowed.depth },
-            slot: {
-                tier: p.tier,
-                slot: p.slot,
-                anchorId: p.anchorId,
-                tierPosition: { ...p.tierPosition },
-                tierRotation: p.tierRotation,
-                offset: { ...p.offset },
-                rotation: p.rotation
-            }
-        };
-    });
-    return [...declared, ...slots];
-}
-function clearMountingFace(asset) {
-    if (!asset.occupancy?.contact)
-        fail('EDIT_TARGET', 'occupancy', 'this figure names no mounting face');
-    delete asset.occupancy.contact;
-    return asset;
-}
-function nudgePart(asset, a) {
-    const m = asset.document.model;
-    const path = a.part;
-    const { pose } = partOf(m, a.part, path);
-    if (pose.op !== 'rigid@1')
-        fail('EDIT_TARGET', path, `${a.part} is not posed by a rigid@1 this command can move`);
-    if (pose.params?.to !== 'asset')
-        fail('EDIT_TARGET', path, `${a.part} is carried by a joint or a seat, which places it`);
-    if (parentOf(m, a.part))
-        fail('EDIT_TARGET', path, `${a.part} is fastened to ${parentOf(m, a.part)}, which places it; detach it first`);
-    const shift = (slot, by, unit, kind, axis) => {
-        if (!by)
-            return;
-        if (!Number.isFinite(by))
-            fail('SCHEMA', `${path}.${kind}.${axis}`, 'a finite amount required');
-        const was = pose.args[slot];
-        const own = `${a.part}.${kind}.${axis}`;
-        /* Already the part's own number: add to it. */
-        if (was === own && m.inputs.some((i) => i.id === own && i.role === 'design')) {
-            asset.designInputs[own] = round6(asset.designInputs[own] + by);
-            return;
-        }
-        const constant = m.constants.find((c) => c.id === was);
-        const free = (id) => !m.inputs.some((i) => i.id === id) && !m.nodes.some((n) => n.id === id || Object.values(n.outputs).includes(id));
-        const input = (id, value) => {
-            m.inputs.push({ id, unit, min: -Number.MAX_VALUE, max: Number.MAX_VALUE, role: 'design' });
-            asset.designInputs[id] = round6(value);
-        };
-        /* A plain number becomes the part's own, moved. */
-        if (constant && free(own)) {
-            input(own, constant.value + by);
-            pose.args = pose.args.map((r, k) => (k === slot ? own : r));
-            return;
-        }
-        /* A worked-out place keeps its rule and takes the drag beside it. */
-        const nudge = `${a.part}.${kind}.nudge.${axis}`;
-        if (m.inputs.some((i) => i.id === nudge)) {
-            asset.designInputs[nudge] = round6(asset.designInputs[nudge] + by);
-            return;
-        }
-        input(nudge, by);
-        const id = namer(m, `${a.part}.${kind}`)(`nudged.${axis}`);
-        m.nodes.push({ id, op: 'add@1', args: [was, nudge], outputs: { value: `${id}.value` } });
-        pose.args = pose.args.map((r, k) => (k === slot ? `${id}.value` : r));
-    };
-    AXES.forEach((axis, i) => shift(i, a.by?.[axis] ?? 0, 'mm', 'position', axis));
-    AXES.forEach((axis, i) => shift(3 + i, a.turn?.[axis] ?? 0, 'deg', 'rotation', axis));
-    /* Sizes: the measure's own node carries a factor beside its rule (`stableDimension` routes every measure through one). */
-    const shape = partOf(m, a.part, path).shape;
-    const described = figureShapeDescriptionOf(shape);
-    const edits = described?.edit;
-    if (!edits)
-        fail('EDIT_TARGET', path, `${a.part} is a ${shape.op}; it is not a shape with measures`);
-    const measures = AXES.filter(axis => !('refused' in edits[axis]) && !edits[axis].sameAs);
-    for (const axis of measures) {
-        /* A round section's one value answers to the cross axis the drag moved more. */
-        const partner = AXES.find(b => edits[b].sameAs === axis);
-        const factor = partner ? mostChanged(a.grow?.[axis], a.grow?.[partner]) : a.grow?.[axis];
-        if (factor === undefined || factor === 1)
-            continue;
-        if (!(Number.isFinite(factor) && factor > 0))
-            fail('GEOMETRY_DOMAIN', `${path}.dimension.${axis}`, 'a positive factor required');
-        stableDimension(m, a.part, axis, `${path}.dimension.${axis}`);
-        const node = nodeById(m, `${a.part}.dimension.${axis}`);
-        const id = `${a.part}.dimension.scale.${axis}`;
-        if (node.args[1] === id)
-            asset.designInputs[id] = round6(asset.designInputs[id] * factor);
-        else {
-            if (m.inputs.some((i) => i.id === id))
-                fail('DUPLICATE_WRITER', path, `${id} already exists`);
-            m.inputs.push({ id, unit: 'ratio', min: Number.MIN_VALUE, max: Number.MAX_VALUE, role: 'design' });
-            const was = m.constants.find((c) => c.id === node.args[1])?.value ?? 1;
-            asset.designInputs[id] = round6(was * factor);
-            node.args = [node.args[0], id];
-        }
-        /* A taper's other end keeps its proportion: it is scaled by the same factor, through the same input. */
-        const e = edits?.[axis];
-        for (const i of e?.with ?? []) {
-            const own = `${a.part}.dimension.${axis}.with.${i}`;
-            if (!nodeById(m, own)) {
-                const ref = `${own}.value`;
-                m.nodes.push({ id: own, op: 'mul@1', args: [shape.args[i], id], outputs: { value: ref } });
-                shape.args = shape.args.map((r, k) => (k === i ? ref : r));
-            }
-        }
-    }
-    return asset;
-}
-const mostChanged = (a, b) => {
-    const pick = [a, b].filter((v) => v !== undefined);
-    return pick.length ? pick.reduce((x, y) => (Math.abs(y - 1) > Math.abs(x - 1) ? y : x), 1) : undefined;
-};
-function setRepeat(asset, a) {
-    const m = asset.document.model;
-    const path = `${a.part}.repeat`;
-    /* A row made in the modeller lives in its fastening's record: the pitch changes there, and the row is made again. */
-    const record = (asset.joints ?? []).find(o => o.body1.part === a.part && o.repeat);
-    if (record) {
-        setJoint(asset, { ...record, repeat: { ...record.repeat, pitch: a.pitch } });
-        return asset;
-    }
-    const layout = nodeById(m, `${a.part}.layout`);
-    if (!layout || !nodeById(m, `${a.part}.repeat`))
-        fail('EDIT_TARGET', path, `${a.part} is not a repeated part`);
-    if (layout.op === 'fixed-count@1')
-        fail('EDIT_TARGET', path, `${a.part} repeats a fixed count; its pitch is built into its length and cannot be set yet`);
-    if (layout.op !== 'fit-pitch@1')
-        fail('EDIT_TARGET', path, `${a.part} lays its copies out by ${layout.op}, which has no pitch`);
-    /* A pitch read from an input is a record's: a row without one takes a number (ADR-0096). */
-    if (typeof a.pitch !== 'number')
-        fail('EDIT_TARGET', path, `${a.part}'s row has no record to read its pitch from an input; make it again with make-repeat`);
-    const pitch = a.pitch;
-    if (!(Number.isFinite(pitch) && pitch > 0))
-        fail('GEOMETRY_DOMAIN', path, 'a positive pitch is required');
-    /*
-      One number, the pitch: copies = floor(row length / pitch), at most `limit` of them (the kernel's copy cap).
-      So the longest row the figure may be placed at is limit x pitch. A new pitch moves that bound with it; the pitch is refused only when the length the figure
-      is authored at would already hold more copies than the cap.
-    */
-    const values = compileFigureGraph(m).evaluate({ ...asset.designInputs, ...asset.stateDefaults }).values;
-    const lengthRef = layout.args[0];
-    const authored = values[lengthRef];
-    const limit = (values[layout.args[6]] ?? m.constants.find((c) => c.id === layout.args[6])?.value);
-    const smallest = Math.ceil((authored / limit) * 1000) / 1000;
-    if (pitch < smallest)
-        fail('INPUT_RANGE', path, `at the length it is authored (${round6(authored)} mm) a pitch under ${smallest} mm makes more than ${limit} copies`);
-    const id = `${a.part}.repeat.pitch`;
-    if (!m.inputs.some((i) => i.id === id)) {
-        if (m.nodes.some((n) => n.id === id || Object.values(n.outputs).includes(id)))
-            fail('DUPLICATE_WRITER', path, `${id} already exists`);
-        m.inputs.push({ id, unit: 'mm', min: Number.MIN_VALUE, max: Number.MAX_VALUE, role: 'design' });
-        const was = [layout.args[3], layout.args[4]];
-        layout.args = layout.args.map((r, k) => (k === 3 || k === 4 ? id : r));
-        for (const ref of new Set(was))
-            dropIfUnused(asset, ref);
-    }
-    asset.designInputs[id] = pitch;
-    /* The longest length follows the pitch, within the default range (ten times the authored length). */
-    const length = m.inputs.find((i) => i.id === lengthRef && i.role === 'design');
-    if (length) {
-        const longest = Math.min(round6(limit * pitch), round6(authored * FIGURE_INSTANCE_SIZE_DEFAULT.times));
-        length.max = Math.max(longest, authored);
-        if (length.min > length.max)
-            length.min = Math.min(length.min, authored);
-    }
-    return asset;
-}
-function scaleUniformly(asset) {
-    const m = asset.document.model;
-    if (asset.sizing === 'uniform')
-        return asset;
-    const authored = {};
-    for (const axis of AXES) {
-        const id = `size.${axis}`;
-        if (!m.inputs.some((i) => i.id === id && i.role === 'design'))
-            fail('TARGET_ABSENT', 'sizing', `the instance has no ${id}; declare the instance size first`);
-        const at = asset.designInputs[id];
-        if (!(Number.isFinite(at) && at > 0))
-            fail('GEOMETRY_DOMAIN', 'sizing', `${id} must be positive`);
-        authored[axis] = at;
-    }
-    /*
-      u = geomean(size.x, size.y, size.z) ÷ geomean(x₀, y₀, z₀) -- the same ratio as the mean of the three axes' ratios,
-      in two nodes; a figure near the document's node limit (ROBOT_ARM: 509 of 512) has little room.
-    */
-    const name = namer(m, 'sizing');
-    const mean = name('mean');
-    m.nodes.push({ id: mean, op: 'geomean@1', args: AXES.map(axis => `size.${axis}`), outputs: { value: `${mean}.value` } });
-    const u = name('u');
-    const g0 = round6(Math.cbrt(AXES.reduce((p, axis) => p * authored[axis], 1)));
-    m.nodes.push({ id: u, op: 'div@1', args: [`${mean}.value`, constantOf(m, 'mm', g0, 'd')], outputs: { value: `${u}.value` } });
-    const uniform = {};
-    for (const axis of AXES) {
-        const id = name(`size.${axis}`);
-        m.nodes.push({ id, op: 'mul@1', args: [`${u}.value`, constantOf(m, 'mm', authored[axis], 'd')], outputs: { value: `${id}.value` } });
-        uniform[`size.${axis}`] = `${id}.value`;
-    }
-    /* Every reader of the instance size reads the uniform size instead -- but the mean, which is what makes it. */
-    for (const n of m.nodes)
-        if (n.id !== mean)
-            n.args = n.args.map((a) => uniform[a] ?? a);
-    /*
-      A ratio of a size to its own authored length (`scale.x` · `scale.y` · `scale.z`) is now u itself:
-      its readers read u and it goes, which gives back the nodes the rule took.
-    */
-    const sameAsU = m.nodes.filter((n) => n.op === 'div@1' &&
-        AXES.some(axis => n.args[0] === uniform[`size.${axis}`] && m.constants.find((c) => c.id === n.args[1])?.value === authored[axis]));
-    for (const gone of sameAsU) {
-        const out = Object.values(gone.outputs)[0];
-        for (const n of m.nodes)
-            n.args = n.args.map((a) => (a === out ? `${u}.value` : a));
-    }
-    m.nodes = m.nodes.filter((n) => !sameAsU.includes(n));
-    const swap = (value) => typeof value === 'string' ? (uniform[value] ?? value) : Array.isArray(value) ? value.map(swap) : value && typeof value === 'object' ? Object.fromEntries(Object.entries(value).map(([k, v]) => [k, swap(v)])) : value;
-    if (asset.occupancy)
-        asset.occupancy = swap(asset.occupancy);
-    asset.document.capabilities = swap(asset.document.capabilities);
-    asset.sizing = 'uniform';
-    return asset;
-}
-/** Reads the asset; changes nothing. Refused for a figure that does not grow by one ratio. */
-export function proposeFigureProportion(asset) {
-    asset = upgradeFigurePlacement(asset);
-    return proportionPlan(asset);
-}
-function proportionPlan(asset) {
-    const m = asset.document.model;
-    if (asset.sizing !== 'uniform')
-        fail('SIZING_UNDECLARED', 'sizing', 'the figure does not grow by one ratio; declare that first (scale-uniformly), then every length can follow it');
-    const values = compileFigureGraph(m).evaluate({ ...asset.designInputs, ...asset.stateDefaults }).values;
-    const sizeNow = Object.fromEntries(AXES.map(axis => [axis, values[uniformSizeOf(m, axis, 'sizing')]]));
-    const plan = { dimensions: [], lengths: [], skipped: [] };
-    /* To nine places: the ratio's own mean is kept to six, and its noise is not the author's (0.1, not 0.0999999999787). */
-    const share = (value, axis) => Math.round((value / sizeNow[axis]) * 1e9) / 1e9;
-    const describe = (ref) => {
-        const w = writerOf(m, ref);
-        return String(w?.args?.[0] ?? ref).replace(/\.value$/, '');
-    };
-    const parts = m.nodes.filter((n) => n.op === 'place@1' || (n.op === 'member@1' && nodeById(m, `${n.id}.repeat`))).map((n) => n.id);
-    for (const part of parts) {
-        const shape = writerOf(m, nodeById(m, part).args[0]);
-        const described = shape && figureShapeDescriptionOf(shape);
-        const along = figureFollowableAxesOf(shape);
-        if (!described || !along.length) {
-            plan.skipped.push({ what: part, reason: `a ${described?.kind ?? String(shape?.op ?? 'shape')}'s measures are not linked by this command` });
-            continue;
-        }
-        for (const axis of along) {
-            const e = described.edit[axis];
-            const from = dimensionSource(m, part, axis) ?? shape.args[e.arg];
-            if (!ownInput(m, part, from)) {
-                plan.skipped.push({ what: `${part}.${axis}`, reason: `follows ${describe(from)}`, follows: true });
-                continue;
-            }
-            plan.dimensions.push({ part, axis, times: share(values[from], axis) });
-        }
-    }
-    /* A part standing by no record keeps its millimetres: said, not left behind without a word (the robot arm, 2026-09-25). */
-    for (const part of parts) {
-        if (jointAbove(asset, part) || nodeById(m, `${part}.repeat`))
-            continue;
-        const pose = nodeById(m, `${part}.pose`);
-        const moved = (pose?.args.slice(0, 3) ?? []).some((ref) => m.constants.find((c) => c.id === ref)?.value !== 0);
-        if (moved)
-            plan.skipped.push({ what: `${part}.place`, reason: 'stands by no fastening; fasten it for its place to follow' });
-    }
-    for (const j of (asset.joints ?? [])) {
-        const faceAxis = FIGURE_FACES[childFaceOf(m, j)];
-        const gap = j.origin?.gap;
-        if (typeof gap === 'number' && gap !== 0)
-            plan.lengths.push({ joint: j.id, at: 'gap', axis: faceAxis, times: share(gap, faceAxis) });
-        else if (gap && typeof gap === 'object')
-            plan.skipped.push({ what: `${j.id}.gap`, reason: 'follows a length already', follows: true });
-        for (const [axis, how] of Object.entries(j.origin?.align ?? {})) {
-            if (!how || typeof how !== 'object')
-                continue;
-            if (typeof how.mm === 'number') {
-                if (how.mm !== 0)
-                    plan.lengths.push({ joint: j.id, at: axis, axis, times: share(how.mm, axis) });
-            }
-            else
-                plan.skipped.push({ what: `${j.id}.${axis}`, reason: 'follows a length already', follows: true });
-        }
-        if (j.repeat && j.repeat.count === undefined) {
-            const axis = j.repeat.axis.toLowerCase();
-            if (typeof j.repeat.pitch === 'number')
-                plan.lengths.push({ joint: j.id, at: 'pitch', axis, times: share(j.repeat.pitch, axis) });
-            else
-                plan.skipped.push({ what: `${j.id}.pitch`, reason: 'follows a length already', follows: true });
-        }
-        if (j.type === 'prismatic' && !j.travel && !j.mimic)
-            plan.skipped.push({ what: `${j.id}.motion`, reason: 'a slide in millimetres; make its travel follow the size where the motion is changed' });
-        if (j.type === 'prismatic' && j.mimic?.offset)
-            plan.skipped.push({ what: `${j.id}.offset`, reason: "a follower's offset in millimetres" });
-    }
-    return plan;
-}
-function followSizeInProportion(asset) {
-    const plan = proportionPlan(asset);
-    for (const d of plan.dimensions)
-        linkDimension(asset, { kind: 'link-dimension', part: d.part, axis: d.axis, source: { of: 'instance', axis: d.axis }, times: d.times });
-    const follows = (axis, times) => ({ from: { of: 'instance', axis }, times });
-    for (const l of plan.lengths) {
-        const j = asset.joints.find(o => o.id === l.joint);
-        if (l.at === 'gap')
-            j.origin = { ...j.origin, gap: follows(l.axis, l.times) };
-        else if (l.at === 'pitch')
-            j.repeat = { ...j.repeat, pitch: follows(l.axis, l.times) };
-        else
-            j.origin = { ...j.origin, align: { ...j.origin.align, [l.at]: { mm: follows(l.axis, l.times) } } };
-    }
-    // The joints' nodes are made again from these records after the command, as after every command.
-    return asset;
-}
-function scalePosition(asset, a) {
-    const m = asset.document.model;
-    const path = `${a.part}.${a.axis}`;
-    if (!AXES.includes(a.axis))
-        fail('SCHEMA', path, `${String(a.axis)} is not an axis`);
-    const { pose } = partOf(m, a.part, path);
-    if (pose.op !== 'rigid@1')
-        fail('EDIT_TARGET', path, `${a.part} is not posed by a rigid@1 this command can read`);
-    if (parentOf(m, a.part))
-        fail('EDIT_TARGET', path, `${a.part} is fastened to ${parentOf(m, a.part)}, which places it; detach it first`);
-    const size = `size.${a.axis}`;
-    if (!m.inputs.some((i) => i.id === size && i.role === 'design'))
-        fail('TARGET_ABSENT', path, `the instance has no ${size}; declare it before keeping a place in proportion to it`);
-    const i = AXES.indexOf(a.axis);
-    const was = pose.args[i];
-    const values = compileFigureGraph(m).evaluate({ ...asset.designInputs, ...asset.stateDefaults }).values;
-    const value = values[was];
-    const of = values[size];
-    if (!Number.isFinite(value))
-        fail('TARGET_ABSENT', path, `${was} has no value to keep`);
-    if (!(Number.isFinite(of) && of > 0))
-        fail('GEOMETRY_DOMAIN', path, `${size} must be positive to take a share of it`);
-    const share = round6(value / of);
-    const ref = share === 0 ? constantOf(m, 'mm', 0, 'd') : scaled(m, namer(m, `${a.part}.position`), size, share, 0, a.axis);
-    pose.args = pose.args.map((r, k) => (k === i ? ref : r));
-    // The part's own position number is read by nothing now; left behind it would be a field that moves nothing.
-    if (was !== ref)
-        dropIfUnused(asset, was, ownInput(m, a.part, was) ? was : undefined);
-    return asset;
-}
-function fixPosition(asset, a) {
-    const m = asset.document.model;
-    const path = `${a.part}.${a.axis}`;
-    if (!AXES.includes(a.axis))
-        fail('SCHEMA', path, `${String(a.axis)} is not an axis`);
-    const { pose } = partOf(m, a.part, path);
-    if (pose.op !== 'rigid@1')
-        fail('EDIT_TARGET', path, `${a.part} is not posed by a rigid@1 this command can read`);
-    if (parentOf(m, a.part))
-        fail('EDIT_TARGET', path, `${a.part} is fastened to ${parentOf(m, a.part)}, which places it; detach it first`);
-    const i = AXES.indexOf(a.axis);
-    const was = pose.args[i];
-    if (ownInput(m, a.part, was))
-        return asset;
-    const values = compileFigureGraph(m).evaluate({ ...asset.designInputs, ...asset.stateDefaults }).values;
-    const value = round6(values[was]);
-    if (!Number.isFinite(value))
-        fail('TARGET_ABSENT', path, `${was} has no value to keep`);
-    const id = `${a.part}.position.${a.axis}`;
-    /* The part's own position number, if it has one (an expression may read it), takes the value; else it is made. */
-    const own = m.inputs.find((input) => input.id === id && input.role === 'design' && input.unit === 'mm');
-    const taken = !own && (m.inputs.some((input) => input.id === id) || m.nodes.some((n) => n.id === id || Object.values(n.outputs).includes(id)));
-    let ref;
-    if (taken)
-        ref = constantOf(m, 'mm', value, 'd');
-    else {
-        if (!own)
-            m.inputs.push({ id, unit: 'mm', min: -Number.MAX_VALUE, max: Number.MAX_VALUE, role: 'design' });
-        asset.designInputs[id] = value;
-        ref = id;
     }
-    pose.args = pose.args.map((r, k) => (k === i ? ref : r));
-    dropIfUnused(asset, was);
     return asset;
 }
 //# sourceMappingURL=authoring-actions.js.map