@reekon-tools/boldr-cad 0.1.0 → 1.0.0

package/src/tools/dim.ts

@@ -1,33 +1,46 @@
-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 type { Constraint, OpeningEdge, XY } from '../model/types';
+import type { Constraint, LinkTarget, OpeningEdge, Sketch, WallFace, XY } from '../model/types';
+import { askLinkedChange, changesValue } from '../editor/linkWrite';
+import { offersJobMeasurements, type MeasurementKind } 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 type { Hit } from '../app/state';
-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 type { PEv } from './registry';
-import { closeKeypad, kpTyped, openKeypad, showConflict, toast, updateCtx, updateHint } from '../editor/ports';
+import { keypadFresh, keypadOpen, keypadSetReading } from '../editor/keypad';
+import { cornerLines } from '../editor/selection';
+import { closeKeypad, kpTyped, openKeypad, showConflict, toast, updateCtx, updateHint, type KeypadSpec } from '../editor/ports';
 
 export const dimTool = {
-  st: { first: null as string | 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 as string | 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: PEv) {
+    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: PEv): { from: XY; to: XY; snapped: boolean } | null {
@@ -54,12 +67,14 @@ export const dimTool = {
   up(ev: PEv) {
     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; ed.sel = []; ed.preview = null; updateHint(); requestDraw(); return; }
     // door/window edge anchors: dimension them to a point (or another opening's edge) to lock them
     const picked = ed.pickedAnchor;
     if (h.type === 'oanchor') {
       const edge = h.part as OpeningEdge;
-      if (print) { toast('Print dimensions can’t attach to doors or windows yet. Switch to Driving in the bar below.'); return; }
+      if (print) { toast('Print dimensions can’t attach to doors or windows yet. Switch to Driving in the bar below.', { warn: true }); return; }
       if (st.first) {
         const p = st.first; st.first = null; ed.sel = [];
         addOpeningDim(h.id, h.weak ? nearerEdge(SK(), h.id, p) : edge, { pt: p });
@@ -79,21 +94,39 @@ export const dimTool = {
     }
     if (picked) {
       if (h.type === 'point') { ed.pickedAnchor = null; addOpeningDim(picked.id, picked.body ? nearerEdge(SK(), picked.id, h.id) : picked.edge, { pt: h.id }); 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 }]; updateHint(); requestDraw(); return; }
+      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;
+      }
       if (h.id !== st.first) dimPoints(st.first, h.id, print);
       st.first = null; 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; updateHint(); return; }
       dimLine(h.id, print);
       return;
     }
-    if (h.type === 'circle' || h.type === 'arc') dimCurve(h.id);
+    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) return 'Tap a corner or point to measure from. The door or window locks at that distance.';
@@ -107,12 +140,15 @@ export const dimTool = {
  * counts as its nearer edge, so openings are as easy to dimension as points.
  */
 function pickForDim(ev: PEv): Hit | null {
-  const h = hitAny(ev.sx, ev.sy, { touch: ev.touch, only: 'geom' });
-  if (!h || h.type !== 'line') return h;
-  const sk = SK(), l = sk.lines[h.id], A = sk.points[l.a], B = sk.points[l.b];
+  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 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;
 }
@@ -126,32 +162,250 @@ function sideAwayFromRooms(lid: string): number {
   return 1;
 }
 
-/** Tap on a line (or its + chip): open the keypad for its length, or edit the existing length. */
-export function dimLine(lid: string, print: boolean): void {
+/**
+ * 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: string, print: boolean, side?: 1 | -1): void {
   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); 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();
-    },
-  });
+  if (ex) { editDim(ex, undefined, false, wall && side ? { face: side } : undefined); return; }
+  let face: 0 | 1 | -1 = 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: KeypadSpec = {
+    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: number, extra: Partial<Constraint>): void {
+    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: LinkTarget, kind: MeasurementKind): number | null {
+  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: Sketch, lid?: string): boolean {
+  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: Sketch, lid: string, face: number): string => (face ? edgeLabel(sk, lid, face as 1 | -1) : 'Wall centerline');
+
+/**
+ * Faces a dimension can be measured between. `face`: a wall's length on its face to the left of A → B (+1), the right
+ * (−1) or its centerline (0). `faces`: a distance between two walls ([the line it's square to, the wall its point is
+ * on — `l2`]) between the faces toward each other (+1), far faces (−1) or centerlines (0).
+ */
+export interface FaceChoice {
+  /** what it's called in the keypad; `short`, in the bar (beside `icon`, which shows the face as the page has it) */
+  label?: string; short?: string; icon?: string;
+  face?: 0 | 1 | -1; faces?: [number, number]; l2?: string;
+}
+
+/** 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: Sketch, lid: string, side: number): string {
+  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: Sketch, lid: string): FaceChoice[] {
+  const n = faceName(sk, lid, 1), byWay = ['Top', 'Bottom', 'Left', 'Right'].includes(n);
+  const first: 1 | -1 = byWay ? (n === 'Top' || n === 'Left' ? 1 : -1) : spaceBeside(sk, lid, 1) ? 1 : -1;
+  const side = (f: 1 | -1): FaceChoice => ({ 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: Sketch, id: string): FaceChoice[] {
+  const first: 1 | -1 = spaceBeside(sk, id, 1) && !spaceBeside(sk, id, -1) ? 1 : -1;
+  const side = (f: 1 | -1): FaceChoice => ({ 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: Sketch, c: Constraint): FaceChoice[] {
+  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: number): [number, number] => [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: Constraint, ch: FaceChoice): boolean {
+  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: Constraint, ch: FaceChoice): void {
+  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: Constraint, ch: FaceChoice | null): Constraint {
+  const n = { ...c };
+  if (ch) applyFace(n, ch);
+  return n;
+}
+
+/** What a dimension's faces are, to put back. */
+const faceState = (c: Constraint) => ({ face: c.face, faces: c.faces, l2: c.l2, off: c.off });
+function restoreFace(c: Constraint, f: ReturnType<typeof faceState>): void {
+  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: string, ch: FaceChoice): void {
+  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: Sketch, lid: string, at: XY, side?: 0 | 1 | -1, wall = false): number {
+  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: string, side: 1 | -1, p: string): void {
+  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: { type: string; id: string }[], thickness: (lid: string) => void): void {
+  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: string, b: string, print: boolean): void {
@@ -170,9 +424,9 @@ export function dimPoints(a: string, b: string, print: boolean): void {
   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 = [];
       afterEdit();
@@ -182,9 +436,11 @@ export function dimPoints(a: string, b: string, print: boolean): void {
 
 /**
  * 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: string, l2: string): void {
+export function dimTwoLines(l1: string, l2: string, sides: Record<string, 0 | 1 | -1> = {}): void {
   const sk = SK(), L1 = sk.lines[l1], L2 = sk.lines[l2];
   if (!L1 || !L2) return;
   const [ax, ay] = norm2(sk.points[L1.b].x - sk.points[L1.a].x, sk.points[L1.b].y - sk.points[L1.a].y);
@@ -197,125 +453,301 @@ export function dimTwoLines(l1: string, l2: string): void {
     if (kind === 'angle') 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));
   });
-  if (existing) { editDim(existing); return; }
+  /** The faces between line `l` (the one measured square to) and the other, from point `p` on the other. */
+  const facesFrom = (l: string, p: string): FaceChoice => {
+    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) {
+    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) { dimAngle(l1, l2); return; }
   // measure from the end of the second line that sits most squarely across from the first
   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: string) => { 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 });
 }
 
-export function dimPointLine(p: string, lid: string, opts: { keepParallel?: string; title?: string } = {}): void {
+/**
+ * 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: string, lid: string, opts: { keepParallel?: string; title?: string; faces?: [number, number]; l2?: string } = {}): void {
   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: Constraint = { 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: KeypadSpec = {
     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)
       else if (opts.keepParallel) tryAddConstraint({ type: 'par', l1: lid, l2: opts.keepParallel }, { silent: true });
       ed.sel = [];
       afterEdit();
     },
-  });
+  };
+  openKeypad(spec);
 }
 
-export function dimCurve(id: string): void {
-  const sk = SK();
-  for (const k in sk.cons) { const c = sk.cons[k]; if (c.type === 'diam' && c.c === id) { editDim(k); 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,
+/**
+ * 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: string, side?: 1 | -1): void {
+  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, undefined, false, wall && side ? { face: side } : undefined); return; } }
+  let face: 0 | 1 | -1 = 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' as const : 'arc' as const;
+  const show = () => { ed.sel = face ? [{ type: 'wface', id: edgeId(id, face) }] : [{ type, id }]; requestDraw(); };
+  show();
+  const spec: KeypadSpec = {
+    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: string, done?: () => void, modeless = false): boolean {
+  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: string, l2: string): void {
+export function dimAngle(l1: string, l2: string, done?: () => void, modeless = false): void {
   const c: Constraint = { 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: number, extra: Partial<Constraint>) => {
+    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: string): void {
+/**
+ * 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: string, done?: () => void, modeless = false, pick?: FaceChoice): void {
   const sk = SK(), c = sk.cons[id];
   if (!c) return;
   ed.sel = [{ type: 'dim', 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: FaceChoice | null = 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: KeypadSpec = {
     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: Constraint, v: number) => (c.type === 'angle' ? fmtAng(v) : fmtLen(v));
 
-export function setDimValue(id: string, v: number): void {
+/**
+ * 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: ReturnType<typeof SK>, id: string): string[][] {
+  for (const cb of Object.values((sk as WallFace).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 [];
+}
+
+/** Set a dimension's value — on the faces of its walls `face` says, when it's given (both, or neither). */
+/** What else a new value for a dimension brings with it. */
+export interface DimValueOpts {
+  /** the measurement of the job it's linked to from now on (null: it lets go of its link) */
+  link?: LinkTarget | null;
+  /** the host's record of the laser reading the value is from: kept on the dimension until it's saved to the group */
+  capture?: unknown;
+  /** the person has said to already: a linked one changes without asking */
+  asked?: boolean;
+  /** the job's own value coming in: no undo step of its own, and nothing shown if the drawing can't hold it */
+  quiet?: boolean;
+}
+
+/** 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: Constraint, o: DimValueOpts): void {
+  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: string, v: number, face?: FaceChoice, opts: DimValueOpts = {}): boolean {
   const sk = SK(), c = sk.cons[id];
-  if (!c) return;
-  if (c.layer === 'print') { toast('Print dimensions follow the drawing. Change a driving dimension instead.'); return; }
+  if (!c) return false;
+  if (c.layer === 'print') { 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 }));
-    if (!r.ok) { sk.cons[id] = c; dropHistory(); }
+    const n: Constraint = 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; 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 as WallFace).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: string[]) => {
+    // (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: ReturnType<typeof solver.solve> | null = 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: (string[] | null)[] = 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({
+    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),
+      retry: () => setDimValue(id, v, face, { ...opts, asked: true }),
     });
+    afterEdit();
+    return false;
   }
+  takeLink(c, opts);
   afterEdit();
+  return true;
 }
 
 export function toggleRef(id: string): void {