@hatiolab/figure-model 0.5.0 → 0.5.2

package/dist/authoring-occupancy.js

@@ -0,0 +1,784 @@
+/*
+ * Copyright © HatioLab Inc. All rights reserved.
+ */
+/*
+ * The room the figure takes up: proposed from its parts, declared, and the face it is mounted by.
+ */
+import { upgradeFigurePlacement } from "./asset.js";
+import { compileFigureGraph } from "./graph.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, planeFacesOf, 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). */
+    const text = JSON.stringify({
+        ...asset,
+        placement: undefined,
+        occupancy: asset.occupancy ? { ...asset.occupancy, bounds: null } : undefined
+    });
+    let h1 = 0x811c9dc5;
+    let h2 = 0x01000193;
+    for (let i = 0; i < text.length; i++) {
+        h1 = Math.imul(h1 ^ text.charCodeAt(i), 0x01000193) >>> 0;
+        h2 = Math.imul(h2 + text.charCodeAt(i), 0x85ebca6b) >>> 0;
+    }
+    return `${h1.toString(16).padStart(8, '0')}${h2.toString(16).padStart(8, '0')}:${text.length}`;
+}
+const linAdd = (a, b, k = 1) => ({
+    terms: [...a.terms, ...b.terms.map(t => ({ ref: t.ref, k: t.k * k }))],
+    c: a.c + b.c * k
+});
+/** The same sum with each reference once. */
+const linNorm = (a) => {
+    const by = new Map();
+    for (const t of a.terms)
+        by.set(t.ref, (by.get(t.ref) ?? 0) + t.k);
+    return { terms: [...by].filter(([, k]) => k !== 0).map(([ref, k]) => ({ ref, k })), c: a.c };
+};
+/** A sum at least as large as either, where every reference is a size (never below zero): term by term, the larger. */
+const linAtLeast = (a, b) => {
+    const by = new Map();
+    for (const t of [...linNorm(a).terms, ...linNorm(b).terms])
+        by.set(t.ref, Math.max(by.get(t.ref) ?? 0, t.k));
+    return { terms: [...by].map(([ref, k]) => ({ ref, k })), c: Math.max(a.c, b.c) };
+};
+const linOf = (m, ref) => {
+    const constant = m.constants.find((c) => c.id === ref);
+    return constant ? { terms: [], c: constant.value } : { terms: [{ ref, k: 1 }], c: 0 };
+};
+/**
+ * The same sum read back through the sums and scalings that make it up, down to what no command rewrites: the inputs,
+ * and values that are not a sum (a row's count). A declared room that read a node a joint writes -- where a leg stands,
+ * a share of the figure's depth -- was broken by the next fastening, which writes that joint's nodes afresh: the gantry
+ * could not be re-fastened once its room was declared (UNKNOWN_REFERENCE, 2026-09-25).
+ */
+function linThroughSums(m, lin) {
+    const constant = (ref) => m.constants.find((c) => c.id === ref)?.value;
+    const ratio = (ref) => m.constants.find((c) => c.id === ref && c.unit === 'ratio')?.value;
+    const expand = (ref, k, depth) => {
+        const c = constant(ref);
+        if (c !== undefined)
+            return { terms: [], c: c * k };
+        const w = depth < 256 ? writerOf(m, ref) : undefined;
+        if (w?.op === 'add@1')
+            return w.args.reduce((sum, arg) => linAdd(sum, expand(arg, k, depth + 1)), { terms: [], c: 0 });
+        /* Only a length times a ratio: what is left is then a length, as each term of the room must be. */
+        if (w?.op === 'mul@1') {
+            const [a, b] = w.args;
+            if (ratio(b) !== undefined)
+                return expand(a, k * ratio(b), depth + 1);
+            if (ratio(a) !== undefined)
+                return expand(b, k * ratio(a), depth + 1);
+        }
+        return { terms: [{ ref, k }], c: 0 };
+    };
+    return linNorm(lin.terms.reduce((sum, t) => linAdd(sum, expand(t.ref, t.k, 0)), { terms: [], c: lin.c }));
+}
+/**
+ * How far a slide has gone when its control is at one end of its range, as a sum: each control at that end, what the
+ * figure's sizes make of the rest. A mimic of a leader whose stroke follows a length is the leader's ratio times that
+ * length times its multiplier -- read through, not refused: the telescopic conveyor's second and third stages were
+ * left out of its declared room, 2600 and 5200 mm past it (2026-09-25).
+ */
+function travelAt(m, asset, motion, bound) {
+    const pick = (i) => bound === 'start' ? (asset.stateDefaults[i.id] ?? i.min) : bound === 'min' ? i.min : i.max;
+    const constant = (r) => m.constants.find((c) => c.id === r)?.value;
+    const stateOf = (r) => m.inputs.find((i) => i.id === r && i.role === 'state');
+    /* A value no control reaches: it is the same at either end, so it stays a term of the sum. */
+    const still = (ref, depth = 0) => {
+        if (stateOf(ref))
+            return false;
+        const w = depth < 256 ? writerOf(m, ref) : undefined;
+        return !w || w.args.every((a) => typeof a !== 'string' || still(a, depth + 1));
+    };
+    const read = (ref, depth = 0) => {
+        const c = constant(ref);
+        if (c !== undefined)
+            return { terms: [], c };
+        const state = stateOf(ref);
+        if (state)
+            return { terms: [], c: pick(state) };
+        const w = depth < 256 ? writerOf(m, ref) : undefined;
+        if (w?.op === 'add@1') {
+            let out = { terms: [], c: 0 };
+            for (const arg of w.args) {
+                const l = read(arg, depth + 1);
+                if (!l)
+                    return null;
+                out = linAdd(out, l);
+            }
+            return out;
+        }
+        if (w?.op === 'mul@1' && w.args.length === 2) {
+            /* A ratio times a length (the one ratio's size, u × x₀) is kept whole: the sum's terms stay lengths. */
+            const known = (arg) => m.constants.find((c) => c.id === arg);
+            if (!w.args.every(known) &&
+                w.args.some(arg => known(arg) && known(arg).unit !== 'ratio'))
+                return still(ref) ? { terms: [{ ref, k: 1 }], c: 0 } : null;
+            const [a, b] = w.args.map(arg => read(arg, depth + 1));
+            if (!a || !b)
+                return null;
+            // One side a number: a product of two sizes is not a length.
+            if (!a.terms.length)
+                return linAdd({ terms: [], c: 0 }, b, a.c);
+            if (!b.terms.length)
+                return linAdd({ terms: [], c: 0 }, a, b.c);
+            return null;
+        }
+        return still(ref) ? { terms: [{ ref, k: 1 }], c: 0 } : null;
+    };
+    return read(motion.args[3]);
+}
+const zeroVec = () => ({ x: { terms: [], c: 0 }, y: { terms: [], c: 0 }, z: { terms: [], c: 0 } });
+/** A vector of sums turned by a quarter turn (a signed axis permutation). */
+const turnVec = (r, v) => Object.fromEntries(AXES.map((a, i) => [
+    a,
+    AXES.reduce((sum, b, j) => (r[i][j] ? linAdd(sum, v[b], r[i][j]) : sum), { terms: [], c: 0 })
+]));
+const isQuarter = (t) => t !== null && Number.isFinite(t) && Math.abs(t / 90 - Math.round(t / 90)) < 1e-9;
+/** A part's own turn: none, a quarter turn, or one this command cannot add up (any other angle, or not a number). */
+function poseTurnOf(m, asset, part) {
+    const pose = nodeById(m, `${part}.pose`);
+    const turn = (pose?.args.slice(3, 6) ?? []).map((ref) => angleOf(m, asset, ref));
+    if (turn.every((t) => t === 0))
+        return null;
+    return turn.every(isQuarter) ? turnMatrix(turn) : 'other';
+}
+/** Whether a part, or anything carrying it, turns on a joint or stands turned by other than quarter turns. */
+function carriedByATurn(m, asset, id) {
+    for (let part = id; part; part = parentOf(m, part)) {
+        if (nodeById(m, `${part}.motion`)?.op === 'axis-turn@1')
+            return true;
+        if (poseTurnOf(m, asset, part) === 'other')
+            return true;
+    }
+    return false;
+}
+/** How a part's own axes lie in the figure's: the quarter turns of it and everything carrying it, composed. */
+function worldTurnOf(m, asset, id) {
+    let c = IDENTITY;
+    for (let part = id; part; part = parentOf(m, part)) {
+        const r = poseTurnOf(m, asset, part);
+        if (r === 'other')
+            return null;
+        if (r)
+            c = mul3(r, c);
+    }
+    return c;
+}
+/**
+ * Where a point of a part lies in the figure, as sums, following whatever it is fastened to: its centre, or `from` in
+ * its own frame. A part standing a quarter turned turns what it carries -- a valve body on a lying pipe, a hub on its
+ * post -- and was refused, those figures left without a room (2026-09-25); another angle still is.
+ */
+function centreVec(m, asset, id, bound, from) {
+    let v = from ?? zeroVec();
+    for (let part = id; part; part = parentOf(m, part)) {
+        const pose = nodeById(m, `${part}.pose`);
+        if (!pose)
+            return `${part} has no pose this command can read`;
+        /* A part's own turn turns it about its centre: its centre does not move by it. */
+        if (part !== id || from) {
+            const r = poseTurnOf(m, asset, part);
+            if (r === 'other')
+                return `${part} is turned by other than quarter turns, so what it carries is not a box this command can add up`;
+            if (r)
+                v = turnVec(r, v);
+        }
+        for (const [i, a] of AXES.entries())
+            v[a] = linAdd(v[a], linOf(m, pose.args[i]));
+        const motion = nodeById(m, `${part}.motion`);
+        if (motion) {
+            if (motion.op !== 'axis-slide@1')
+                return `${part} turns, so its reach is not a box this command can add up`;
+            const unit = motion.args
+                .slice(0, 3)
+                .map((ref) => m.constants.find((k) => k.id === ref)?.value ?? null);
+            if (unit.some((u) => u === null))
+                return `${part}'s slide axis is not a constant`;
+            if (unit.some((u) => u !== 0)) {
+                const travel = travelAt(m, asset, motion, bound);
+                if (!travel)
+                    return `${part}'s travel is not a distance this command can read`;
+                for (const [i, a] of AXES.entries())
+                    if (unit[i])
+                        v[a] = linAdd(v[a], travel, unit[i]);
+            }
+        }
+        const seat = nodeById(m, `${part}.seat.rigid`);
+        if (seat) {
+            if (seat.args.slice(3, 6).some((ref) => angleOf(m, asset, ref) !== 0))
+                return `${part} is seated turned, which this command does not add up`;
+            for (const [i, a] of AXES.entries())
+                v[a] = linAdd(v[a], linOf(m, seat.args[i]));
+        }
+    }
+    return v;
+}
+/** Where a part's centre is on one axis, as a sum, following whatever it is fastened to. */
+function centreLin(m, asset, id, axis, bound) {
+    const v = centreVec(m, asset, id, bound);
+    return typeof v === 'string' ? v : v[axis];
+}
+/** A value written as a sum of design inputs times constants, or null where it is anything else. */
+function affineOf(m, ref, seen = 0) {
+    if (seen > 64)
+        return null;
+    const constant = m.constants.find((c) => c.id === ref);
+    if (constant)
+        return { terms: [], c: constant.value };
+    if (m.inputs.some((i) => i.id === ref))
+        return { terms: [{ ref, k: 1 }], c: 0 };
+    const writer = writerOf(m, ref);
+    if (writer?.op === 'add@1') {
+        let out = { terms: [], c: 0 };
+        for (const arg of writer.args) {
+            const part = affineOf(m, arg, seen + 1);
+            if (!part)
+                return null;
+            out = linAdd(out, part);
+        }
+        return out;
+    }
+    if (writer?.op === 'mul@1' && writer.args.length === 2) {
+        /* A ratio times a length is kept whole: its terms must stay lengths (the one ratio's size, u × x₀). */
+        const constant = (arg) => m.constants.find((c) => c.id === arg);
+        const ratioTimesLength = !writer.args.every(constant) && writer.args.some((arg) => constant(arg) && constant(arg).unit !== 'ratio');
+        if (ratioTimesLength)
+            return sizeValue(m, ref) ? { terms: [{ ref, k: 1 }], c: 0 } : null;
+        const [a, b] = writer.args.map((arg) => affineOf(m, arg, seen + 1));
+        if (!a || !b)
+            return null;
+        if (!a.terms.length)
+            return linAdd({ terms: [], c: 0 }, b, a.c);
+        if (!b.terms.length)
+            return linAdd({ terms: [], c: 0 }, a, b.c);
+    }
+    /* Not a sum, but a size all the same: the one ratio a figure grows by, read as it is. */
+    if (sizeValue(m, ref))
+        return { terms: [{ ref, k: 1 }], c: 0 };
+    return null;
+}
+/**
+ * A value never below zero that is not a sum of inputs: the mean of sizes, or it over a positive number -- the ratio
+ * a figure that grows by one ratio grows by (`scaleUniformly`). A turntable made to follow it had its platter and
+ * clamps left out of the room, their reach no longer a sum of inputs (2026-09-25).
+ */
+function sizeValue(m, ref, seen = 0) {
+    if (seen > 64)
+        return false;
+    const input = m.inputs.find((i) => i.id === ref);
+    if (input)
+        return input.role !== 'state' && input.min >= 0;
+    const w = writerOf(m, ref);
+    const positive = (r) => (m.constants.find((c) => c.id === r)?.value ?? -1) > 0;
+    if (w?.op === 'geomean@1')
+        return w.args.every((a) => sizeValue(m, a, seen + 1));
+    if (w?.op === 'div@1')
+        return sizeValue(m, w.args[0], seen + 1) && positive(w.args[1]);
+    if (w?.op === 'mul@1')
+        return (w.args.length === 2 &&
+            ((sizeValue(m, w.args[0], seen + 1) && positive(w.args[1])) ||
+                (positive(w.args[0]) && sizeValue(m, w.args[1], seen + 1))));
+    return false;
+}
+/**
+ * How long a value can be, at most, as a sum that holds at every design size: each input's coefficient taken
+ * positive. Sound only over inputs that are never below zero (sizes), so any other input makes it unreadable.
+ */
+function magnitudeOf(m, lin) {
+    let out = { terms: [], c: 0 };
+    for (const t of lin.terms) {
+        const a = affineOf(m, t.ref);
+        if (!a)
+            return null;
+        for (const u of a.terms) {
+            if (!sizeValue(m, u.ref))
+                return null;
+            out = linAdd(out, { terms: [{ ref: u.ref, k: Math.abs(u.k * t.k) }], c: 0 });
+        }
+        out.c += Math.abs(a.c * t.k);
+    }
+    out.c += Math.abs(lin.c);
+    return out;
+}
+/**
+ * Where a part carried by a turn can reach: a ball about the point the first turn above it turns about, as wide as
+ * every step from there to the part laid end to end, plus the part's own half size on each axis (the triangle
+ * inequality -- it holds at every angle and every design size, so it is a bound, not a sample). As a box, that
+ * ball is the pivot plus and minus its radius on each axis. Read by the proposal; the release gate still checks
+ * the parts against it.
+ */
+function reachOf(m, asset, id, ends, freezeless = true) {
+    const chain = [];
+    for (let part = id; part; part = parentOf(m, part))
+        chain.push(part);
+    /* The topmost part that turns on a joint, or stands turned by an angle a box cannot follow (a fan's blade at 120°). */
+    const top = chain.reduce((found, part, i) => nodeById(m, `${part}.motion`)?.op === 'axis-turn@1' || poseTurnOf(m, asset, part) === 'other' ? i : found, -1);
+    if (top < 0)
+        return `${id} is carried by no turn`;
+    let radius = { terms: [], c: 0 };
+    const grow = (lin, what) => {
+        const size = lin && magnitudeOf(m, lin);
+        if (!size)
+            return `${what} is not a sum of sizes, so how far it reaches cannot be bounded`;
+        radius = linAdd(radius, size);
+        return null;
+    };
+    /* Its half size on every axis of its own, whichever way it stands: the ball holds it at any angle. */
+    const sizes = sizeRefsOf(m, id, id);
+    void freezeless;
+    for (const axis of AXES) {
+        const bad = grow({ terms: [{ ref: sizes[axis].ref, k: 0.5 * sizes[axis].k }], c: 0 }, `${id}'s size`);
+        if (bad)
+            return bad;
+    }
+    for (let i = 0; i <= top; i++) {
+        const part = chain[i];
+        const pose = nodeById(m, `${part}.pose`);
+        if (!pose)
+            return `${part} has no pose this command can read`;
+        for (const ref of pose.args.slice(0, 3)) {
+            const bad = grow(linOf(m, ref), `${part}'s place`);
+            if (bad)
+                return bad;
+        }
+        if (i < top) {
+            const seat = nodeById(m, `${part}.seat.rigid`);
+            for (const ref of seat?.args.slice(0, 3) ?? []) {
+                const bad = grow(linOf(m, ref), `where ${part} is fastened`);
+                if (bad)
+                    return bad;
+            }
+            const motion = nodeById(m, `${part}.motion`);
+            if (motion?.op === 'axis-slide@1')
+                for (const end of ['min', 'max']) {
+                    const bad = grow(travelAt(m, asset, motion, end), `${part}'s travel`);
+                    if (bad)
+                        return bad;
+                }
+        }
+    }
+    /*
+      The pivot: where the topmost turn is fastened, and everything above it. Above it nothing turns, but a slide may
+      carry it -- the telescopic conveyor's nose turns at the end of its third stage -- so the pivot is read at each
+      end of the controls, a ball at each: a slide is a straight line, so the balls at its two ends bound it all the
+      way (it had been refused, and the nose left out of the room).
+    */
+    const pivotPart = chain[top];
+    const parent = parentOf(m, pivotPart);
+    const seat = nodeById(m, `${pivotPart}.seat.rigid`);
+    const seatAt = Object.fromEntries(AXES.map((a, i) => [a, seat ? linOf(m, seat.args[i]) : { terms: [], c: 0 }]));
+    const centres = [];
+    for (const end of ends) {
+        /* The point it turns about, in the frame of what carries it, carried there -- turned with it if that stands turned. */
+        const at = parent ? centreVec(m, asset, parent, end, structuredClone(seatAt)) : seatAt;
+        if (typeof at === 'string')
+            return at;
+        centres.push(at);
+    }
+    return { centres, radius };
+}
+/** The bounds the parts come to, as sums, with what could not be read named. */
+function occupancyLins(asset, over) {
+    const m = asset.document.model;
+    const parts = [];
+    const skipped = [];
+    const low = { x: [], y: [], z: [] };
+    const high = { x: [], y: [], z: [] };
+    /* Parts carried by the same turn share one ball: its radius the larger of theirs, term by term. */
+    const balls = new Map();
+    /* A row's template stands for its copies (`repeatPart`): leaving it out left a conveyor's rollers out of its room. */
+    const rowOf = (id) => nodeById(m, `${id}.repeat`);
+    const ends = over === 'rest' ? ['start'] : ['min', 'max'];
+    /* A part's size along the figure's axes, whichever quarter turns it and what carries it stand in. */
+    const sizesOf = (id, turns) => {
+        /* A turned chain's reach is read from one size per axis (reachOf), so a part there must have one. */
+        const own = occupiedExtentsOf(m, id, id, turns);
+        const c = turns ? IDENTITY : worldTurnOf(m, asset, id);
+        if (!c)
+            throw new FigureContractError('EDIT_TARGET', id, `${id} is turned by other than quarter turns`);
+        return Object.fromEntries(AXES.map((axis, i) => {
+            const j = c[i].findIndex(v => v !== 0);
+            const e = own[AXES[j]];
+            /* A size is the same either way round; a reach turned half about flips: its offsets change sign. */
+            return [axis, isReach(e) && c[i][j] < 0 ? { offsets: e.offsets.map(o => ({ ...o, k: -o.k })) } : e];
+        }));
+    };
+    /*
+      A row runs from its parent's one edge to the other along its axis, every copy inside (fit-pitch and fixed-count lay
+      them out within that length). What it spans there, how long its part is along it, and how far a rising row climbs.
+    */
+    const runOf = (part) => {
+        const row = rowOf(part);
+        const axis = String(row.params?.axis ?? '').toLowerCase();
+        const parent = parentOf(m, part);
+        const straight = parent && worldTurnOf(m, asset, parent);
+        if (!parent || !AXES.includes(axis) || !straight || AXES.some((_, i) => straight[i][i] !== 1))
+            return `${part} is a row whose run this command cannot read`;
+        const theirs = standingRefsOf(m, asset, parent, parent, false)[axis];
+        const half = { terms: [{ ref: theirs.ref, k: 0.5 * theirs.k }], c: 0 };
+        const centres = ends.map(end => centreLin(m, asset, parent, axis, end));
+        const bad = centres.find(c => typeof c === 'string');
+        if (bad)
+            return String(bad);
+        const along = sizesOf(part, false)[axis];
+        if (isReach(along))
+            return `${part} is a row of a drawn section along its section; how far each copy reaches is not added up`;
+        const mine = along[0];
+        const extent = { terms: [{ ref: mine.ref, k: mine.k }], c: 0 };
+        const record = (asset.joints ?? []).find(o => o.body1.part === part && o.repeat)?.repeat;
+        let climb;
+        if (record?.rise) {
+            /*
+              The last copy is (count − 1) rises past the first. A row that fills its length has at most
+              (length − one copy) / pitch copies past the first, so that many rises bound it and follow the parent's size;
+              a counted row has exactly count − 1.
+            */
+            const per = record.rise.mm;
+            let reach;
+            if (record.count !== undefined)
+                reach = { terms: [], c: (record.count - 1) * per };
+            else if (typeof record.pitch === 'number')
+                reach = {
+                    terms: [
+                        { ref: theirs.ref, k: (theirs.k * per) / record.pitch },
+                        { ref: mine.ref, k: (-mine.k * per) / record.pitch }
+                    ],
+                    c: 0
+                };
+            else
+                return `${part} is a rising row whose pitch follows a length; how far it rises is not added up`;
+            climb = { axis: record.rise.axis.toLowerCase(), up: per > 0, reach };
+        }
+        return {
+            axis,
+            lows: centres.map(c => linAdd(c, half, -1)),
+            highs: centres.map(c => linAdd(c, half, 1)),
+            extent,
+            climb
+        };
+    };
+    /* A part in a row, or fastened to one: each copy carries it (ADR-0093, 2026-09-26). */
+    for (const place of m.nodes.filter((n) => n.op === 'place@1' || (n.op === 'member@1' && (rowOf(n.id) || rowHolding(m, n.id))))) {
+        const turns = carriedByATurn(m, asset, place.id);
+        let sizes = {};
+        try {
+            sizes = sizesOf(place.id, turns);
+        }
+        catch (e) {
+            skipped.push({
+                part: place.id,
+                reason: e instanceof FigureContractError ? e.message : 'not a part whose size this command can read'
+            });
+            continue;
+        }
+        /*
+          The rows around this part, nearest first: its own if it is a row's part, then the row of each part it hangs from
+          (a grid is a row inside a row, each along its own axis).
+        */
+        const rows = [];
+        let unread;
+        for (let up = place.op === 'member@1' ? place.id : null; up; up = parentOf(m, up)) {
+            if (!rowOf(up))
+                continue;
+            const run = runOf(up);
+            if (typeof run === 'string') {
+                unread = run;
+                break;
+            }
+            rows.push({ part: up, run });
+        }
+        if (unread) {
+            skipped.push({ part: place.id, reason: unread });
+            continue;
+        }
+        const rowAxes = new Set(rows.map(r => r.run.axis));
+        /* How far the rows around it climb, along an axis and a way, added up: each copy of each row is further up. */
+        const climbed = (at, side, onto, axis) => {
+            const climbs = rows.map(r => r.run.climb).filter(c => c && c.axis === axis && (c.up ? 1 : -1) === side);
+            if (climbs.length)
+                onto[axis].push(climbs.reduce((sum, c) => linAdd(sum, c.reach), at));
+        };
+        if (turns) {
+            const reach = reachOf(m, asset, place.id, ends);
+            if (typeof reach === 'string') {
+                skipped.push({ part: place.id, reason: reach });
+                continue;
+            }
+            parts.push(place.id);
+            if (rows.length) {
+                /*
+                  Each copy turns about its own pivot, which lies on its rows' runs: along a row the copies reach the run's
+                  ends and the turn's reach past them; across them, the turn's reach about the pivot.
+                */
+                for (const { run } of rows) {
+                    for (const l of run.lows)
+                        low[run.axis].push(linAdd(l, reach.radius, -1));
+                    for (const h of run.highs)
+                        high[run.axis].push(linAdd(h, reach.radius, 1));
+                }
+                for (const at of reach.centres)
+                    for (const axis of AXES.filter(a => !rowAxes.has(a))) {
+                        const lo = linAdd(at[axis], reach.radius, -1);
+                        const hi = linAdd(at[axis], reach.radius, 1);
+                        low[axis].push(lo);
+                        high[axis].push(hi);
+                        climbed(lo, -1, low, axis);
+                        climbed(hi, 1, high, axis);
+                    }
+                continue;
+            }
+            for (const at of reach.centres) {
+                const centre = Object.fromEntries(AXES.map(a => [a, linNorm(at[a])]));
+                const key = JSON.stringify(centre);
+                const ball = balls.get(key);
+                balls.set(key, { centre, radius: ball ? linAtLeast(ball.radius, reach.radius) : linNorm(reach.radius) });
+            }
+            continue;
+        }
+        /*
+          Both ends of every control are candidates, and which one is the low end is not decided here: a travel of
+          −40 mm puts the low end at the control's maximum (designer's counterexample 2026-09-23, where the
+          proposal read −50..10 for a part that needs −90..50). Both candidates go into the same min and the same
+          max, so the answer holds whichever way the travel runs, and holds at every design size, because the
+          choice is made when the graph is evaluated rather than when the proposal is written.
+        */
+        const readings = AXES.map(axis => ({ axis, at: ends.map(end => centreLin(m, asset, place.id, axis, end)) }));
+        const bad = readings.flatMap(r => r.at).find(v => typeof v === 'string');
+        if (bad) {
+            skipped.push({ part: place.id, reason: String(bad) });
+            continue;
+        }
+        let offRun;
+        for (const { part: template, run } of rows) {
+            if (template === place.id) {
+                /* The row's own part: along the row it takes the run. */
+                low[run.axis].push(...run.lows);
+                high[run.axis].push(...run.highs);
+                continue;
+            }
+            /*
+              Carried by a row's part: its copies stand where that part's copies do, offset as it is from it. That part's
+              centres lie half its length in from the run's ends.
+            */
+            const theirs = ends.map(end => centreLin(m, asset, template, run.axis, end));
+            const bad = theirs.find(c => typeof c === 'string');
+            if (bad) {
+                offRun = String(bad);
+                break;
+            }
+            const along = readings.find(r => r.axis === run.axis).at;
+            const inset = linAdd({ terms: [], c: 0 }, run.extent, 0.5);
+            const across = sizes[run.axis];
+            if (isReach(across)) {
+                offRun = `${place.id} is a drawn section carried along a row; how far each copy reaches is not added up`;
+                break;
+            }
+            for (const [i, mine] of along.entries()) {
+                const offset = linAdd(mine, theirs[i], -1);
+                for (const e of across) {
+                    const half = { terms: [{ ref: e.ref, k: 0.5 * e.k }], c: 0 };
+                    for (const l of run.lows)
+                        low[run.axis].push(linAdd(linAdd(linAdd(l, inset), offset), half, -1));
+                    for (const h of run.highs)
+                        high[run.axis].push(linAdd(linAdd(linAdd(h, inset, -1), offset), half));
+                }
+            }
+        }
+        if (offRun) {
+            skipped.push({ part: place.id, reason: offRun });
+            continue;
+        }
+        parts.push(place.id);
+        for (const r of readings) {
+            if (rowAxes.has(r.axis))
+                continue;
+            const extent = sizes[r.axis];
+            const seen = new Set();
+            for (const centre of r.at) {
+                const key = JSON.stringify([centre.terms.map(t => [t.ref, t.k]).sort(), centre.c]);
+                if (seen.has(key))
+                    continue; // a part that does not move gives the same candidate twice
+                seen.add(key);
+                if (isReach(extent)) {
+                    /* Every point is a candidate for both ends: the least is the low end, the greatest the high one. */
+                    for (const o of extent.offsets) {
+                        const at = linAdd(centre, { terms: [{ ref: o.ref, k: o.k }], c: 0 });
+                        low[r.axis].push(at);
+                        high[r.axis].push(at);
+                        climbed(at, -1, low, r.axis);
+                        climbed(at, 1, high, r.axis);
+                    }
+                    continue;
+                }
+                const halves = extent.map(e => ({ terms: [{ ref: e.ref, k: 0.5 * e.k }], c: 0 }));
+                for (const half of halves) {
+                    const lo = linAdd(centre, half, -1);
+                    const hi = linAdd(centre, half, 1);
+                    low[r.axis].push(lo);
+                    high[r.axis].push(hi);
+                    climbed(lo, -1, low, r.axis);
+                    climbed(hi, 1, high, r.axis);
+                }
+            }
+        }
+    }
+    return { parts, skipped, low, high, balls: [...balls.values()] };
+}
+const valueOfLin = (values, l) => l.terms.reduce((s, t) => s + t.k * (values[t.ref] ?? NaN), l.c);
+/** What the parts come to, and what a person is being asked to confirm. Reads the asset; changes nothing. */
+export function proposeFigureOccupancy(asset, options = {}) {
+    asset = upgradeFigurePlacement(asset);
+    const over = options.over ?? 'range';
+    if (over !== 'rest' && over !== 'range')
+        fail('SCHEMA', 'over', `${String(over)} is neither rest nor range`);
+    const source = structuredClone(asset);
+    const { parts, skipped, low, high, balls } = occupancyLins(source, over);
+    for (const ball of balls)
+        for (const axis of AXES) {
+            low[axis].push(linAdd(ball.centre[axis], ball.radius, -1));
+            high[axis].push(linAdd(ball.centre[axis], ball.radius, 1));
+        }
+    if (!parts.length)
+        fail('OCCUPANCY_NO_PARTS', 'occupancy', `no part could be measured${skipped.length ? `: ${skipped.map(s => `${s.part} — ${s.reason}`).join('; ')}` : ''}`);
+    const values = compileFigureGraph(source.document.model).evaluate({ ...source.designInputs, ...source.stateDefaults })
+        .values;
+    const at = Object.fromEntries(AXES.map(axis => [
+        axis,
+        {
+            min: round6(Math.min(...low[axis].map(l => valueOfLin(values, l)))),
+            max: round6(Math.max(...high[axis].map(l => valueOfLin(values, l))))
+        }
+    ]));
+    return { over, at, parts, skipped, basis: fingerprintOf(source) };
+}
+/**
+ * The placement says which plane the mounting plane is. A part already fastened to it by a face the new plane does not
+ * take -- a bottom on the floor, when the figure is to hang on a wall -- is named, not seated again without a word
+ * (chief architect's condition, 2026-09-25): fasten it again by the face the new plane takes.
+ */
+export function setPlacement(asset, a) {
+    if (!FIGURE_PLACEMENTS.includes(a.placement))
+        fail('SCHEMA', 'placement', `${String(a.placement)} is not a placement`);
+    const takes = planeFacesOf(a.placement);
+    const misfit = (asset.joints ?? []).filter(j => 'plane' in j.body0 && !takes.includes(j.body1.face));
+    if (misfit.length)
+        fail('PLACEMENT_PLANE', 'placement', `${misfit.map(j => `${j.body1.part} (${j.body1.face})`).join(', ')} ${misfit.length > 1 ? 'are' : 'is'} fastened to the mounting plane by a face a ${a.placement} does not take (${takes.join(' or ')}); detach ${misfit.length > 1 ? 'them' : 'it'} or fasten ${misfit.length > 1 ? 'them' : 'it'} by ${takes.join(' or ')} first`, {
+            reason: 'placement-face',
+            placement: a.placement,
+            parts: misfit.map(j => ({ part: j.body1.part, face: String(j.body1.face) })),
+            takes: [...takes]
+        });
+    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));
+        }
+    for (const axis of AXES) {
+        if (!padding[axis])
+            continue;
+        low[axis] = low[axis].map((l) => ({ ...l, c: l.c - padding[axis] }));
+        high[axis] = high[axis].map((l) => ({ ...l, c: l.c + padding[axis] }));
+    }
+    if (parts.join('|') !== a.proposal.parts.join('|'))
+        fail('OCCUPANCY_STALE', 'occupancy', `the figure changed since the proposal was made (${a.proposal.parts.join(', ')} then, ${parts.join(', ')} now); propose again and confirm that`);
+    /* One node for the six bounds (affine-bounds@1): each candidate its constant, then a value and a ratio per term. */
+    const args = [];
+    const layout = AXES.flatMap(axis => [low[axis], high[axis]]).map(side => side
+        .map((l) => {
+        const n = linThroughSums(m, l);
+        args.push(constantOf(m, 'mm', round6(n.c), 'd'));
+        for (const t of n.terms)
+            args.push(t.ref, constantOf(m, 'ratio', t.k, 'k'));
+        return n.terms.length;
+    })
+        .join('_'));
+    const id = namer(m, 'occupancy')('bounds');
+    const port = (p) => `${id}.${p}`;
+    m.nodes.push({
+        id,
+        op: 'affine-bounds@1',
+        args,
+        params: { layout: `L${layout.join('.')}` },
+        outputs: Object.fromEntries(['xmin', 'xmax', 'ymin', 'ymax', 'zmin', 'zmax'].map(p => [p, port(p)]))
+    });
+    const bounds = Object.fromEntries(AXES.map(axis => [axis, { min: port(`${axis}min`), max: port(`${axis}max`) }]));
+    const was = stringsIn(asset.occupancy?.bounds);
+    asset.occupancy = { ...(asset.occupancy?.contact ? { contact: asset.occupancy.contact } : {}), bounds };
+    /*
+      The room declared before goes with what fed only it. Left in the graph, it kept reading where parts had been
+      fastened, and the next fastening was refused over a room no one read (the gantry, 2026-09-25).
+    */
+    for (const ref of was)
+        dropIfUnused(asset, ref);
+    /*
+      A part's own measure the old room alone still read -- the part follows something else now -- goes too: kept, it
+      was a dial that changed nothing (the turntable after every part followed the one ratio, 2026-09-25). So does its
+      own position or turn, once a fastening places it: a floor part's height position stayed as a field that moved
+      nothing (browser check, ADR-0097, 2026-09-27). The room's refit names them before it is confirmed (figureRoomRefitOf).
+    */
+    const placed = new Set(m.nodes.filter((n) => n.op === 'place@1' || n.op === 'member@1').map((n) => n.id));
+    for (const input of [...m.inputs])
+        if (input.role === 'design' &&
+            placed.has(String(input.id).split('.')[0]) &&
+            /\.(dimension|size|position|rotation)\.[a-z]+$/.test(input.id))
+            dropIfUnused(asset, input.id, input.id);
+    return asset;
+}
+/** "This face is what the figure is mounted on." Kept apart from how much room the figure takes up. */
+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);
+    const id = `${a.part}.mount.${a.face}`;
+    if (!nodeById(m, id))
+        m.nodes.push({
+            id,
+            op: 'feature@1',
+            args: [place.args[0]],
+            outputs: { pose: `${id}.value` },
+            params: { frame: `${id}.frame`, name: a.face }
+        });
+    asset.occupancy.contact = {
+        plane: 'mounting-plane',
+        surface: { placement: place.outputs.placed, feature: `${id}.value` }
+    };
+    return asset;
+}
+export function clearMountingFace(asset) {
+    if (!asset.occupancy?.contact)
+        fail('EDIT_TARGET', 'occupancy', 'this figure names no mounting face');
+    delete asset.occupancy.contact;
+    return asset;
+}
+//# sourceMappingURL=authoring-occupancy.js.map