@hatiolab/figure-model 0.9.4 → 0.9.6

package/dist/authoring-occupancy.js

@@ -6,12 +6,13 @@
  */
 import { upgradeFigurePlacement, 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, 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";
+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, axisTurn, offCentreEndsOf, 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) {
     /*
@@ -59,34 +60,6 @@ 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
@@ -161,7 +134,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)) {
@@ -286,8 +259,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')
@@ -304,12 +278,20 @@ function sizeValue(m, ref, seen = 0) {
  * 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) {
+function magnitudeOf(m, sum) {
     let out = { terms: [], c: 0 };
+    /* Read through its sums first: what cancels there -- a rim's place taken back out of a pose -- is not counted. */
+    const lin = throughSums(m, sum);
     for (const t of lin.terms) {
         const a = affineOf(m, t.ref);
-        if (!a)
-            return null;
+        if (!a) {
+            /* A value held by bounds (`boundsOf`): no larger than its bound -- √(x·y) ≤ (|x| + |y|) / 2, a largest or least ≤ the larger. */
+            const bound = boundedMagnitudeOf(m, t.ref);
+            if (!bound)
+                return null;
+            out = linAdd(out, bound, Math.abs(t.k));
+            continue;
+        }
         for (const u of a.terms) {
             if (!sizeValue(m, u.ref))
                 return null;
@@ -321,13 +303,223 @@ function magnitudeOf(m, lin) {
     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.
+ * Places a fastening writes that are not sums (ADR-0140 3.9) are held by bounds, each a few sums (chief architect
+ * 2026-10-20): the room takes them as candidates, the least of the lows and the greatest of the highs, so it holds at
+ * every design size though it may be wider than the parts by a little -- and says by how much (`bounded`).
+ *   - where a part lined up with a disc's rim stands, √((R − E)(R + E));
+ *   - a point of an ellipsoid of two radii, r_i² · n_i / hypot(r·n), written as (r_i · r_i · n_i) / hypot: it lies on the
+ *     ellipsoid, so between 0 and r_i on the side n_i points to.
+ * A root of sizes alone -- the one ratio a figure grows by -- is a size, read as it is (`sizeValue`).
+ */
+function boundedKind(m, ref) {
+    const w = writerOf(m, ref);
+    if (w?.op === 'geomean@1' && !sizeValue(m, ref))
+        return { root: [w.args[0], w.args[1]] };
+    if (w?.op !== 'div@1')
+        return undefined;
+    const top = writerOf(m, w.args[0]);
+    const k = top?.op === 'mul@1' ? m.constants.find((c) => c.id === top.args[1] && c.unit === 'ratio')?.value : undefined;
+    const square = k ? writerOf(m, top.args[0]) : undefined;
+    if (square?.op !== 'mul@1' || square.args[0] !== square.args[1])
+        return undefined;
+    return { point: { radius: square.args[0], sign: k > 0 ? 1 : -1 } };
+}
+const isBounded = (m, ref) => boundedKind(m, ref) !== undefined;
+/**
+ * Sums that bound a value from above (`up`: its greatest is at least the value) or below (its least is at most it):
+ *     √(x·y) ∈ [min(x, y), (x + y) / 2]        a point of an ellipsoid ∈ [0, r_i] on the side n_i points to
+ * read through the sums and ratios that make it up; a term with a negative factor bounded the other way. What is
+ * inside the root -- the largest of R − E and 0 -- is read as it is, as the room reads any largest.
  */
-function reachOf(m, asset, id, ends, freezeless = true) {
+function boundsOf(m, lin, up, seen = 0) {
+    const flat = throughSums(m, lin);
+    let out = [{ terms: [], c: flat.c }];
+    for (const t of flat.terms) {
+        let candidates = [{ terms: [t], c: 0 }];
+        const kind = seen < 64 ? boundedKind(m, t.ref) : undefined;
+        if (kind) {
+            const way = t.k > 0 ? up : !up;
+            let raw;
+            if ('root' in kind) {
+                const each = kind.root.map(ref => boundsOf(m, { terms: [{ ref, k: 1 }], c: 0 }, way, seen + 1));
+                raw = way ? each[0].flatMap(x => each[1].map(y => linAdd({ terms: [], c: 0 }, linAdd(x, y), 0.5))) : each.flat();
+            }
+            else {
+                /* Toward its side the radius, away from it the middle. */
+                const far = kind.point.sign > 0 === way;
+                raw = far ? boundsOf(m, { terms: [{ ref: kind.point.radius, k: kind.point.sign }], c: 0 }, way, seen + 1) : [{ terms: [], c: 0 }];
+            }
+            candidates = raw.map(c => linAdd({ terms: [], c: 0 }, c, t.k));
+        }
+        out = out.flatMap(o => candidates.map(c => linAdd(o, c)));
+    }
+    return out.map(linNorm);
+}
+/**
+ * How large a bounded root can be, as one sum of sizes: √(x·y) no more than (|x| + |y|) / 2; the largest or least of
+ * values inside it no more than the larger of them.
+ */
+function boundedMagnitudeOf(m, ref, inside = false) {
+    const w = writerOf(m, ref);
+    const kind = boundedKind(m, ref);
+    if (kind && 'point' in kind)
+        return magnitudeOf(m, { terms: [{ ref: kind.point.radius, k: 1 }], c: 0 });
+    if (!(kind || (inside && (w?.op === 'max@1' || w?.op === 'min@1'))))
+        return null;
+    const each = w.args.map(a => {
+        const lin = throughSums(m, { terms: [{ ref: a, k: 1 }], c: 0 });
+        let out = { terms: [], c: Math.abs(lin.c) };
+        for (const t of lin.terms) {
+            const size = affineOf(m, t.ref) ? magnitudeOf(m, { terms: [t], c: 0 }) : boundedMagnitudeOf(m, t.ref, true);
+            if (!size)
+                return null;
+            out = linAdd(out, size, Math.abs(t.k));
+        }
+        return out;
+    });
+    if (each.some(e => !e))
+        return null;
+    if (w.op === 'geomean@1')
+        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) {
+        low[axis] = low[axis].flatMap(l => boundsOf(m, l, false));
+        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));
+/** The directions seen from a frame turned by `r` from this one (a point there is r·x here). */
+function turnedBy(d, r) {
+    if ('one' in d)
+        return { one: transposedTimes(r, d.one) };
+    return { most: [0, 1, 2].map(j => Math.min(1, d.most.reduce((sum, v, i) => sum + Math.abs(r[i][j]) * v, 0))) };
+}
+/** The largest |a + b cos t + c sin t| for t from lo to hi, in radians; all the way round without a range. */
+function largestOver(a, b, c, range) {
+    if (!range)
+        return Math.abs(a) + Math.hypot(b, c);
+    const [lo, hi] = range;
+    const at = (t) => Math.abs(a + b * Math.cos(t) + c * Math.sin(t));
+    let 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)
+            most = Math.max(most, at(t));
+    return most;
+}
+/**
+ * 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.
+ */
+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))));
+    }
+    if ('one' in d) {
+        const v = d.one;
+        const sum = (f, j) => [0, 1, 2].reduce((s, i) => s + f(i, j) * v[i], 0);
+        const parts = [0, 1, 2].map(j => [sum(A, j), sum(B, j), sum(C, j)]);
+        /* Along the axis it is turned about, a direction does not move. */
+        if (parts.every(([, b, c]) => Math.abs(b) < 1e-12 && Math.abs(c) < 1e-12))
+            return d;
+        return { most: parts.map(([a, b, c]) => Math.min(1, largestOver(a, b, c, range))) };
+    }
+    return {
+        most: [0, 1, 2].map(j => Math.min(1, d.most.reduce((s, v, i) => s + largestOver(A(i, j), B(i, j), C(i, j), range) * v, 0)))
+    };
+}
+/**
+ * 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: while
+ * the directions are one, what it adds, sign included; once a joint has turned them through its range, each axis's
+ * largest times the size of that coordinate -- no more than its length, when its coordinates are numbers. The part
+ * adds its own half size 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);
@@ -339,56 +531,149 @@ 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 = { one: transposedTimes(frame, e) };
+        let out = { terms: [], c: 0 };
+        const most = (dir) => ('one' in dir ? dir.one.map(Math.abs) : dir.most);
+        /* A step of three coordinates, in the frame the directions are seen from. */
+        const step = (refs, what) => {
+            if ('one' in d) {
+                const v = d.one;
+                refs.forEach((ref, i) => {
+                    if (Math.abs(v[i]) > 1e-12)
+                        out = linAdd(out, linOf(m, ref), v[i]);
+                });
+                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`);
+            const w = d.most;
+            const numbers = constants(refs);
+            if (numbers.every(n => n !== undefined)) {
+                const across = numbers.reduce((s, n, i) => s + w[i] * Math.abs(n), 0);
+                const length = Math.hypot(...numbers.map((n, i) => (w[i] > 0 ? n : 0)));
+                out = linAdd(out, { terms: [], c: Math.min(across, length) });
+                return null;
+            }
+            for (const [i, ref] of refs.entries()) {
+                if (!w[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, w[i]);
+            }
+            return null;
+        };
+        const turnTo = (refs) => {
+            const a = angles(refs);
+            if (a.every(t => t === 0))
+                return;
+            d = a.every(t => t !== null && Number.isFinite(t))
+                ? turnedBy(d, rigidTurnOf(a))
+                : { most: [0, 1, 2].map(() => Math.min(1, most(d).reduce((s, v) => s + v, 0))) };
+        };
+        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') {
+                    const along = most(d).reduce((s, v, k) => s + v * Math.abs(u[k]), 0);
+                    for (const end of ['min', 'max']) {
+                        const travel = travelAt(m, asset, motion, end);
+                        const size = travel && magnitudeOf(m, travel);
+                        if (!size)
+                            return `${part}'s travel is not a sum of sizes, so how far it reaches cannot be bounded`;
+                        out = linAdd(out, size, along);
+                    }
+                }
+                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`).
+        */
+        const w = most(d);
+        for (const [i, axis] of AXES.entries()) {
+            if (!w[i])
+                continue;
+            const ends = offCentre[axis];
+            if (ends && 'one' in d) {
+                const e = d.one[i] > 0 ? ends[1] : ends[0];
+                out = linAdd(out, { terms: [{ ref: e.ref, k: e.k * d.one[i] }], c: 0 });
+                continue;
+            }
+            const reach = ends
+                ? ends.reduce((sum, e) => {
+                    const size = sum && magnitudeOf(m, { terms: [{ ref: e.ref, k: e.k }], c: 0 });
+                    return size && sum && linAtLeast(sum, size);
+                }, { terms: [], c: 0 })
+                : magnitudeOf(m, { terms: [{ ref: sizes[axis].ref, k: 0.5 * sizes[axis].k }], c: 0 });
+            if (!reach)
+                return `${id}'s size is not a sum of sizes, so how far it reaches cannot be bounded`;
+            out = linAdd(out, reach, w[i]);
+        }
+        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 = [];
@@ -399,17 +684,38 @@ 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) {
     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'];
@@ -536,14 +842,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);
@@ -551,12 +857,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;
         }
         /*
@@ -646,7 +951,10 @@ function occupancyLins(asset, over) {
             }
         }
     }
-    return { parts, skipped, low, high, balls: [...balls.values()] };
+    for (const part of parts)
+        if (boundsUnder(m, part).length)
+            bounded.push(part);
+    return { parts, skipped, bounded, 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. */
@@ -656,12 +964,12 @@ export function proposeFigureOccupancy(asset, options = {}) {
     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));
-        }
+    const { parts, skipped, bounded, low, high, reaches } = occupancyLins(source, over);
+    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 })
@@ -673,7 +981,9 @@ export function proposeFigureOccupancy(asset, options = {}) {
             max: round6(Math.max(...high[axis].map(l => valueOfLin(values, l))))
         }
     ]));
-    return { over, at, parts, skipped, basis: fingerprintOf(source) };
+    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) };
 }
 /**
  * The placement says which plane the mounting plane is. A part fastened to it in a way the new plane does not take --
@@ -714,13 +1024,13 @@ export function declareOccupancy(asset, a) {
             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));
-        }
+    const { parts, low, high, reaches } = occupancyLins(asset, a.proposal.over);
+    /* What the parts carried by a turn reach either way about their pivots, on each axis. */
+    for (const axis of AXES) {
+        low[axis].push(...reaches.low[axis]);
+        high[axis].push(...reaches.high[axis]);
+    }
+    boundedSides(m, low, high);
     for (const axis of AXES) {
         if (!padding[axis])
             continue;
@@ -733,7 +1043,7 @@ export function declareOccupancy(asset, a) {
     const args = [];
     const layout = AXES.flatMap(axis => [low[axis], high[axis]]).map(side => side
         .map((l) => {
-        const n = linThroughSums(m, 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'));