@hatiolab/figure-model 0.9.6 → 0.11.0

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

@@ -2,9 +2,10 @@
  * 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";
@@ -13,31 +14,7 @@ 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, 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) {
-    /*
-      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 { motionStagesOf } from "./authoring-fastening.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
@@ -60,14 +37,74 @@ 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 };
 };
+/** Most controls a part's slides are read over corner by corner: 2^n corners, so a bound is kept on n. */
+const CORNER_CONTROLS = 10;
+/** The state inputs a value reads, through whatever writes it. */
+function statesReaching(m, ref, out = new Set(), depth = 0) {
+    if (m.inputs.some((i) => i.id === ref && i.role === 'state'))
+        out.add(ref);
+    const w = depth < 256 ? writerOf(m, ref) : undefined;
+    for (const a of w?.args ?? [])
+        if (typeof a === 'string')
+            statesReaching(m, a, out, depth + 1);
+    return out;
+}
+/**
+ * Every corner of the controls that slide a part or what carries it: each control at its least or its greatest, apart
+ * from the others. Two slides that pull one way and the other reach furthest with one at each end, which all-least
+ * and all-greatest miss (review 2026-10-24, F1: a block 70 mm out of the room it was given). A control two slides read
+ * takes one end for both. More controls than `CORNER_CONTROLS` are too many corners to read one by one: they are
+ * given back to be bounded apart (`wideReadingOf`).
+ */
+function cornersOf(m, id) {
+    const states = new Set();
+    for (let part = id; part; part = parentOf(m, part))
+        for (const { motion } of motionStagesOf(m, part))
+            if (motion.op === 'axis-slide@1')
+                statesReaching(m, motion.args[3], states);
+    const list = [...states].sort();
+    if (list.length > CORNER_CONTROLS)
+        return { many: list };
+    if (list.length <= 1)
+        return ['min', 'max'];
+    return Array.from({ length: 2 ** list.length }, (_, n) => Object.fromEntries(list.map((s, i) => [s, (n >> i) & 1 ? 'max' : 'min'])));
+}
+/** Said where too many controls slide a part for this reading to go corner by corner. */
+const tooManyCorners = (id, many) => `${id} is slid by ${many.length} controls; this reading goes over at most ${CORNER_CONTROLS} of them corner by corner`;
+/**
+ * Where a part slid by more controls than its corners can be read over is on one axis: a bound, never a sample (review
+ * 2026-10-24, F5). Its centre is linear in each control apart -- a slide's travel is its control times a length, and a
+ * follower's a sum of its leaders' -- so from every control at its least, each control taken to its greatest moves it
+ * by a sum d; wherever the controls stand, it is within the sum of every |d| either way of that. |d| is read as sizes,
+ * which are never below zero; a d that is not a sum of sizes cannot be bounded and is said.
+ */
+function wideReadingOf(m, asset, id, axis, states) {
+    const least = Object.fromEntries(states.map(s => [s, 'min']));
+    const from = centreLin(m, asset, id, axis, least);
+    if (typeof from === 'string')
+        return from;
+    let spread = { terms: [], c: 0 };
+    for (const s of states) {
+        const moved = centreLin(m, asset, id, axis, { ...least, [s]: 'max' });
+        if (typeof moved === 'string')
+            return moved;
+        const size = magnitudeOf(m, linAdd(moved, from, -1));
+        if (!size)
+            return `${id}'s travel is not a sum of sizes, so how far it reaches cannot be bounded`;
+        spread = linAdd(spread, size);
+    }
+    return [linAdd(from, spread, -1), linAdd(from, spread)];
+}
 /**
  * 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;
+    const pick = (i) => typeof bound === 'object'
+        ? (bound[i.id] === 'min' ? i.min : i.max)
+        : 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. */
@@ -130,6 +167,8 @@ function poseTurnOf(m, asset, part) {
         return null;
     return turn.every(isQuarter) ? turnMatrix(turn) : 'other';
 }
+/** Whether any axis a part moves on turns (ADR-0159: a part may move on several). */
+const turnsOnAJoint = (m, part) => motionStagesOf(m, part).some(s => s.motion.op === 'axis-turn@1');
 /** Whether a part's seat is turned: its joint frame turned by `origin.parentRotate` (ADR-0107). */
 const seatTurned = (m, asset, part) => (nodeById(m, `${part}.seat.rigid`)?.args.slice(3, 6) ?? []).some((ref) => angleOf(m, asset, ref) !== 0);
 /**
@@ -138,7 +177,7 @@ const seatTurned = (m, asset, part) => (nodeById(m, `${part}.seat.rigid`)?.args.
  */
 function carriedByATurn(m, asset, id) {
     for (let part = id; part; part = parentOf(m, part)) {
-        if (nodeById(m, `${part}.motion`)?.op === 'axis-turn@1')
+        if (turnsOnAJoint(m, part))
             return true;
         if (poseTurnOf(m, asset, part) === 'other' || seatTurned(m, asset, part))
             return true;
@@ -178,8 +217,8 @@ function centreVec(m, asset, id, bound, from) {
         }
         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) {
+        /* Slides add up in any order, and a slide along a line through a point is the slide: the point is not read. */
+        for (const { motion } of motionStagesOf(m, part)) {
             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
@@ -383,31 +422,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) {
@@ -418,29 +432,38 @@ function boundedSides(m, low, high) {
 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) {
-    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))) };
+    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 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) {
+/** 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 Math.abs(a) + Math.hypot(b, c);
+        return [a - Math.hypot(b, c), 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));
+    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)
+        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 most;
+        }
+    return [least, 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.
+ * 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 sweptBy(d, u, range) {
     const K = [
@@ -455,18 +478,13 @@ function sweptBy(d, u, range) {
         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)))
-    };
+    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.
@@ -512,19 +530,19 @@ function angleRangeOf(m, ref, depth = 0) {
 }
 /**
  * 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
+ * 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) {
+function reachOf(m, asset, id) {
     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' ||
+    const top = chain.reduce((found, part, i) => turnsOnAJoint(m, part) ||
         poseTurnOf(m, asset, part) === 'other' ||
         seatTurned(m, asset, part)
         ? i
@@ -544,34 +562,29 @@ function reachOf(m, asset, id, ends) {
     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 d = { mid: transposedTimes(frame, e), spread: [0, 0, 0] };
         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 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) => {
-            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 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 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;
             }
             for (const [i, ref] of refs.entries()) {
-                if (!w[i])
+                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, w[i]);
+                out = linAdd(out, size, d.spread[i]);
             }
             return null;
         };
@@ -579,9 +592,13 @@ function reachOf(m, asset, id, ends) {
             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))) };
+            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];
@@ -595,8 +612,13 @@ function reachOf(m, asset, id, ends) {
                 }
                 turnTo(seat.args.slice(3, 6));
             }
-            const motion = nodeById(m, `${part}.motion`);
-            if (motion) {
+            /* Its axes in order, each about the point it passes: there, turned or slid, and back (ADR-0159). */
+            for (const { motion, through, back } of motionStagesOf(m, part)) {
+                if (through) {
+                    const bad = step(through.args.slice(0, 3), `the point ${part} turns about`);
+                    if (bad)
+                        return bad;
+                }
                 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`;
@@ -607,17 +629,44 @@ function reachOf(m, asset, id, ends) {
                     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)
+                    /*
+                      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);
+                    /* Every corner of the controls it reads: a sum of leaders pulling apart goes furthest with them at either end. */
+                    const states = [...statesReaching(m, motion.args[3])].sort();
+                    if (states.length > CORNER_CONTROLS)
+                        return `${part}'s slide reads ${states.length} controls; how far it reaches is read over at most ${CORNER_CONTROLS}`;
+                    const corners = states.length <= 1 ? ['min', 'max'] : Array.from({ length: 2 ** states.length }, (_, n) => Object.fromEntries(states.map((st, i) => [st, (n >> i) & 1 ? 'max' : 'min'])));
+                    const travels = corners.map(corner => travelAt(m, asset, motion, corner));
+                    if (travels.some(t => !t))
+                        return `${part}'s travel is not a sum of sizes, so how far it reaches cannot be bounded`;
+                    const [lo, hi] = travels.length === 2 ? travels : [null, null];
+                    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 = lo && hi ? (nothing(lo) ? hi : nothing(hi) ? lo : null) : 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 = travels.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, size, along);
+                        out = linAdd(out, further, Math.abs(mid) + spread);
                     }
                 }
                 else
                     return `${part} moves by ${motion.op}, which this command does not add up`;
+                if (back) {
+                    const bad = step(back.args.slice(0, 3), `the point ${part} turns about`);
+                    if (bad)
+                        return bad;
+                }
             }
             const pose = nodeById(m, `${part}.pose`);
             if (!pose)
@@ -629,27 +678,33 @@ function reachOf(m, asset, id, ends) {
         }
         /*
           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`).
+          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.
         */
-        const w = most(d);
         for (const [i, axis] of AXES.entries()) {
-            if (!w[i])
+            const mid = d.mid[i], spread = d.spread[i];
+            if (tiny(mid) && tiny(spread))
                 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 });
+            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 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)
+            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, reach, w[i]);
+            out = linAdd(out, half, Math.min(1, Math.abs(mid) + spread));
         }
         return linNorm(out);
     };
@@ -671,15 +726,18 @@ function reachOf(m, asset, id, ends) {
     /*
       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 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).
+      corner of the controls (`cornersOf`), a reach from each: a slide is a straight line, so the reaches from its ends
+      bound it all the way (it had been refused, and the nose left out of the room).
     */
     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) {
+    const corners = parent ? cornersOf(m, parent) : ['min'];
+    if (!Array.isArray(corners))
+        return tooManyCorners(parent, corners.many);
+    for (const corner of corners) {
         /* 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;
+        const at = parent ? centreVec(m, asset, parent, corner, structuredClone(seatAt)) : seatAt;
         if (typeof at === 'string')
             return at;
         centres.push(at);
@@ -687,11 +745,10 @@ function reachOf(m, asset, id, ends) {
     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: [] };
     /*
@@ -718,7 +775,6 @@ function occupancyLins(asset, over) {
     };
     /* 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. */
@@ -746,7 +802,10 @@ function occupancyLins(asset, over) {
             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 corners = cornersOf(m, parent);
+        if (!Array.isArray(corners))
+            return tooManyCorners(parent, corners.many);
+        const centres = corners.map(corner => centreLin(m, asset, parent, axis, corner));
         const bad = centres.find(c => typeof c === 'string');
         if (bad)
             return String(bad);
@@ -829,7 +888,7 @@ function occupancyLins(asset, over) {
                 onto[axis].push(climbs.reduce((sum, c) => linAdd(sum, c.reach), at));
         };
         if (turns) {
-            const reach = reachOf(m, asset, place.id, ends);
+            const reach = reachOf(m, asset, place.id);
             if (typeof reach === 'string') {
                 skipped.push({ part: place.id, reason: reach });
                 continue;
@@ -865,13 +924,22 @@ function occupancyLins(asset, over) {
             continue;
         }
         /*
-          Both ends of every control are candidates, and which one is the low end is not decided here: a travel of
+          Every corner of the controls is a candidate (`cornersOf`), 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 corners = cornersOf(m, place.id);
+        /* A row's copies are read corner by corner against its part's: too many controls for that is said, not bounded. */
+        if (!Array.isArray(corners) && rows.some(r => r.part !== place.id)) {
+            skipped.push({ part: place.id, reason: tooManyCorners(place.id, corners.many) });
+            continue;
+        }
+        const readings = AXES.map(axis => ({
+            axis,
+            at: Array.isArray(corners) ? corners.map(corner => centreLin(m, asset, place.id, axis, corner)) : wideReadingOf(m, asset, place.id, axis, corners.many)
+        })).map(r => ({ axis: r.axis, at: typeof r.at === 'string' ? [r.at] : r.at }));
         const bad = readings.flatMap(r => r.at).find(v => typeof v === 'string');
         if (bad) {
             skipped.push({ part: place.id, reason: String(bad) });
@@ -889,7 +957,8 @@ function occupancyLins(asset, over) {
               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));
+            /* Read corner by corner: a part slid by too many controls for that was said above. */
+            const theirs = corners.map(corner => centreLin(m, asset, template, run.axis, corner));
             const bad = theirs.find(c => typeof c === 'string');
             if (bad) {
                 offRun = String(bad);
@@ -951,39 +1020,34 @@ function occupancyLins(asset, over) {
             }
         }
     }
-    for (const part of parts)
-        if (boundsUnder(m, part).length)
-            bounded.push(part);
-    return { parts, skipped, bounded, low, high, reaches };
+    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, reaches } = occupancyLins(source, over);
+    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 --
@@ -1007,86 +1071,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, 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;
-        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);
@@ -1099,16 +1086,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