@hatiolab/figure-model 0.9.5 → 0.10.0

package/dist/{authoring-occupancy.js → authoring-placement.js}

@@ -2,41 +2,18 @@
  * Copyright © HatioLab Inc. All rights reserved.
  */
 /*
- * The room the figure takes up: proposed from its parts, declared, and the face it is mounted by.
+ * The room a figure sweeps as it moves (ADR-0145 2.3), worked out from its parts and joints; where it is placed from, and
+ * the face it is mounted by.
  */
-import { upgradeFigurePlacement, figurePlacementOf } from "./asset.js";
+import { figurePlacementOf } from "./asset.js";
 import { compileFigureGraph } from "./graph.js";
+import { figureShapeDescriptionOf } from "./shape-ops.js";
 import { FigureContractError } from "./contract.js";
 import { AXES } from "./words.js";
 import { FIGURE_PLACEMENTS } from "./asset-types.js";
 import { FIGURE_FACES } from "./authoring-types.js";
 import { fail, nodeById, writerOf, throughSums, rowHolding, partOf, namer, constantOf, dropIfUnused, parentOf, round6, stringsIn } from "./authoring-nodes.js";
-import { isReach, sizeRefsOf, occupiedExtentsOf, angleOf, turnMatrix, mul3, standingRefsOf, half, IDENTITY } from "./authoring-geometry.js";
-/** 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). Nor do the clips,
-      their groups and the data connections -- the room is measured over the joints' ranges, not what plays them -- and a
-      command is applied with the groups and their clips held aside (clip-keeping.ts): counted, a room proposed on the
-      figure as it is was stale against the same figure without them, and a figure with a motion group could not declare
-      its room again (the robot dog, 2026-10-19).
-    */
-    const text = JSON.stringify({
-        ...asset,
-        placement: undefined,
-        occupancy: asset.occupancy ? { ...asset.occupancy, bounds: null } : undefined,
-        drivers: undefined,
-        motionGroups: undefined,
-        dataInterface: 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}`;
-}
+import { isReach, sizeRefsOf, occupiedExtentsOf, angleOf, turnMatrix, mul3, standingRefsOf, half, axisTurn, offCentreEndsOf, IDENTITY } from "./authoring-geometry.js";
 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
@@ -63,7 +40,7 @@ const linOf = (m, ref) => {
  * 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).
+ * left out of the room it was given, 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;
@@ -133,7 +110,7 @@ function poseTurnOf(m, asset, part) {
 const seatTurned = (m, asset, part) => (nodeById(m, `${part}.seat.rigid`)?.args.slice(3, 6) ?? []).some((ref) => angleOf(m, asset, ref) !== 0);
 /**
  * Whether a part, or anything carrying it, turns on a joint, stands turned by other than quarter turns, or is seated
- * turned: a box cannot follow it, a ball about the point it turns at can (`reachOf`).
+ * turned: a box cannot follow it, its reach about the point it turns at can (`reachOf`).
  */
 function carriedByATurn(m, asset, id) {
     for (let part = id; part; part = parentOf(m, part)) {
@@ -258,8 +235,9 @@ function sizeValue(m, ref, seen = 0) {
     if (seen > 64)
         return false;
     const input = m.inputs.find((i) => i.id === ref);
+    /* The instance size is never below zero, its smallest end given or not (ADR-0087 decision 6). */
     if (input)
-        return input.role !== 'state' && input.min >= 0;
+        return input.role !== 'state' && (/^size\.[xyz]$/.test(input.id) || 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')
@@ -381,31 +359,6 @@ function boundedMagnitudeOf(m, ref, inside = false) {
         return linAdd({ terms: [], c: 0 }, linAdd(each[0], each[1]), 0.5);
     return each.reduce((a, b) => linAtLeast(a, b));
 }
-/** The values held by bounds a part's place reads, up what carries it: its room may be wider than it there. */
-function boundsUnder(m, id) {
-    const found = new Set();
-    for (let part = id; part; part = parentOf(m, part))
-        for (const node of [nodeById(m, `${part}.pose`), nodeById(m, `${part}.seat.rigid`)])
-            for (const ref of (node?.args ?? []).slice(0, 3))
-                for (const t of throughSums(m, linOf(m, ref)).terms)
-                    if (isBounded(m, t.ref))
-                        found.add(t.ref);
-    return [...found];
-}
-/**
- * How much wider than a bounded value its room may be, at the figure's values, in mm: the greatest of its bound over
- * the value -- (x + y) / 2 − √(x·y) for a root, r_i − |p_i| for a point of an ellipsoid (chief architect 2026-10-20).
- */
-function boundedWidthOf(m, values, refs) {
-    let most = 0;
-    for (const ref of refs) {
-        const kind = boundedKind(m, ref);
-        const v = Math.abs(values[ref] ?? 0);
-        const wide = 'root' in kind ? (values[kind.root[0]] + values[kind.root[1]]) / 2 - v : Math.abs(values[kind.point.radius]) - v;
-        most = Math.max(most, wide);
-    }
-    return Math.round(most * 10) / 10;
-}
 /** Every low candidate bounded from below and every high one from above, so the room holds whatever they come to. */
 function boundedSides(m, low, high) {
     for (const axis of AXES) {
@@ -413,14 +366,115 @@ function boundedSides(m, low, high) {
         high[axis] = high[axis].flatMap(l => boundsOf(m, l, true));
     }
 }
+const transposedTimes = (r, d) => [0, 1, 2].map(j => r[0][j] * d[0] + r[1][j] * d[1] + r[2][j] * d[2]);
+/** A turn as `rigid@1` writes it, in degrees about X, Y and Z: Rx·Ry·Rz, at any angle (`turnMatrix` takes quarter turns). */
+const rigidTurnOf = ([x, y, z]) => mul3(mul3(axisTurn('x', x), axisTurn('y', y)), axisTurn('z', z));
+/** Each component's largest size, which a unit direction never passes. */
+const largestOf = (d) => d.mid.map((v, i) => Math.min(1, Math.abs(v) + d.spread[i]));
+/** The same directions, each component held to [−1, 1]. */
+function heldToUnit(mid, spread) {
+    const lo = mid.map((v, i) => Math.max(-1, v - spread[i]));
+    const hi = mid.map((v, i) => Math.min(1, v + spread[i]));
+    return { mid: lo.map((l, i) => (l + hi[i]) / 2), spread: lo.map((l, i) => (hi[i] - l) / 2) };
+}
+/** The directions seen from a frame turned by `r` from this one (a point there is r·x here). */
+function turnedBy(d, r) {
+    return heldToUnit(transposedTimes(r, d.mid), [0, 1, 2].map(j => d.spread.reduce((sum, v, i) => sum + Math.abs(r[i][j]) * v, 0)));
+}
+/** The least and the greatest of a + b cos t + c sin t for t from lo to hi, in radians; all the way round without a range. */
+function rangeOver(a, b, c, range) {
+    if (!range)
+        return [a - Math.hypot(b, c), a + Math.hypot(b, c)];
+    const [lo, hi] = range;
+    const at = (t) => a + b * Math.cos(t) + c * Math.sin(t);
+    let least = Math.min(at(lo), at(hi)), most = Math.max(at(lo), at(hi));
+    /* Where its slope is zero: t = atan2(c, b) and half a turn from it, every whole turn over. */
+    const turn = 2 * Math.PI;
+    for (const t0 of [Math.atan2(c, b), Math.atan2(c, b) + Math.PI])
+        for (let t = t0 + Math.ceil((lo - t0) / turn) * turn; t <= hi; t += turn) {
+            least = Math.min(least, at(t));
+            most = Math.max(most, at(t));
+        }
+    return [least, most];
+}
 /**
- * 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.
+ * The directions seen from a frame turned about the unit axis `u` by any angle in `range` (radians; null all the way
+ * round): R(t) = u uᵀ + (I − u uᵀ) cos t + [u]× sin t, each entry a + b cos t + c sin t. The middle is turned through
+ * the range exactly; the spread about it by each entry's largest.
  */
-function reachOf(m, asset, id, ends, freezeless = true) {
+function sweptBy(d, u, range) {
+    const K = [
+        [0, -u[2], u[1]],
+        [u[2], 0, -u[0]],
+        [-u[1], u[0], 0]
+    ];
+    const A = (i, j) => u[i] * u[j];
+    const B = (i, j) => (i === j ? 1 : 0) - u[i] * u[j];
+    const C = (i, j) => K[i][j];
+    if (range && Math.abs(range[1] - range[0]) < 1e-12) {
+        const t = range[0];
+        return turnedBy(d, [0, 1, 2].map(i => [0, 1, 2].map(j => A(i, j) + B(i, j) * Math.cos(t) + C(i, j) * Math.sin(t))));
+    }
+    const sum = (f, j) => [0, 1, 2].reduce((s, i) => s + f(i, j) * d.mid[i], 0);
+    const ends = [0, 1, 2].map(j => rangeOver(sum(A, j), sum(B, j), sum(C, j), range));
+    const spread = [0, 1, 2].map(j => d.spread.reduce((s, v, i) => {
+        const [l, h] = rangeOver(A(i, j), B(i, j), C(i, j), range);
+        return s + Math.max(Math.abs(l), Math.abs(h)) * v;
+    }, 0));
+    return heldToUnit(ends.map(([l, h]) => (l + h) / 2), ends.map(([l, h], j) => (h - l) / 2 + spread[j]));
+}
+/**
+ * The angles a turn's control can give it, in degrees: its limits, scaled and moved as the angle is written from it.
+ * Null -- all the way round -- for a control without limits or that turns a whole turn, and for an angle written any
+ * other way.
+ */
+function angleRangeOf(m, ref, depth = 0) {
+    if (depth > 64)
+        return null;
+    const constant = m.constants.find((c) => c.id === ref);
+    if (constant)
+        return constant.unit === 'deg' ? [constant.value, constant.value] : null;
+    const input = m.inputs.find((i) => i.id === ref);
+    if (input) {
+        if (input.role !== 'state' || input.unit !== 'deg')
+            return null;
+        const { min, max } = input;
+        return Number.isFinite(min) && Number.isFinite(max) && max - min < 360 ? [min, max] : null;
+    }
+    const w = writerOf(m, ref);
+    if (w?.op === 'add@1') {
+        let lo = 0, hi = 0;
+        for (const arg of w.args) {
+            const r = angleRangeOf(m, arg, depth + 1);
+            if (!r)
+                return null;
+            lo += r[0];
+            hi += r[1];
+        }
+        return hi - lo < 360 ? [lo, hi] : null;
+    }
+    if (w?.op === 'mul@1' && w.args.length === 2) {
+        const factor = (arg) => m.constants.find((c) => c.id === arg && c.unit === 'ratio')?.value;
+        const [a, b] = w.args;
+        const k = factor(a) ?? factor(b);
+        const r = factor(a) !== undefined ? angleRangeOf(m, b, depth + 1) : factor(b) !== undefined ? angleRangeOf(m, a, depth + 1) : null;
+        if (k === undefined || !r)
+            return null;
+        const ends = [r[0] * k, r[1] * k].sort((x, y) => x - y);
+        return ends[1] - ends[0] < 360 ? ends : null;
+    }
+    return null;
+}
+/**
+ * Where a part carried by a turn can reach, on each side of each axis, from the point the first turn above it turns
+ * about (ADR-0087, amendments 2026-10-21). Down the chain from there each step adds what it can add that way: the
+ * middle of the directions times the step, sign included, and their spread -- none until a joint has turned them
+ * through its range -- times its size; no more than its length, when its coordinates are numbers. A slide from nothing
+ * to a sum of sizes adds only toward the way it goes. The part adds its own extent the same way. Each step's largest taken on its own (the triangle inequality), it holds at
+ * every angle the joints can reach and every design size: a bound, not a sample. Read by the proposal; the release
+ * gate still checks the parts against it.
+ */
+function reachOf(m, asset, id, ends) {
     const chain = [];
     for (let part = id; part; part = parentOf(m, part))
         chain.push(part);
@@ -432,56 +486,170 @@ function reachOf(m, asset, id, ends, freezeless = true) {
         : 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 pivotPart = chain[top];
+    const parent = parentOf(m, pivotPart);
+    /* Above the pivot every part stands in quarter turns: the frame it turns in is a signed axis permutation. */
+    const frame = parent ? worldTurnOf(m, asset, parent) : IDENTITY;
+    if (!frame)
+        return `${pivotPart} is carried by a part turned by other than quarter turns`;
     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 { shape } = partOf(m, id, id);
+    const faces = figureShapeDescriptionOf(shape)?.faces;
+    const offCentre = Object.fromEntries(AXES.map(axis => [axis, offCentreEndsOf(shape, faces, axis)]));
+    const constants = (refs) => refs.map(r => m.constants.find((c) => c.id === r)?.value);
+    const angles = (refs) => refs.map(r => angleOf(m, asset, r));
+    const reachToward = (e) => {
+        let d = { mid: transposedTimes(frame, e), spread: [0, 0, 0] };
+        let out = { terms: [], c: 0 };
+        const tiny = (v) => Math.abs(v) < 1e-12;
+        /* A step of three coordinates, in the frame the directions are seen from: the middle times it, the spread times its size. */
+        const step = (refs, what) => {
+            const numbers = constants(refs);
+            if (numbers.every(n => n !== undefined)) {
+                const across = numbers.reduce((s, n, i) => s + d.mid[i] * n + d.spread[i] * Math.abs(n), 0);
+                /* No unit direction takes a step further than its length. */
+                const w = largestOf(d);
+                const length = Math.hypot(...numbers.map((n, i) => (w[i] > 0 ? n : 0)));
+                out = linAdd(out, { terms: [], c: Math.min(across, length) });
+                return null;
             }
-            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`);
+            for (const [i, ref] of refs.entries()) {
+                if (!tiny(d.mid[i]))
+                    out = linAdd(out, linOf(m, ref), d.mid[i]);
+                if (tiny(d.spread[i]))
+                    continue;
+                const size = magnitudeOf(m, linOf(m, ref));
+                if (!size)
+                    return `${what} is not a sum of sizes, so how far it reaches cannot be bounded`;
+                out = linAdd(out, size, d.spread[i]);
+            }
+            return null;
+        };
+        const turnTo = (refs) => {
+            const a = angles(refs);
+            if (a.every(t => t === 0))
+                return;
+            if (a.every(t => t !== null && Number.isFinite(t)))
+                d = turnedBy(d, rigidTurnOf(a));
+            else {
+                /* A turn this command cannot read: any direction no longer than the largest it was. */
+                const reach = Math.min(1, largestOf(d).reduce((s, v) => s + v, 0));
+                d = { mid: [0, 0, 0], spread: [reach, reach, reach] };
+            }
+        };
+        for (let i = top; i >= 0; i--) {
+            const part = chain[i];
+            const seat = nodeById(m, `${part}.seat.rigid`);
+            if (seat) {
+                /* The pivot's own seat is where it turns: it is the centre, not a step. */
+                if (i < top) {
+                    const bad = step(seat.args.slice(0, 3), `where ${part} is fastened`);
                     if (bad)
                         return bad;
                 }
+                turnTo(seat.args.slice(3, 6));
+            }
+            const motion = nodeById(m, `${part}.motion`);
+            if (motion) {
+                const unit = constants(motion.args.slice(0, 3));
+                if (unit.some(u => u === undefined))
+                    return `${part}'s ${motion.op === 'axis-turn@1' ? 'turn' : 'slide'} axis is not a constant`;
+                const n = Math.hypot(...unit);
+                const u = unit.map(v => v / n);
+                if (motion.op === 'axis-turn@1') {
+                    const range = angleRangeOf(m, motion.args[3]);
+                    d = sweptBy(d, u, range && [(range[0] * Math.PI) / 180, (range[1] * Math.PI) / 180]);
+                }
+                else if (motion.op === 'axis-slide@1') {
+                    /*
+                      Its travel lies between the two ends of its control. One end at nothing and the other a sum of sizes: it
+                      goes only that way, so the middle adds it only toward that side. Otherwise the further end, either way.
+                    */
+                    const mid = d.mid.reduce((s, v, k) => s + v * u[k], 0);
+                    const spread = d.spread.reduce((s, v, k) => s + v * Math.abs(u[k]), 0);
+                    const [lo, hi] = ['min', 'max'].map(end => travelAt(m, asset, motion, end));
+                    if (!lo || !hi)
+                        return `${part}'s travel is not a sum of sizes, so how far it reaches cannot be bounded`;
+                    const nothing = (l) => !linNorm(l).terms.length && Math.abs(l.c) < 1e-12;
+                    const sizes = (l) => l.c >= 0 && linNorm(l).terms.every(t => t.k > 0 && sizeValue(m, t.ref));
+                    const other = nothing(lo) ? hi : nothing(hi) ? lo : null;
+                    const way = other && (sizes(other) ? 1 : sizes(linAdd({ terms: [], c: 0 }, other, -1)) ? -1 : 0);
+                    if (other && way)
+                        out = linAdd(out, other, way * (Math.max(way * mid, 0) + spread));
+                    else {
+                        const further = [lo, hi].reduce((sum, l) => {
+                            const size = sum && magnitudeOf(m, l);
+                            return size && sum && linAtLeast(sum, size);
+                        }, { terms: [], c: 0 });
+                        if (!further)
+                            return `${part}'s travel is not a sum of sizes, so how far it reaches cannot be bounded`;
+                        out = linAdd(out, further, Math.abs(mid) + spread);
+                    }
+                }
+                else
+                    return `${part} moves by ${motion.op}, which this command does not add up`;
+            }
+            const pose = nodeById(m, `${part}.pose`);
+            if (!pose)
+                return `${part} has no pose this command can read`;
+            const bad = step(pose.args.slice(0, 3), `${part}'s place`);
+            if (bad)
+                return bad;
+            turnTo(pose.args.slice(3, 6));
         }
+        /*
+          Its own extent on every axis, as far as the directions reach across it: half its size either way about its
+          origin, or from face to face where they do not sit about it (a portal stands on 0, `offCentreEndsOf`) -- the
+          middle at the face it points to, the spread times the further face.
+        */
+        for (const [i, axis] of AXES.entries()) {
+            const mid = d.mid[i], spread = d.spread[i];
+            if (tiny(mid) && tiny(spread))
+                continue;
+            const ends = offCentre[axis];
+            if (ends) {
+                const e = mid > 0 ? ends[1] : ends[0];
+                if (!tiny(mid))
+                    out = linAdd(out, { terms: [{ ref: e.ref, k: e.k * mid }], c: 0 });
+                if (tiny(spread))
+                    continue;
+                const further = ends.reduce((sum, x) => {
+                    const size = sum && magnitudeOf(m, { terms: [{ ref: x.ref, k: x.k }], c: 0 });
+                    return size && sum && linAtLeast(sum, size);
+                }, { terms: [], c: 0 });
+                if (!further)
+                    return `${id}'s size is not a sum of sizes, so how far it reaches cannot be bounded`;
+                out = linAdd(out, further, spread);
+                continue;
+            }
+            const half = magnitudeOf(m, { terms: [{ ref: sizes[axis].ref, k: 0.5 * sizes[axis].k }], c: 0 });
+            if (!half)
+                return `${id}'s size is not a sum of sizes, so how far it reaches cannot be bounded`;
+            out = linAdd(out, half, Math.min(1, Math.abs(mid) + spread));
+        }
+        return linNorm(out);
+    };
+    const up = {};
+    const down = {};
+    for (const [i, axis] of AXES.entries()) {
+        const e = [0, 0, 0];
+        e[i] = 1;
+        const high = reachToward(e);
+        if (typeof high === 'string')
+            return high;
+        e[i] = -1;
+        const low = reachToward(e);
+        if (typeof low === 'string')
+            return low;
+        up[axis] = high;
+        down[axis] = low;
     }
     /*
       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).
+      end of the controls, a reach from each: a slide is a straight line, so the reaches from 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 = [];
@@ -492,21 +660,40 @@ function reachOf(m, asset, id, ends, freezeless = true) {
             return at;
         centres.push(at);
     }
-    return { centres, radius };
+    return { centres, up, down };
 }
 /** The bounds the parts come to, as sums, with what could not be read named. */
-function occupancyLins(asset, over) {
+function reachLins(asset) {
     const m = asset.document.model;
     const parts = [];
     const skipped = [];
-    const bounded = [];
     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();
+    /*
+      Parts carried by the same turn each bound their own reach about its pivot, and the room takes the largest when the
+      graph is evaluated (ADR-0087, 2026-10-21). One ball per pivot, its radius the larger of theirs term by term, was
+      every branch added up: each part's sizes and places are values of its own, and a humanoid's torso, head and two arms
+      under its waist came to 8210 mm across for a body 300 mm wide. A reach that another one passes at every size -- by a
+      number and sizes, never below zero -- is left out.
+    */
+    const reaches = {
+        low: { x: [], y: [], z: [] },
+        high: { x: [], y: [], z: [] }
+    };
+    const atLeast = (a, b) => {
+        const gap = linNorm(linAdd(a, b, -1));
+        return gap.c >= -1e-9 && gap.terms.every(t => t.k > 0 && sizeValue(m, t.ref));
+    };
+    const addReach = (side, axis, lin) => {
+        const list = reaches[side][axis];
+        const further = (a, b) => (side === 'high' ? atLeast(a, b) : atLeast(b, a));
+        if (list.some(o => further(o, lin)))
+            return;
+        reaches[side][axis] = [...list.filter(o => !further(lin, o)), lin];
+    };
     /* 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'];
+    const ends = ['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. */
@@ -630,14 +817,14 @@ function occupancyLins(asset, over) {
                 */
                 for (const { run } of rows) {
                     for (const l of run.lows)
-                        low[run.axis].push(linAdd(l, reach.radius, -1));
+                        low[run.axis].push(linAdd(l, reach.down[run.axis], -1));
                     for (const h of run.highs)
-                        high[run.axis].push(linAdd(h, reach.radius, 1));
+                        high[run.axis].push(linAdd(h, reach.up[run.axis], 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);
+                        const lo = linAdd(at[axis], reach.down[axis], -1);
+                        const hi = linAdd(at[axis], reach.up[axis], 1);
                         low[axis].push(lo);
                         high[axis].push(hi);
                         climbed(lo, -1, low, axis);
@@ -645,12 +832,11 @@ function occupancyLins(asset, over) {
                     }
                 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) });
-            }
+            for (const at of reach.centres)
+                for (const axis of AXES) {
+                    addReach('low', axis, linNorm(linAdd(at[axis], reach.down[axis], -1)));
+                    addReach('high', axis, linNorm(linAdd(at[axis], reach.up[axis], 1)));
+                }
             continue;
         }
         /*
@@ -740,40 +926,34 @@ function occupancyLins(asset, over) {
             }
         }
     }
-    for (const part of parts)
-        if (boundsUnder(m, part).length)
-            bounded.push(part);
-    return { parts, skipped, bounded, low, high, balls: [...balls.values()] };
+    return { parts, skipped, low, high, reaches };
 }
 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`);
+/**
+ * The room a figure sweeps (ADR-0145 2.3): every part over every joint's range, at the authored size or at `sizes`
+ * (design inputs, by id). Computed, never declared -- it holds the parts by what it is. Undefined for a figure with no
+ * part to measure. Reads the asset; changes nothing.
+ */
+export function figureMotionRangeOf(asset, sizes = {}) {
     const source = structuredClone(asset);
-    const { parts, skipped, bounded, 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));
-        }
+    const { parts, skipped, low, high, reaches } = reachLins(source);
+    for (const axis of AXES) {
+        low[axis].push(...reaches.low[axis]);
+        high[axis].push(...reaches.high[axis]);
+    }
     boundedSides(source.document.model, low, high);
     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 })
+        return undefined;
+    const values = compileFigureGraph(source.document.model).evaluate({ ...source.designInputs, ...source.stateDefaults, ...sizes })
         .values;
-    const at = Object.fromEntries(AXES.map(axis => [
+    const bounds = 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))))
         }
     ]));
-    const m = source.document.model;
-    const held = bounded.map(part => ({ part, mm: boundedWidthOf(m, values, boundsUnder(m, part)) }));
-    return { over, at, parts, skipped, ...(held.length ? { bounded: held } : {}), basis: fingerprintOf(source) };
+    return { bounds, parts, skipped };
 }
 /**
  * The placement says which plane the mounting plane is. A part fastened to it in a way the new plane does not take --
@@ -797,87 +977,9 @@ export function setPlacement(asset, a) {
     asset.placement = a.placement;
     return asset;
 }
-export 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));
-        }
-    boundedSides(m, low, high);
-    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 = throughSums(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. */
+/** "This face is what the figure is mounted on." */
 export 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);
@@ -890,16 +992,16 @@ export function setMountingFace(asset, a) {
             outputs: { pose: `${id}.value` },
             params: { frame: `${id}.frame`, name: a.face }
         });
-    asset.occupancy.contact = {
+    asset.mountingFace = {
         plane: 'mounting-plane',
         surface: { placement: place.outputs.placed, feature: `${id}.value` }
     };
     return asset;
 }
 export function clearMountingFace(asset) {
-    if (!asset.occupancy?.contact)
-        fail('EDIT_TARGET', 'occupancy', 'this figure names no mounting face');
-    delete asset.occupancy.contact;
+    if (!asset.mountingFace)
+        fail('EDIT_TARGET', 'mountingFace', 'this figure names no mounting face');
+    delete asset.mountingFace;
     return asset;
 }
-//# sourceMappingURL=authoring-occupancy.js.map
+//# sourceMappingURL=authoring-placement.js.map