@reekon-tools/boldr-cad 0.1.0 → 1.0.0

package/dist/tools/dim.js

@@ -1,30 +1,47 @@
-import { afterEdit, tryAddConstraint } from '../app/edit';
+import { afterEdit, holdGroups, tryAddConstraint } from '../app/edit';
 import { ed } from '../app/state';
 import { measure } from '../model/constraints';
 import { hyp, norm2, pointInPoly, projT } from '../model/geom';
 import { dropHistory, pushHistory } from '../model/history';
-import { addCons, lengthDimOf, lineLen, restorePos, roomValid, snapshotPos } from '../model/sketch';
+import { addCons, lengthDimOf, lineLen, roomValid } from '../model/sketch';
 import { SK } from '../model/store';
+import { askLinkedChange, changesValue } from '../editor/linkWrite';
+import { offersJobMeasurements } from '../editor/links';
+import { fromUm, linkInfoOf, linkSnapshot } from '../model/links';
+import { defaultFace, dimEnds, edgeId, edgeLabel, edgeOf, faceName, sideOf, spaceBeside, wallOf } from '../model/planGeom';
+import { faceLength } from '../model/wallfaces';
+import { fitState, overflow, pastWallMsg, restoreFit } from '../editor/elevation';
+import { pushedOut } from '../model/facesolve';
 import { hitAny } from '../render/hit';
 import { chooseEdges, edgePoint, nearerEdge, openingOnLineAt } from '../model/openings';
 import { drawPendingDim, drawRubberBand } from '../render/draw';
-import { mainT, requestDraw, s2w, V } from '../render/view';
+import { mainT, requestDraw, requestOverlayDraw, s2w, V } from '../render/view';
 import { solver } from '../solver';
 import { fmtAng, fmtLen } from '../units';
 import { addOpeningDim } from './openings';
+import { keypadFresh, keypadOpen, keypadSetReading } from '../editor/keypad';
+import { cornerLines } from '../editor/selection';
 import { closeKeypad, kpTyped, openKeypad, showConflict, toast, updateCtx, updateHint } from '../editor/ports';
 export const dimTool = {
-    st: { first: null },
-    reset() { this.st = { first: null }; ed.hover = null; ed.pickedAnchor = null; },
+    /** angle: the first pick is a corner whose angle keypad is open (the next tap closes it) */
+    st: { first: null, angle: false },
+    reset() { if (this.st.angle && keypadOpen())
+        closeKeypad(); this.st = { first: null, angle: false }; ed.hover = null; ed.pickedAnchor = null; },
     busy() { return !!this.st.first || !!ed.pickedAnchor; },
     hover(ev) {
+        const was = ed.hover;
         ed.hover = pickForDim(ev);
         if (ed.hover && ed.hover.type === 'room')
             ed.hover = null;
         // after the first pick: a rubber band from it to what's under the pointer
         const band = this.band(ev);
         ed.preview = band ? (c, T) => drawRubberBand(c, T, band.from, band.to, band.snapped) : null;
-        requestDraw();
+        // what's under the pointer is highlighted in the drawing itself; otherwise only the band moved
+        const same = was?.type === ed.hover?.type && was?.id === ed.hover?.id && was?.part === ed.hover?.part;
+        if (same)
+            requestOverlayDraw();
+        else
+            requestDraw();
     },
     /** Ends of the rubber band: the first pick (an opening body resolves to the edge facing the target) and the target. */
     band(ev) {
@@ -69,6 +86,12 @@ export const dimTool = {
     up(ev) {
         const h = pickForDim(ev);
         const print = ed.dimLayer === 'print', st = this.st;
+        // a corner's angle keypad is open: the next tap closes it and goes on (a second point measures from the corner)
+        if (st.angle) {
+            st.angle = false;
+            if (keypadOpen())
+                closeKeypad();
+        }
         if (!h || h.type === 'room') {
             st.first = null;
             ed.pickedAnchor = null;
@@ -83,7 +106,7 @@ export const dimTool = {
         if (h.type === 'oanchor') {
             const edge = h.part;
             if (print) {
-                toast('Print dimensions can’t attach to doors or windows yet. Switch to Driving in the bar below.');
+                toast('Print dimensions can’t attach to doors or windows yet. Switch to Driving in the bar below.', { warn: true });
                 return;
             }
             if (st.first) {
@@ -120,13 +143,16 @@ export const dimTool = {
                 updateHint();
                 return;
             }
-            toast('Tap a corner, a point, or another door or window edge to measure to.');
+            toast('Tap a corner, a point, or another door or window edge to measure to.', { warn: true });
             return;
         }
         if (h.type === 'point') {
             if (!st.first) {
                 st.first = h.id;
                 ed.sel = [{ type: 'point', id: h.id }];
+                // a corner: its angle straight away (close the keypad to measure from the corner to another point instead)
+                if (!print)
+                    st.angle = cornerAngle(h.id, () => { this.st.first = null; this.st.angle = false; ed.sel = []; updateHint(); requestDraw(); }, true);
                 updateHint();
                 requestDraw();
                 return;
@@ -137,7 +163,30 @@ export const dimTool = {
             updateHint();
             return;
         }
+        // a wall's edge: its length on that face — or, after a point, the distance from the face to it; a curved wall's,
+        // its diameter across that face
+        if (h.type === 'wface') {
+            const [lid, side] = edgeOf(h.id);
+            if (!SK().lines[lid]) {
+                dimCurve(lid, side);
+                return;
+            }
+            if (st.first) {
+                const p = st.first;
+                st.first = null;
+                if (print)
+                    dimPointLine(p, lid);
+                else
+                    dimEdgePoint(lid, side, p);
+                updateHint();
+                return;
+            }
+            dimLine(lid, print, side);
+            return;
+        }
         if (h.type === 'line') {
+            if (h.side)
+                ed.wallTap = { id: h.id, side: h.side };
             if (st.first) {
                 dimPointLine(st.first, h.id);
                 st.first = null;
@@ -147,8 +196,11 @@ export const dimTool = {
             dimLine(h.id, print);
             return;
         }
-        if (h.type === 'circle' || h.type === 'arc')
+        if (h.type === 'circle' || h.type === 'arc') {
+            if (h.side)
+                ed.wallTap = { id: h.id, side: h.side };
             dimCurve(h.id);
+        }
     },
     hint() {
         if (ed.pickedAnchor)
@@ -163,13 +215,17 @@ export const dimTool = {
  * counts as its nearer edge, so openings are as easy to dimension as points.
  */
 function pickForDim(ev) {
-    const h = hitAny(ev.sx, ev.sy, { touch: ev.touch, only: 'geom' });
-    if (!h || h.type !== 'line')
+    const h = hitAny(ev.sx, ev.sy, { touch: ev.touch, only: 'geom', faces: true });
+    if (!h || (h.type !== 'line' && h.type !== 'wface'))
         return h;
-    const sk = SK(), l = sk.lines[h.id], A = sk.points[l.a], B = sk.points[l.b];
+    const lid = h.type === 'wface' ? edgeOf(h.id)[0] : h.id;
+    const sk = SK(), l = sk.lines[lid];
+    if (!l)
+        return h; // (a curved wall's edge)
+    const A = sk.points[l.a], B = sk.points[l.b];
     const [wx, wy] = s2w(ev.sx, ev.sy);
     const s = projT(A, B, { x: wx, y: wy }) * hyp(B.x - A.x, B.y - A.y);
-    const a = openingOnLineAt(sk, h.id, s, 2 / mainT().s);
+    const a = openingOnLineAt(sk, lid, s, 2 / mainT().s);
     // weak = the body was tapped: the edge gets chosen to face whatever it's measured to
     return a ? { type: 'oanchor', id: a.id, part: a.edge, weak: true } : h;
 }
@@ -185,38 +241,272 @@ function sideAwayFromRooms(lid) {
     }
     return 1;
 }
-/** Tap on a line (or its + chip): open the keypad for its length, or edit the existing length. */
-export function dimLine(lid, print) {
+/**
+ * Tap on a line (or its + chip): open the keypad for its length, or edit the existing length. A wall's is measured on
+ * `side`, the edge picked — or, picked whole, on the side a space is on (the side it was tapped on, between two), and
+ * along its centerline where there's no space; the keypad can switch it.
+ */
+export function dimLine(lid, print, side) {
     const sk = SK(), l = sk.lines[lid];
     if (!l)
         return;
+    const wall = faced(sk, lid);
     if (print) {
         pushHistory();
-        const off = (36 / V().s) * sideAwayFromRooms(lid);
-        addCons(sk, { type: 'dist', a: l.a, b: l.b, kind: 'al', value: lineLen(sk, l), line: lid, driving: false, layer: 'print', off });
+        // (on a wall's edge: that face's length, labelled on that side)
+        const f = wall ? side : undefined;
+        const off = (36 / V().s) * (f ?? sideAwayFromRooms(lid));
+        addCons(sk, { type: 'dist', a: l.a, b: l.b, kind: 'al', value: f ? faceLength(sk, lid, f) : lineLen(sk, l), line: lid, driving: false, layer: 'print', off, ...(f ? { face: f } : {}) });
         afterEdit();
         toast('Print dimension added. Drag it to move it.');
         return;
     }
     const ex = lengthDimOf(sk, lid);
     if (ex) {
-        editDim(ex);
+        editDim(ex, undefined, false, wall && side ? { face: side } : undefined);
         return;
     }
-    ed.sel = [{ type: 'line', id: lid }];
-    requestDraw();
-    openKeypad({
-        title: 'Length', sub: l.kind === 'wall' ? 'Wall centerline' : '', initial: fmtLen(lineLen(sk, l)), selectAll: true, laser: true,
-        onDone: v => {
-            if (v <= 0)
-                return;
-            pushHistory();
-            const r = tryAddConstraint({ type: 'dist', a: l.a, b: l.b, kind: 'al', value: v, line: lid, driving: true, off: 0 });
-            if (!r.ok)
-                dropHistory();
-            afterEdit();
-        },
-    });
+    let face = wall ? side ?? defaultFace(sk, lid, ed.wallTap?.id === lid ? ed.wallTap.side : undefined) ?? 0 : 0;
+    const len = () => (face ? faceLength(sk, lid, face) : lineLen(sk, l));
+    // (while it's being entered, what it measures is what's highlighted: the edge, or the wall)
+    const was = ed.sel;
+    const show = () => { ed.sel = face ? [{ type: 'wface', id: edgeId(lid, face) }] : [{ type: 'line', id: lid }]; requestDraw(); };
+    show();
+    const spec = {
+        title: 'Length', sub: wall ? lengthSub(sk, lid, face) : '', initial: fmtLen(len()), selectAll: true, laser: true,
+        extras: wall ? () => lengthChoices(sk, lid).map(ch => ({
+            label: ch.label, on: ch.face === face,
+            onPress: () => { face = ch.face; spec.sub = lengthSub(sk, lid, face); show(); if (keypadFresh())
+                keypadSetReading(len()); },
+        })) : undefined,
+        onClose: () => { ed.sel = was; updateCtx(); requestDraw(); },
+        onDone: (v, capture) => { if (v > 0)
+            addLength(v, capture !== undefined ? { capture } : {}); },
+        // (or a length of the job's, from its list: the line takes it, linked to it)
+        measurements: offersJobMeasurements() ? {
+            kind: 'length', pick: t => {
+                const v = jobValue(t, 'length');
+                if (v == null)
+                    return;
+                closeKeypad();
+                addLength(v, { measurementRef: linkSnapshot(t) });
+            },
+        } : undefined,
+    };
+    /** The line's length dimension, driving, measured where the keypad says (`extra`: what it's from). */
+    function addLength(v, extra) {
+        pushHistory();
+        const r = tryAddConstraint({ type: 'dist', a: l.a, b: l.b, kind: 'al', value: v, line: lid, driving: true, off: face ? (face * 30) / V().s : 0, ...(face ? { face } : {}), ...extra });
+        // a measurement of the job drives a line, or nothing: not one whose length the drawing already sets
+        if (r.ok && r.ref && extra.measurementRef) {
+            delete SK().cons[r.id];
+            dropHistory();
+            toast(LENGTH_SET_ALREADY, { warn: true });
+        }
+        else if (!r.ok)
+            dropHistory();
+        afterEdit();
+    }
+    openKeypad(spec);
+}
+/** Why a measurement of the job can't drive a line the drawing already sets the length of. */
+export const LENGTH_SET_ALREADY = 'The drawing already sets that line’s length. Free it first (make one of its dimensions a reference), then pick the measurement.';
+/** Why a measurement of the job can't drive an angle the drawing already sets. */
+export const ANGLE_SET_ALREADY = 'The drawing already sets that angle. Free it first (make one of its dimensions a reference), then pick the measurement.';
+/**
+ * A measurement of the job's as a keypad of `kind` takes it — inches for a length, degrees for an angle (what the host
+ * says it is now, or what it was when listed); null, said why, if it has none, or isn't of that kind.
+ */
+function jobValue(t, kind) {
+    if ((t.mkind ?? 'length') !== kind) {
+        toast(kind === 'angle' ? 'That’s a length. Pick an angle, or type one in.' : 'That’s an angle. Pick a length, or type one in.', { warn: true });
+        return null;
+    }
+    const v = linkInfoOf(t)?.value ?? t.value;
+    if (v == null || !(v > 0)) {
+        toast(kind === 'angle' ? 'That measurement has no angle to use. Pick another, or type one in.' : 'That measurement has no length to use. Pick another, or type one in.', { warn: true });
+        return null;
+    }
+    return kind === 'angle' ? v : fromUm(v);
+}
+/* Measuring off a wall's faces (its edges) rather than its centerline. */
+/** A straight wall, whose length can be measured on either face (not a guide). */
+function faced(sk, lid) {
+    const l = lid ? sk.lines[lid] : undefined;
+    return !!l && l.kind === 'wall' && !l.constr;
+}
+/** What a wall's length (a curved one's diameter) is measured on, as the keypad says it. */
+const lengthSub = (sk, lid, face) => (face ? edgeLabel(sk, lid, face) : 'Wall centerline');
+/** A wall's face as an icon: the one on top, at the bottom, left or right (as the page shows it) — or its centerline. */
+function faceIcon(sk, lid, side) {
+    const l = sk.lines[lid], a = sk.points[l.a], b = sk.points[l.b], level = Math.abs(b.x - a.x) >= Math.abs(b.y - a.y);
+    if (!side)
+        return level ? 'faceMidH' : 'faceMidV';
+    // (the face's outward direction: the left of A → B for +1; y is up)
+    const nx = -(b.y - a.y) * side, ny = (b.x - a.x) * side;
+    return level ? (ny > 0 ? 'faceT' : 'faceB') : nx > 0 ? 'faceR' : 'faceL';
+}
+/**
+ * A wall's length: on its inside face (or one space's side, or — named by the way they face — its top or left), its
+ * centerline, its other face.
+ */
+function lengthChoices(sk, lid) {
+    const n = faceName(sk, lid, 1), byWay = ['Top', 'Bottom', 'Left', 'Right'].includes(n);
+    const first = byWay ? (n === 'Top' || n === 'Left' ? 1 : -1) : spaceBeside(sk, lid, 1) ? 1 : -1;
+    const side = (f) => ({ label: edgeLabel(sk, lid, f), short: faceName(sk, lid, f).replace(/ side$/, ''), icon: faceIcon(sk, lid, f), face: f });
+    return [side(first), { label: 'Centerline', short: 'Center', icon: faceIcon(sk, lid, 0), face: 0 }, side(first === 1 ? -1 : 1)];
+}
+/**
+ * A curved wall's diameter (or radius): across its inner face, its centerline, its outer face — its outer face first
+ * when that's the one a space is against (a round column in a room).
+ */
+function curveChoices(sk, id) {
+    const first = spaceBeside(sk, id, 1) && !spaceBeside(sk, id, -1) ? 1 : -1;
+    const side = (f) => ({ label: edgeLabel(sk, id, f), short: faceName(sk, id, f), icon: f === 1 ? 'ringOut' : 'ringIn', face: f });
+    return [side(first), { label: 'Centerline', short: 'Center', icon: 'ringMid', face: 0 }, side(first === 1 ? -1 : 1)];
+}
+/** The faces a dimension on walls can be measured on, as choices; none when it isn't on a wall. */
+export function faceChoices(sk, c) {
+    if (c.type === 'dist' && c.line && (!c.kind || c.kind === 'al') && faced(sk, c.line))
+        return lengthChoices(sk, c.line);
+    if (c.type === 'diam' && c.c && !sk.lines[c.c] && wallOf(sk, c.c))
+        return curveChoices(sk, c.c);
+    if (c.type === 'pldist' && c.l && sk.lines[c.l] && sk.points[c.p]) {
+        const w1 = faced(sk, c.l), w2 = faced(sk, c.l2);
+        if (!w1 && !w2)
+            return [];
+        const k = (v) => [w1 ? v : 0, w2 ? v : 0];
+        if (w1 && w2) {
+            const l = sk.lines[c.l], a = sk.points[l.a], b = sk.points[l.b], H = Math.abs(b.x - a.x) >= Math.abs(b.y - a.y) ? 'H' : '';
+            return [
+                { label: 'Inside faces', short: 'Inside', icon: 'spanIn' + H, faces: k(1) },
+                { label: 'Centerlines', short: 'Centers', icon: 'spanMid' + H, faces: [0, 0] },
+                { label: 'Outside faces', short: 'Outside', icon: 'spanOut' + H, faces: k(-1) },
+            ];
+        }
+        // one wall: its face toward the other end, its centerline, its far face
+        const wl = w1 ? c.l : c.l2, other = w1 ? sk.points[c.p] : sk.points[sk.lines[c.l].a], toward = sideOf(sk, wl, other);
+        return [
+            { label: 'Near face', short: 'Near', icon: faceIcon(sk, wl, toward), faces: k(1) },
+            { label: 'Centerline', short: 'Center', icon: faceIcon(sk, wl, 0), faces: [0, 0] },
+            { label: 'Far face', short: 'Far', icon: faceIcon(sk, wl, -toward), faces: k(-1) },
+        ];
+    }
+    return [];
+}
+/** Whether a dimension is measured on the faces a choice says. */
+export function onChoice(c, ch) {
+    if (ch.face !== undefined)
+        return (c.face ?? 0) === ch.face;
+    return !!ch.faces && (c.faces?.[0] ?? 0) === ch.faces[0] && (c.faces?.[1] ?? 0) === ch.faces[1];
+}
+/** Measure a dimension on the faces a choice says (its number left as it is). A length's label moves to that side. */
+function applyFace(c, ch) {
+    if (ch.face !== undefined) {
+        if (ch.face)
+            c.face = ch.face;
+        else
+            delete c.face;
+        if (ch.face && c.type === 'dist') {
+            const l = SK().lines[c.line], k = l && c.a === l.a ? 1 : -1;
+            c.off = (Math.abs(c.off ?? 0) || 30 / V().s) * ch.face * k;
+        }
+    }
+    if (ch.faces) {
+        if (ch.l2)
+            c.l2 = ch.l2;
+        if (ch.faces[0] || ch.faces[1])
+            c.faces = [ch.faces[0], ch.faces[1]];
+        else
+            delete c.faces;
+    }
+}
+/** A copy of a dimension, measured on the faces a choice says. */
+function withFace(c, ch) {
+    const n = { ...c };
+    if (ch)
+        applyFace(n, ch);
+    return n;
+}
+/** What a dimension's faces are, to put back. */
+const faceState = (c) => ({ face: c.face, faces: c.faces, l2: c.l2, off: c.off });
+function restoreFace(c, f) {
+    if (f.face === undefined)
+        delete c.face;
+    else
+        c.face = f.face;
+    if (f.faces === undefined)
+        delete c.faces;
+    else
+        c.faces = f.faces;
+    if (f.l2 === undefined)
+        delete c.l2;
+    else
+        c.l2 = f.l2;
+    if (f.off === undefined)
+        delete c.off;
+    else
+        c.off = f.off;
+}
+/** Measure a dimension on other faces of its walls, the drawing kept as it is: its number is what it measures there now. */
+export function setDimFace(id, ch) {
+    const sk = SK(), c = sk.cons[id];
+    if (!c || onChoice(c, ch))
+        return;
+    pushHistory();
+    applyFace(c, ch);
+    if (c.driving !== false)
+        c.value = measure(sk, c);
+    afterEdit();
+}
+/**
+ * The face of wall `lid` to measure from, to something at `at`: +1 its face toward it, −1 its far face, 0 its centerline.
+ * `side` is the edge picked (+1 / −1: the left / right of its A → B; 0 its centerline). Picked whole, to a point: the
+ * face toward it where a space is against it. To another wall (`wall`): its room's side, as its length is measured —
+ * the side toward the other between two spaces; with no space beside it, its centerline.
+ */
+function faceToward(sk, lid, at, side, wall = false) {
+    if (!faced(sk, lid))
+        return 0;
+    const toward = sideOf(sk, lid, at);
+    if (side === undefined)
+        return spaceBeside(sk, lid, toward) ? 1 : wall && spaceBeside(sk, lid, toward === 1 ? -1 : 1) ? -1 : 0;
+    return side === 0 ? 0 : side === toward ? 1 : -1;
+}
+/** From a wall's edge to a point: square to the wall, from that face. */
+export function dimEdgePoint(lid, side, p) {
+    const sk = SK(), l = sk.lines[lid];
+    // (one of the wall's own ends is no distance from it)
+    if (!l || p === l.a || p === l.b) {
+        toast('Pick a point off the wall to measure from its edge.', { warn: true });
+        return;
+    }
+    dimPointLine(p, lid, { faces: [faceToward(sk, lid, sk.points[p], side), 0], title: 'Distance from the edge' });
+}
+/**
+ * Two things picked, at least one a wall's edge: the distance between them — two edges of one wall, its thickness
+ * (`thickness` opens it); of two walls, face to face; an edge and a line, from that face; an edge and a point, from it.
+ */
+export function dimEdges(items, thickness) {
+    const edges = items.filter(x => x.type === 'wface').map(x => edgeOf(x.id));
+    const other = items.find(x => x.type !== 'wface');
+    if (edges.length === 2) {
+        const [[a, sa], [b, sb]] = edges;
+        if (a === b) {
+            thickness(a);
+            return;
+        }
+        if (SK().lines[a] && SK().lines[b])
+            dimTwoLines(a, b, { [a]: sa, [b]: sb });
+        return;
+    }
+    if (edges.length !== 1 || !other)
+        return;
+    const [lid, side] = edges[0];
+    if (other.type === 'point')
+        dimEdgePoint(lid, side, other.id);
+    else if (other.type === 'line')
+        dimTwoLines(lid, other.id, { [lid]: side });
 }
 export function dimPoints(a, b, print) {
     const sk = SK(), A = sk.points[a], B = sk.points[b];
@@ -234,9 +524,9 @@ export function dimPoints(a, b, print) {
     openKeypad({
         onClose: () => { ed.preview = null; requestDraw(); },
         title: 'Distance', initial: fmtLen(L), selectAll: true, laser: true,
-        onDone: v => {
+        onDone: (v, capture) => {
             pushHistory();
-            const r = tryAddConstraint({ type: 'dist', a, b, kind: 'al', value: v, driving: true, off: 0 });
+            const r = tryAddConstraint({ type: 'dist', a, b, kind: 'al', value: v, driving: true, off: 0, ...(capture !== undefined ? { capture } : {}) });
             if (!r.ok)
                 dropHistory();
             ed.sel = [];
@@ -246,9 +536,11 @@ export function dimPoints(a, b, print) {
 }
 /**
  * Dimension between two lines: their distance if they're parallel (measured square to them, and kept parallel),
- * otherwise the angle between them. An existing dimension between them is edited instead of stacking another.
+ * otherwise the angle between them. An existing dimension between them is edited instead of stacking another. Between
+ * walls it's measured on `sides`, the edges picked (+1 / −1: the face to the left / right of A → B; 0 its centerline) —
+ * or, picked whole, each wall's room side (see faceToward).
  */
-export function dimTwoLines(l1, l2) {
+export function dimTwoLines(l1, l2, sides = {}) {
     const sk = SK(), L1 = sk.lines[l1], L2 = sk.lines[l2];
     if (!L1 || !L2)
         return;
@@ -264,8 +556,15 @@ export function dimTwoLines(l1, l2) {
             return (c.l1 === l1 && c.l2 === l2) || (c.l1 === l2 && c.l2 === l1);
         return (c.l === l1 && (c.p === L2.a || c.p === L2.b)) || (c.l === l2 && (c.p === L1.a || c.p === L1.b));
     });
+    /** The faces between line `l` (the one measured square to) and the other, from point `p` on the other. */
+    const facesFrom = (l, p) => {
+        const o = l === l1 ? l2 : l1, ol = sk.lines[o], on = sk.lines[l];
+        return { faces: [faceToward(sk, l, sk.points[p], sides[l], true), faceToward(sk, o, sk.points[on.a], sides[o], true)], ...(faced(sk, o) && ol ? { l2: o } : {}) };
+    };
     if (existing) {
-        editDim(existing);
+        const c = sk.cons[existing];
+        // (the edges picked: it's measured between them now)
+        editDim(existing, undefined, false, c.type === 'pldist' && Object.keys(sides).length ? facesFrom(c.l, c.p) : undefined);
         return;
     }
     if (!parallel) {
@@ -276,23 +575,38 @@ export function dimTwoLines(l1, l2) {
     const A = sk.points[L1.a], B = sk.points[L1.b], len2 = (B.x - A.x) ** 2 + (B.y - A.y) ** 2 || 1;
     const t = (pid) => { const P = sk.points[pid]; return ((P.x - A.x) * (B.x - A.x) + (P.y - A.y) * (B.y - A.y)) / len2; };
     const p = Math.abs(t(L2.a) - 0.5) <= Math.abs(t(L2.b) - 0.5) ? L2.a : L2.b;
-    dimPointLine(p, l1, { keepParallel: l2, title: 'Distance between lines' });
+    const f = facesFrom(l1, p);
+    dimPointLine(p, l1, { keepParallel: l2, title: 'Distance between lines', faces: f.faces, l2: f.l2 });
 }
+/**
+ * The distance from point `p` to line `lid`, square to it. On a wall it's measured from `faces[0]`, its face toward
+ * the point (+1), its far face (−1) or its centerline (0) — by default the face toward it where a space is against it;
+ * `faces[1]` is the same for wall `l2`, which the point is the end of (a distance between two walls). The keypad can
+ * switch them.
+ */
 export function dimPointLine(p, lid, opts = {}) {
     const sk = SK(), l = sk.lines[lid], P = sk.points[p], A = sk.points[l.a], B = sk.points[l.b];
     const sd = ((B.x - A.x) * (P.y - A.y) - (B.y - A.y) * (P.x - A.x)) / (hyp(B.x - A.x, B.y - A.y) || 1);
     const sign = sd < 0 ? -1 : 1;
-    const t = ((P.x - A.x) * (B.x - A.x) + (P.y - A.y) * (B.y - A.y)) / ((B.x - A.x) ** 2 + (B.y - A.y) ** 2 || 1);
-    const foot = { x: A.x + (B.x - A.x) * t, y: A.y + (B.y - A.y) * t };
+    const c = { type: 'pldist', p, l: lid, value: 0, sign, driving: true, ...(opts.l2 ? { l2: opts.l2 } : {}) };
+    applyFace(c, { faces: opts.faces ?? [faceToward(sk, lid, P), 0] });
+    const choices = faceChoices(sk, c);
     ed.sel = [];
-    ed.preview = (c, T) => drawPendingDim(c, T, { from: P, to: foot, a: P, b: foot, nx: 0, ny: 0, off: 0, label: fmtLen(kpTyped() ?? Math.abs(sd)) });
+    ed.preview = (cx, T) => { const e = dimEnds(sk, c); if (e)
+        drawPendingDim(cx, T, { from: e.a, to: e.b, a: e.a, b: e.b, nx: 0, ny: 0, off: 0, label: fmtLen(kpTyped() ?? measure(sk, c)) }); };
     requestDraw();
-    openKeypad({
+    const spec = {
         onClose: () => { ed.preview = null; requestDraw(); },
-        title: opts.title || 'Distance to line', sub: opts.keepParallel ? 'Measured square to the lines' : '', initial: fmtLen(Math.abs(sd)), selectAll: true,
+        // (which faces it's measured between: the choices beside the keys)
+        title: opts.title || 'Distance to line', sub: opts.keepParallel ? 'Measured square to the lines' : '', initial: fmtLen(measure(sk, c)), selectAll: true,
+        extras: choices.length ? () => choices.map(ch => ({
+            label: ch.label, on: onChoice(c, ch),
+            onPress: () => { applyFace(c, ch); requestOverlayDraw(); if (keypadFresh())
+                keypadSetReading(measure(sk, c)); },
+        })) : undefined,
         onDone: v => {
             pushHistory();
-            const r = tryAddConstraint({ type: 'pldist', p, l: lid, value: v, sign, driving: true });
+            const r = tryAddConstraint({ ...c, value: v });
             if (!r.ok)
                 dropHistory();
             // a distance between two lines only holds if they stay parallel (no-op if something already keeps them so)
@@ -301,49 +615,102 @@ export function dimPointLine(p, lid, opts = {}) {
             ed.sel = [];
             afterEdit();
         },
-    });
+    };
+    openKeypad(spec);
 }
-export function dimCurve(id) {
-    const sk = SK();
+/**
+ * A circle's or arc's diameter: its keypad, or its dimension's. A curved wall's is measured across `side`, the edge
+ * picked (+1 its outer face, −1 its inner) — or, picked whole, the side a space is on (the side it was tapped on,
+ * between two), and its centerline where there's no space; the keypad can switch it.
+ */
+export function dimCurve(id, side) {
+    const sk = SK(), wall = !!wallOf(sk, id);
     for (const k in sk.cons) {
         const c = sk.cons[k];
         if (c.type === 'diam' && c.c === id) {
-            editDim(k);
+            editDim(k, undefined, false, wall && side ? { face: side } : undefined);
             return;
         }
     }
-    const cur = measure(sk, { type: 'diam', c: id });
-    ed.sel = [{ type: sk.circles[id] ? 'circle' : 'arc', id }];
-    requestDraw();
-    openKeypad({
-        title: 'Diameter', initial: fmtLen(cur), selectAll: true,
+    let face = wall ? side ?? defaultFace(sk, id, ed.wallTap?.id === id ? ed.wallTap.side : undefined) ?? 0 : 0;
+    const now = () => measure(sk, { type: 'diam', c: id, ...(face ? { face } : {}) });
+    // (while it's being entered, what it measures across is what's highlighted: the edge, or the wall)
+    const was = ed.sel, type = sk.circles[id] ? 'circle' : 'arc';
+    const show = () => { ed.sel = face ? [{ type: 'wface', id: edgeId(id, face) }] : [{ type, id }]; requestDraw(); };
+    show();
+    const spec = {
+        title: 'Diameter', sub: wall ? lengthSub(sk, id, face) : '', initial: fmtLen(now()), selectAll: true,
+        extras: wall ? () => curveChoices(sk, id).map(ch => ({
+            label: ch.label, on: ch.face === face,
+            onPress: () => { face = ch.face; spec.sub = lengthSub(sk, id, face); show(); if (keypadFresh())
+                keypadSetReading(now()); },
+        })) : undefined,
+        onClose: () => { ed.sel = was; requestDraw(); },
         onDone: v => {
             if (v <= 0)
                 return;
             pushHistory();
-            const r = tryAddConstraint({ type: 'diam', c: id, value: v, driving: true });
+            const r = tryAddConstraint({ type: 'diam', c: id, value: v, driving: true, ...(face ? { face } : {}) });
             if (!r.ok)
                 dropHistory();
+            // (as a length: the dimension made, nothing left highlighted)
+            ed.sel = [];
             afterEdit();
         },
-    });
+    };
+    openKeypad(spec);
+}
+/** A corner's angle (two lines meeting at `pid`): its angle dimension's keypad, or a new one's. False if it isn't a corner. */
+export function cornerAngle(pid, done, modeless = false) {
+    const sk = SK(), pair = cornerLines(sk, pid);
+    if (!pair)
+        return false;
+    // edit the corner's existing angle dimension rather than stacking a second one
+    const ex = Object.keys(sk.cons).find(id => { const c = sk.cons[id]; return c.type === 'angle' && c.layer !== 'print' && ((c.l1 === pair[0] && c.l2 === pair[1]) || (c.l1 === pair[1] && c.l2 === pair[0])); });
+    if (ex)
+        editDim(ex, done, modeless);
+    else
+        dimAngle(pair[0], pair[1], done, modeless);
+    return true;
 }
-export function dimAngle(l1, l2) {
+export function dimAngle(l1, l2, done, modeless = false) {
     const c = { type: 'angle', l1, l2, value: 0, driving: true };
     const cur = measure(SK(), c);
+    /** The angle dimension, driving, at `v` degrees (`extra`: what it's from). */
+    const addAngle = (v, extra) => {
+        pushHistory();
+        const r = tryAddConstraint({ ...c, value: v, ...extra });
+        // a measurement of the job drives an angle, or nothing: not one the drawing already sets
+        if (r.ok && r.ref && extra.measurementRef) {
+            delete SK().cons[r.id];
+            dropHistory();
+            toast(ANGLE_SET_ALREADY, { warn: true });
+        }
+        else if (!r.ok)
+            dropHistory();
+        afterEdit();
+        done?.();
+    };
     openKeypad({
-        title: 'Angle', sub: 'Degrees', numeric: true, initial: String(Math.round(cur * 10) / 10), selectAll: true,
-        onDone: v => {
-            pushHistory();
-            c.value = v;
-            const r = tryAddConstraint(c);
-            if (!r.ok)
-                dropHistory();
-            afterEdit();
-        },
+        title: 'Angle', sub: 'Degrees', numeric: true, initial: String(Math.round(cur * 10) / 10), selectAll: true, modeless,
+        onDone: v => addAngle(v, {}),
+        // (or an angle of the job's, from its list: the corner takes it, linked to it)
+        measurements: offersJobMeasurements() ? {
+            kind: 'angle', pick: t => {
+                const v = jobValue(t, 'angle');
+                if (v == null)
+                    return;
+                closeKeypad();
+                addAngle(v, { measurementRef: linkSnapshot(t) });
+            },
+        } : undefined,
     });
 }
-export function editDim(id) {
+/**
+ * The keypad for a dimension. One measured on walls can be switched to their other faces (or centerlines) there — to
+ * `pick` straight away — taken with the value on Apply.
+ */
+export function editDim(id, done, modeless = false, pick) {
     const sk = SK(), c = sk.cons[id];
     if (!c)
         return;
@@ -351,57 +718,175 @@ export function editDim(id) {
     requestDraw();
     updateCtx();
     const isAng = c.type === 'angle';
-    const cur = c.driving === false ? measure(sk, c) : c.value;
-    const title = c.type === 'diam' ? 'Diameter' : isAng ? 'Angle' : c.type === 'pldist' ? 'Offset distance' : c.line ? 'Length' : 'Distance';
-    openKeypad({
+    // a fillet's radius is kept as its diameter: shown and entered as the radius
+    const k = c.rad ? 2 : 1;
+    let face = pick && !onChoice(c, pick) ? pick : null;
+    /** What it measures on the faces chosen (as it stands, for one that doesn't change them). */
+    const now = () => (face ? measure(sk, withFace(c, face)) : c.driving === false ? measure(sk, c) : c.value) / k;
+    const title = c.type === 'diam' ? (c.rad ? 'Radius' : 'Diameter') : isAng ? 'Angle' : c.type === 'pldist' ? 'Offset distance' : c.line ? 'Length' : 'Distance';
+    // (which faces it's measured on: the choices beside the keys)
+    const spec = {
         title,
         sub: c.driving === false ? (c.layer === 'print' ? 'Print dimension (label only)' : 'Reference — not driving the shape') : 'Driving dimension',
-        numeric: isAng, initial: isAng ? String(Math.round(cur * 10) / 10) : fmtLen(cur), selectAll: true, laser: !isAng,
-        extras: () => [
-            ...(c.layer !== 'print' ? [{ label: c.driving === false ? 'Make driving' : 'Make reference', onPress: () => { closeKeypad(); toggleRef(id); } }] : []),
-            { label: 'Delete', danger: true, onPress: () => { closeKeypad(); pushHistory(); delete SK().cons[id]; ed.sel = []; afterEdit(); } },
-        ],
-        onDone: v => setDimValue(id, v),
-    });
+        numeric: isAng, initial: isAng ? String(Math.round(now() * 10) / 10) : fmtLen(now()), selectAll: true, laser: !isAng, modeless,
+        // (just the faces it's measured on: Reference and Delete are the bar's, for a dimension selected)
+        extras: () => faceChoices(sk, withFace(c, face)).map(ch => ({
+            label: ch.label, on: onChoice(withFace(c, face), ch),
+            onPress: () => { face = onChoice(c, ch) ? null : { ...ch, l2: face?.l2 ?? ch.l2 }; if (keypadFresh())
+                keypadSetReading(now()); },
+        })),
+        onDone: (v, capture) => { setDimValue(id, v * k, face ?? undefined, { capture }); done?.(); },
+        // a line's length or an angle: or one of the job's, from its list — the dimension takes it, linked to it (a
+        // dimension already linked to another, re-linked)
+        measurements: ((c.type === 'dist' && c.line) || isAng) && c.layer !== 'print' && offersJobMeasurements() ? {
+            kind: isAng ? 'angle' : 'length', pick: t => {
+                const v = jobValue(t, isAng ? 'angle' : 'length');
+                if (v == null)
+                    return;
+                closeKeypad();
+                setDimValue(id, v, face ?? undefined, { link: linkSnapshot(t), asked: true });
+                done?.();
+            },
+        } : undefined,
+    };
+    openKeypad(spec);
 }
 const fmtValue = (c, v) => (c.type === 'angle' ? fmtAng(v) : fmtLen(v));
-export function setDimValue(id, v) {
+/**
+ * For a cabinet's width or height on a wall face: which of its corners to keep still while the new size is met, in
+ * the order to try — its bottom, then its top (height); its left side, then its right (width). Empty otherwise.
+ */
+function holdFirst(sk, id) {
+    for (const cb of Object.values(sk.cabs ?? {})) {
+        if (cb.h === id)
+            return [[cb.bl, cb.br], [cb.tl, cb.tr]];
+        if (cb.w === id)
+            return [[cb.bl, cb.tl], [cb.br, cb.tr]];
+    }
+    return [];
+}
+/** What a new value brings with it, once it's taken: a link (or none), and the laser reading it's from (or none). */
+function takeLink(c, o) {
+    if (o.link) {
+        c.measurementRef = o.link;
+        delete c.measurementId;
+    }
+    else if (o.link === null)
+        delete c.measurementRef;
+    // (a reading's record is kept for saving to the group; any other value isn't a reading's)
+    if (o.capture !== undefined && !c.measurementRef)
+        c.capture = o.capture;
+    else if (!o.quiet)
+        delete c.capture;
+}
+/**
+ * Give dimension `id` value `v`, solving the drawing to it (or explaining why it can't). Whether it took — false too
+ * when the person is asked first, for a dimension linked to a measurement of the job (see editor/linkWrite.ts).
+ */
+export function setDimValue(id, v, face, opts = {}) {
     const sk = SK(), c = sk.cons[id];
     if (!c)
-        return;
+        return false;
     if (c.layer === 'print') {
-        toast('Print dimensions follow the drawing. Change a driving dimension instead.');
-        return;
+        toast('Print dimensions follow the drawing. Change a driving dimension instead.', { warn: true });
+        return false;
+    }
+    if (c.measurementRef && opts.link === undefined && !opts.asked && !opts.quiet && changesValue(c, v)) {
+        askLinkedChange(c, v, unlink => setDimValue(id, v, face, { ...opts, asked: true, ...(unlink ? { link: null } : {}) }), opts.capture);
+        return false;
     }
+    const push = opts.quiet ? () => { } : pushHistory, drop = opts.quiet ? () => { } : dropHistory;
     if (c.driving === false) {
-        pushHistory();
+        push();
         delete sk.cons[id];
-        const r = tryAddConstraint(Object.assign({}, c, { driving: true, value: v }));
+        const n = withFace(Object.assign({}, c, { driving: true, value: v }), face ?? null);
+        delete n.auto; // entered: a measurement now
+        takeLink(n, opts);
+        const r = tryAddConstraint(n);
         if (!r.ok) {
             sk.cons[id] = c;
-            dropHistory();
+            drop();
+        }
+        else if (r.id) {
+            // a cabinet's size on a wall face: it's this one now
+            for (const cb of Object.values(sk.cabs ?? {})) {
+                if (cb.w === id)
+                    cb.w = r.id;
+                if (cb.h === id)
+                    cb.h = r.id;
+            }
         }
         afterEdit();
-        return;
+        return r.ok;
     }
-    pushHistory();
-    const old = c.value;
+    push();
+    const old = c.value, wasAuto = c.auto, was = overflow(sk), oldFace = faceState(c);
     c.value = v;
-    const snap = snapshotPos(sk);
-    const s = solver.solve(sk);
+    if (face)
+        applyFace(c, face);
+    delete c.auto; // entered: a measurement now
+    const snap = fitState(sk);
+    // a cabinet's own size grows from the side it stands on: its height upward (its foot stays on the floor), its
+    // width to the right — and only the other way if that would run past the wall
+    const holding = (hold) => {
+        // (held exactly: fixed points aren't moved by the solver at all; put back as they were after)
+        const pts = hold.map(pid => sk.points[pid]).filter(Boolean), had = pts.map(p => p.fixed);
+        pts.forEach(p => { p.fixed = true; });
+        const r = solver.solve(sk);
+        pts.forEach((p, i) => { if (had[i])
+            p.fixed = true;
+        else
+            delete p.fixed; });
+        return r;
+    };
+    let s = null, fit = false, solved = false;
+    // (a cabinet's own size: its sides in order; any other dimension: as it lands, then keeping each thing it ties still)
+    const own = holdFirst(sk, id), holds = own.length ? [...own, null] : [null, ...holdGroups(sk, c)];
+    for (const hold of holds) {
+        if (s)
+            restoreFit(sk, snap);
+        s = hold ? holding(hold) : solver.solve(sk);
+        solved ||= s.ok;
+        if (s.ok && !pushedOut(was, overflow(sk))) {
+            fit = true;
+            break;
+        }
+    }
+    s = s;
+    // a value that would push anything past its wall (or make a wall shorter than what's on it) is refused
+    if (solved && !fit) {
+        restoreFit(sk, snap);
+        c.value = old;
+        restoreFace(c, oldFace);
+        if (wasAuto)
+            c.auto = true;
+        drop();
+        if (!opts.quiet)
+            toast(pastWallMsg(), { warn: true });
+        afterEdit();
+        return false;
+    }
     if (!s.ok) {
-        restorePos(sk, snap);
+        restoreFit(sk, snap);
         c.value = old;
-        dropHistory();
+        restoreFace(c, oldFace);
+        if (wasAuto)
+            c.auto = true;
+        drop();
         const bad = s.bad.filter(cid => cid !== id && sk.cons[cid]);
-        showConflict({
-            title: fmtValue(c, v) + ' doesn’t fit',
-            msg: 'The other constraints can’t hold with that value. Remove one of these, or try a different number.',
-            ids: bad.slice(0, 8),
-            retry: () => setDimValue(id, v),
-        });
+        if (!opts.quiet)
+            showConflict({
+                title: fmtValue(c, v) + ' doesn’t fit',
+                msg: 'The other constraints can’t hold with that value. Remove one of these, or try a different number.',
+                ids: bad.slice(0, 8),
+                retry: () => setDimValue(id, v, face, { ...opts, asked: true }),
+            });
+        afterEdit();
+        return false;
     }
+    takeLink(c, opts);
     afterEdit();
+    return true;
 }
 export function toggleRef(id) {
     const sk = SK(), c = sk.cons[id];