@reekon-tools/boldr-cad 0.1.0 → 1.0.0

package/src/editor/actions.ts

@@ -1,23 +1,31 @@
-import { afterEdit, solveSketch, tryAddConstraint, undo } from '../app/edit';
+import { afterEdit, holdFaces, solveSketch, tryAddConstraint, undo } from '../app/edit';
 import { ed, type OpeningDimPart } from '../app/state';
-import { CONS_LABEL } from '../model/constraints';
+import { CONS_LABEL, measure } from '../model/constraints';
 import { dropHistory, pushHistory } from '../model/history';
-import { createsCycle, facingEdges, nearerEdge } from '../model/openings';
+import { createsCycle, edgePoint, facingEdges, nearerEdge } from '../model/openings';
+import { cabOfPoint } from '../model/faces';
 import { settings } from '../model/settings';
-import { connectedGeometry, curveInfo, deleteSel, mergePoints } from '../model/sketch';
-import { page, saveSoon, SK } from '../model/store';
-import type { Constraint, ConsType, Sketch } from '../model/types';
+import { connectedGeometry, curveInfo, deleteSel, joinPoints } from '../model/sketch';
+import { page, planSK, replaceSK, saveSoon, SK } from '../model/store';
+import type { Constraint, ConsType, OpeningEdge, Sketch, Underlay, WallFace } from '../model/types';
 import { fitView, requestDraw } from '../render/view';
 import { convertNote } from '../tools/annotate';
-import { dimAngle, dimCurve, dimLine, dimPointLine, dimPoints, dimTwoLines, editDim, toggleRef } from '../tools/dim';
+import { cornerAngle, dimCurve, dimEdges, dimLine, dimPointLine, dimPoints, dimTwoLines, editDim, faceChoices, onChoice, setDimFace, toggleRef } from '../tools/dim';
+import { edgeLabel, edgeOf } from '../model/planGeom';
 import type { LineTool } from '../tools/line';
 import { offsetPrompt, splitLine } from '../tools/modify';
+import { filletable, filletPrompt } from '../tools/fillet';
+import { chamferPrompt } from '../tools/chamfer';
 import { addOpeningDim, editOpeningDim, toggleOpeningDim } from '../tools/openings';
 import { setTool, tools } from '../tools/registry';
 import { fmtLen } from '../units';
-import { openElevation } from './elevation';
-import { editRoomName, openKeypad, openPalette, toast, updateCtx, updateTopBar } from './ports';
-import { cornerLines, selInfo } from './selection';
+import { elevOpen, fitState, OPENING_SIZES, openElevation, openingLabel, overflow, restoreFit, TOO_SHORT, wallAction, wallBar, wallDelete, wallPlus } from './elevation';
+import { pushedOut } from '../model/facesolve';
+import { editRoomName, openKeypad, openPalette, toast, toggleImageOpacity, toggleImageRotation, toggleTileSize, updateCtx, updateTopBar } from './ports';
+import { cornerLines, edgePair, selInfo } from './selection';
+import { restackImage } from './project';
+import { imageById } from '../model/images';
+import { canOpenLink, canSaveDim, linkSizeVisible, openDimLink, openSelectedLink, saveDimToGroup, selectedLink, toggleLeader, unlinkDim } from './linkActions';
 
 /*
   The contextual bottom bar's decisions: which actions fit the tool and the selection, what the yellow + measures,
@@ -32,7 +40,7 @@ function lockTargets(): string[] {
   const sk = SK(), s = selInfo(), ids = new Set(s.points);
   s.lines.forEach(id => { ids.add(sk.lines[id].a); ids.add(sk.lines[id].b); });
   s.curves.forEach(id => { const ci = curveInfo(sk, id); if (ci) ids.add(ci.o.c); });
-  return [...ids].filter(id => sk.points[id] && !sk.points[id].origin);
+  return [...ids].filter(id => sk.points[id] && !sk.points[id].origin && !sk.points[id].anchor);
 }
 
 /**
@@ -44,7 +52,7 @@ function arrangeLock(items: CtxEntry[]): CtxEntry[] {
   if (i < 0) return items;
   const it = items[i] as CtxItem;
   const sk = SK();
-  const locked = it.act === 'imgLock' ? !!page().underlay?.locked : (() => { const l = lockTargets(); return l.length > 0 && l.every(id => sk.points[id].fixed); })();
+  const locked = it.act === 'imgLock' ? selImages().length > 0 && selImages().every(u => u.locked) : (() => { const l = lockTargets(); return l.length > 0 && l.every(id => sk.points[id].fixed); })();
   Object.assign(it, { ic: locked ? 'lock' : 'unlock', label: locked ? 'Locked' : 'Lock', on: undefined, locked });
   const rest = items.filter((_, k) => k !== i);
   const out: CtxEntry[] = [it];
@@ -54,52 +62,120 @@ function arrangeLock(items: CtxEntry[]): CtxEntry[] {
   while (out[out.length - 1] === 'sep') out.pop();
   return out;
 }
+/** What the bar calls one end of a door or window. */
+function anchorLabel(id: string): string {
+  return (planSK().openings[id.split('|')[0]]?.type === 'door' ? 'Door' : 'Window') + ' edge';
+}
+
+/** The selected images. */
+const selImages = (): Underlay[] => ed.sel.filter(x => x.type === 'underlay').map(x => imageById(x.id)).filter((u): u is Underlay => !!u);
+
 export type CtxEntry = CtxItem | 'sep' | { lbl: string };
 
+/** The tools that place a door, window or cabinet (in the plan or the wall view), which select what they've placed. */
+const PLACING = new Set(['door', 'window', 'wdoor', 'wwindow', 'cabinet']);
+
 function ctxItems(): CtxEntry[] {
   const items: CtxEntry[] = [], sk = SK(), s = selInfo();
   const add = (ic: string, label: string, act: string, o: Partial<CtxItem> = {}) => items.push(Object.assign({ ic, label, act }, o));
   /** To wall (all the selected lines and curves) — or To line + Thickness when they're all walls already. */
   const wallItems = () => {
+    if (elevOpen()) return;
     const kinds = [...s.lines.map(id => sk.lines[id].kind), ...s.curves.map(id => curveInfo(sk, id)?.o.kind)];
     if (!kinds.length) return;
     if (kinds.every(k => k === 'wall')) { add('thick', 'Thickness', 'thick'); add('line', 'To line', 'kind'); }
     else add('wall', 'To wall', 'kind');
   };
   if (ed.mode === 'annotate') {
-    if (s.n === 1 && s.image) {
-      const locked = !!page().underlay?.locked;
+    const ims = selImages();
+    if (ims.length && ims.length === s.n) {
+      // an image (or several): lock, its own scale, and which goes in front where they overlap
+      // (showing and hiding them all is the Layers menu's)
       add('lock', 'Lock', 'imgLock');
-      if (!locked) add('calib', 'Set scale', 'calibtool');
-      add('eye', 'Hide image', 'toggleUnderlay');
+      if (ims.length === 1 && !ims[0].locked) add('calib', 'Set scale', 'calibtool');
+      if (ims.length === 1) add('opacity', 'Opacity', 'imgOpacity');
+      // (turning moves it: not while it's locked, as it can't be moved or sized then)
+      if (ims.length === 1 && !ims[0].locked) add('rotate', 'Rotate', 'imgRotate');
+      if (ims.length === 1 && page().underlays.length > 1) {
+        const at = page().underlays.indexOf(ims[0]), last = page().underlays.length - 1;
+        if (at < last) add('tofront', 'To front', 'imgFront');
+        if (at > 0) add('toback', 'To back', 'imgBack');
+      }
+      return items;
+    }
+    const lk = selectedLink();
+    if (lk) {
+      // a link's tile: opening it, its leader, its size (its name is on the tile, not here: the user's call, 2026-10-21)
+      if (canOpenLink(lk.link)) add('open', 'Open', 'linkOpen');
+      add('leader', 'Leader', 'linkLeader', { on: !!lk.leader });
+      // (its leader's colour, as all markup's, is the rail's colour dot's)
+      // (every tile on the page: a slider above the bar)
+      add('tilesize', 'Size', 'linkSize');
       return items;
     }
     if (s.notes.length) {
+      // (no Color: the rail's colour dot styles what's selected)
       const n = sk.notes.find(n => n.id === s.notes[0]);
-      add('color', 'Color', 'palette');
       if (n && n.type === 'pen' && s.notes.length === 1) add('convert', 'To lines', 'convert');
-    } else {
-      add('color', 'Color', 'palette');
-      if (page().underlay) { add('calib', 'Scale', 'calibtool'); add('eye', settings.layers.underlay ? 'Hide image' : 'Show image', 'toggleUnderlay'); }
+      if (linkSizeVisible()) add('tilesize', 'Size', 'linkSize');
     }
+    // nothing selected: no bar (the markup colour is the rail's colour dot, for what's selected too; the image's own
+    // options come with selecting it)
     return items;
   }
-  if (ed.tool === 'line' || ed.tool === 'wall') {
+  if (ed.tool === 'line') {
     const st = (tools[ed.tool] as LineTool).st;
-    if (st.start) {
-      add('typelen', 'Type length', 'typelen');
-      if (st.chain.length >= 3) add('closeShape', 'Close', 'closeShape');
-      add('finish', 'Finish', 'finish');
-      return items;
-    }
+    // drawing: no bar (tap the last point again to finish, the first to close the shape; Esc or Enter on a keyboard)
+    if (st.start) return items;
   }
   if (ed.tool === 'dim') { add('dim', 'Driving', 'dimDrive', { on: ed.dimLayer === 'drive' }); add('ref', 'Print', 'dimPrint', { on: ed.dimLayer === 'print' }); return items; }
-  // nothing selected: the bar stays empty (Fit and Icons live in the top bar; grid snap and auto-constrain in Settings)
-  if (!s.n || ed.tool !== 'select') return items;
+  // nothing selected: the bar stays empty (Fit and Icons live in the top bar; grid snap and auto-constrain in Settings).
+  // Just placed a door, window or cabinet (its tool still on): its bar, for its sizes
+  if (!s.n || (ed.tool !== 'select' && !PLACING.has(ed.tool))) return items;
+  // the wall view's own things: a door or window, a cabinet, one of its dimension chips, the plan's edges
+  const wb = wallBar();
+  if (wb) {
+    if (wb.label) items.push({ lbl: wb.label });
+    for (const it of wb.items) add(it.ic, it.label, it.act);
+    return items;
+  }
+  // on a wall face, walls don't exist: no To wall / Thickness
+  const wall = elevOpen();
   const P = s.points.length, L = s.lines.length, C = s.curves.length;
+  // Guide (dashed) is for lines: a wall is always solid (one that's a guide from before can still go back to Solid)
+  const allWalls = L + C > 0 && s.lines.every(id => sk.lines[id].kind === 'wall' && !sk.lines[id].constr) && s.curves.every(id => { const o = curveInfo(sk, id)?.o; return o?.kind === 'wall' && !o.constr; });
+  const guide = () => { if (!allWalls) add('constr', 'Guide', 'constr'); };
+  // a wall's edge: named, with its wall view; with another edge, a line or a point, the distance between them (two
+  // edges of one wall: its thickness)
+  if (s.wfaces.length) {
+    // (a curved wall has no wall view: just its name)
+    if (s.n === 1) {
+      const [id, side] = edgeOf(s.wfaces[0]);
+      items.push({ lbl: edgeLabel(sk, id, side) });
+      if (sk.lines[id]) add('elev', 'Elevation', 'elev');
+    }
+    else if (edgePair(s)) {
+      const one = s.wfaces.length === 2 && edgeOf(s.wfaces[0])[0] === edgeOf(s.wfaces[1])[0];
+      add(one ? 'thick' : 'dim', one ? 'Thickness' : 'Distance', 'edgeDist');
+    }
+    return items;
+  }
   if (s.n === 1 && s.dims.length) {
     const c = sk.cons[s.dims[0]];
-    if (c.layer !== 'print') add('ref', c.driving === false ? 'Drive' : 'Reference', 'toggleref');
+    // linked to a measurement of the job: opening it, letting go of it — no text saying what it's linked to (the user's
+    // call, 2026-10-21; its chip is drawn linked), and no Reference (a measurement drives its line, or it isn't linked)
+    if (c.measurementRef) {
+      const t = c.measurementRef;
+      if (canOpenLink(t)) add('open', 'Open', 'dimLinkOpen');
+      add('unlink', 'Unlink', 'dimUnlink');
+    } else if (canSaveDim(s.dims[0])) add('savegroup', 'Save to group', 'dimSave');
+    // Reference frees what a dimension holds — a distance, say; not a cabinet's own width or height, which it keeps
+    const cabSize = Object.values((sk as WallFace).cabs ?? {}).some(cb => cb.w === s.dims[0] || cb.h === s.dims[0]);
+    if (c.layer !== 'print' && !cabSize && !c.measurementRef) add('ref', c.driving === false ? 'Drive' : 'Reference', 'toggleref');
+    // measured on walls: which of their faces (the drawing stays as it is; the number becomes what it measures there)
+    const fc = faceChoices(sk, c);
+    if (fc.length && items.length) items.push('sep');
+    fc.forEach((ch, i) => add(ch.icon!, ch.short!, 'dimFace' + i, { on: onChoice(c, ch) }));
     return items;
   }
   if (s.n === 1 && s.odims.length) {
@@ -110,26 +186,44 @@ function ctxItems(): CtxEntry[] {
   // a constraint badge: nothing to offer but delete (the trash), so the bar stays empty
   if (s.n === 1 && s.cons.length) return items;
   if (s.n === 1 && s.rooms.length) { add('rename', 'Rename', 'renameRoom'); return items; }
+  // one end of a door or window: named; with another point, end or door/window, the distance between them
+  if (s.oanchors.length && s.n === 1) { items.push({ lbl: anchorLabel(s.oanchors[0]) }); return items; }
+  if (s.oanchors.length && s.n === 2 && s.oanchors.length + s.points.length + s.openings.length === 2) { add('dim', 'Distance', 'anchorDist'); return items; }
   // two doors/windows, or one and a point: the distance between them (locks the second one picked)
   if (s.n === 2 && (s.openings.length === 2 || (s.openings.length === 1 && s.points.length === 1))) { add('dim', 'Distance', 'opDist'); return items; }
   if (s.n === 1 && s.openings.length) {
-    // the yellow + sets the width; the type is fixed once placed (Door and Window are separate tools)
-    if (sk.openings[s.openings[0]].type === 'door') add('flip', 'Flip', 'opFlip');
+    // its sizes by name, as in the wall view (no +: it isn't one dimension); a door's swing too. (The type is fixed
+    // once placed: Door and Window are separate tools.)
+    const o = sk.openings[s.openings[0]];
+    items.push({ lbl: openingLabel(o) });
+    for (const it of OPENING_SIZES) add(it.ic, it.label, it.act);
+    if (o.type === 'door') { items.push('sep'); add('flip', 'Flip', 'opFlip'); }
     return items;
   }
   if (L === 1 && s.n === 1) {
     const l = sk.lines[s.lines[0]];
-    add('h', 'Horizontal', 'h', { key: '⇧H' }); add('v', 'Vertical', 'v', { key: '⇧V' }); add('dim', 'Length', 'len');
+    add('h', 'Horizontal', 'h', { key: '⇧H' }); add('v', 'Vertical', 'v', { key: '⇧V' }); // (its length: the yellow +)
     items.push('sep');
-    add('lock', 'Lock', 'lock', { key: '⇧F' }); add('split', 'Split', 'split'); add('offset', 'Offset', 'offset'); add('chain', 'Connected', 'chain'); add('constr', l.constr ? 'Solid' : 'Guide', 'constr');
-    if (l.kind === 'wall') { add('thick', 'Thickness', 'thick'); add('line', 'To line', 'kind'); } else add('wall', 'To wall', 'kind');
-    if (l.kind === 'wall' && !l.constr) { items.push('sep'); add('elev', 'Elevation', 'elev'); }
+    add('lock', 'Lock', 'lock', { key: '⇧F' }); add('split', 'Split', 'split'); add('offset', 'Offset', 'offset'); if (l.constr) add('constr', 'Solid', 'constr'); else guide();
+    if (!wall) {
+      if (l.kind === 'wall') { add('thick', 'Thickness', 'thick'); add('line', 'To line', 'kind'); } else add('wall', 'To wall', 'kind');
+      if (l.kind === 'wall' && !l.constr) { items.push('sep'); add('elev', 'Elevation', 'elev'); }
+    }
     return items;
   }
-  if (L === 2 && s.n === 2) { add('par', 'Parallel', 'par', { key: '⇧P' }); add('perp', 'Perpendicular', 'perp', { key: '⇧R' }); add('col', 'Collinear', 'col', { key: '⇧L' }); add('eq', 'Equal', 'eq', { key: '⇧E' }); add('angle', 'Angle', 'angle'); wallItems(); return items; }
+  if (L === 2 && s.n === 2) {
+    // (no Angle here: the yellow + is the angle between them — or, parallel, the distance)
+    add('par', 'Parallel', 'par', { key: '⇧P' }); add('perp', 'Perpendicular', 'perp', { key: '⇧R' }); add('col', 'Collinear', 'col', { key: '⇧L' }); add('eq', 'Equal', 'eq', { key: '⇧E' });
+    // two lines that meet: round off (or cut off) the corner between them
+    if (filletCorner2()) { add('fillet', 'Fillet', 'fillet'); add('chamfer', 'Chamfer', 'chamfer'); }
+    wallItems();
+    return items;
+  }
+  // a cabinet's corner: nothing of its own (pick another point or line with it to dimension or constrain)
+  if (P === 1 && s.n === 1 && cabOfPoint(sk, s.points[0])) return items;
   if (P === 1 && s.n === 1) {
-    // a corner where exactly two lines meet: offer its angle
-    if (cornerLines(sk, s.points[0])) add('angle', 'Angle', 'cornerAngle');
+    // a corner where exactly two lines meet: rounding it off or cutting it off (its angle is the yellow +)
+    if (filletable(sk, s.points[0])) { add('fillet', 'Fillet', 'fillet'); add('chamfer', 'Chamfer', 'chamfer'); }
     add('lock', 'Lock', 'lock', { key: '⇧F' });
     return items;
   }
@@ -140,7 +234,8 @@ function ctxItems(): CtxEntry[] {
   // a circle or arc: the yellow + sets its diameter
   if (C === 1 && s.n === 1) {
     const ci = curveInfo(sk, s.curves[0]);
-    add('constr', 'Guide', 'constr');
+    guide();
+    if (wall) return items;
     if (ci && ci.o.kind === 'wall') { add('thick', 'Thickness', 'thick'); add('arc', 'To line', 'kind'); } else add('wall', 'To wall', 'kind');
     return items;
   }
@@ -150,33 +245,87 @@ function ctxItems(): CtxEntry[] {
     add('h', 'Horizontal', 'h', { key: '⇧H' }); add('v', 'Vertical', 'v', { key: '⇧V' });
     add('par', 'Parallel', 'par', { key: '⇧P' }); add('col', 'Collinear', 'col', { key: '⇧L' }); add('eq', 'Equal', 'eq', { key: '⇧E' });
     items.push('sep');
-    add('chain', 'Connected', 'chain'); add('lock', 'Lock', 'lock'); add('constr', 'Guide', 'constr'); wallItems();
+    add('lock', 'Lock', 'lock'); guide(); wallItems();
     return items;
   }
-  if (L >= 2) { add('eq', 'Equal', 'eqall'); add('chain', 'Connected', 'chain'); add('lock', 'Lock', 'lock'); add('constr', 'Guide', 'constr'); wallItems(); return items; }
+  if (L >= 2) { add('eq', 'Equal', 'eqall'); add('lock', 'Lock', 'lock'); guide(); wallItems(); return items; }
   add('lock', 'Lock', 'lock');
   return items;
 }
 
+/** The keypad for walls' thickness, finished face to face. */
+function thicknessPrompt(walls: { thick?: number }[]): void {
+  const sk = SK();
+  if (!walls.length) return;
+  openKeypad({
+    title: 'Wall thickness', sub: 'Finished face to face', initial: fmtLen(walls[0].thick || 4.5), selectAll: true,
+    onDone: v => {
+      if (v <= 0) return;
+      // a thicker wall's faces are shorter (its corners come in): not shorter than what's on them — and what's measured
+      // on walls' faces stays as measured, the centrelines moving to keep it
+      const was = overflow(sk), held = fitState(sk), had = walls.map(w => w.thick);
+      pushHistory();
+      walls.forEach(w => (w.thick = v));
+      const faces = holdFaces();
+      if (!faces || pushedOut(was, overflow(sk))) {
+        walls.forEach((w, i) => (w.thick = had[i])); restoreFit(sk, held); dropHistory();
+        toast(faces ? TOO_SHORT : 'The dimensions measured on walls’ faces can’t hold at that thickness.', { warn: true });
+      }
+      afterEdit();
+    },
+  });
+}
+
+/** Two selected lines that meet at a corner of just those two: that corner (to round it off). */
+function filletCorner2(): string | null {
+  const sk = SK(), s = selInfo();
+  if (s.lines.length !== 2 || s.n !== 2) return null;
+  const [a, b] = s.lines.map(id => sk.lines[id]);
+  const p = [a.a, a.b].find(x => x === b.a || x === b.b);
+  return p && filletable(sk, p) ? p : null;
+}
+
 /** Buttons for the bottom bar: they adapt to the tool and the selection (Lock first, when offered). */
 export const barItems = (): CtxEntry[] => arrangeLock(ctxItems());
 
 /** The yellow + only appears for something it can measure: not for constraint badges or spaces alone. */
+const DRAW_TOOLS = new Set(['line', 'freehand', 'rect', 'circle', 'arc']);
+
 export function plusVisible(): boolean {
+  // markup isn't measured: Annotate has no + (notes are the rail's Text tool)
+  if (ed.mode === 'annotate') return false;
+  const wb = wallBar();
+  if (wb) return wb.plus;
+  // a shape just drawn (Rectangle, Circle, Arc keep their tool, the shape selected) gets no + of its own;
+  // a door or window just placed does (its width)
+  if (ed.mode === 'draft' && DRAW_TOOLS.has(ed.tool)) return false;
+  // one end of a door or window, alone: nothing to measure yet
+  if (ed.sel.length === 1 && ed.sel[0].type === 'oanchor') return false;
+  // one door or window picked as a whole: its sizes are in the bar, by name — no single dimension for a +
+  // (two, or one and a point: the + is the distance between them)
+  if (ed.sel.length === 1 && ed.sel[0].type === 'opening') return false;
   return ed.sel.length > 0 && !ed.sel.every(x => x.type === 'cons') && !ed.sel.every(x => x.type === 'room');
 }
 
-export const plusLabel = (): string => (ed.mode === 'annotate' ? 'Add a note' : 'Add a measurement');
+export const plusLabel = (): string => 'Add a measurement';
 
-/** The yellow +: a note in Annotate; otherwise the measurement that fits the selection (opens the keypad). */
+/** The yellow +: the measurement that fits the selection (opens the keypad). */
 export function plusAction(): void {
-  if (ed.mode === 'annotate') { setTool('text'); return; }
+  if (ed.mode === 'annotate') return;
+  if (wallPlus()) return;
   const s = selInfo(), sk = SK();
-  if (s.dims.length === 1 && s.n === 1) { if (sk.cons[s.dims[0]]?.layer === 'print') toast('Print dimensions are labels only — drag to move them.'); else editDim(s.dims[0]); }
+  if (s.dims.length === 1 && s.n === 1) { if (sk.cons[s.dims[0]]?.layer === 'print') toast('Print dimensions are labels only — drag to move them.', { warn: true }); else editDim(s.dims[0]); }
   else if (s.odims.length === 1 && s.n === 1) { const [op, part] = s.odims[0].split('|'); editOpeningDim(op, part as OpeningDimPart); }
+  // a wall's edge: its length on that face; with another edge, a line or a point, the distance from it
+  // (a curved wall's: its diameter across that face)
+  else if (s.wfaces.length === 1 && s.n === 1) { const [id, side] = edgeOf(s.wfaces[0]); if (sk.lines[id]) dimLine(id, false, side); else dimCurve(id, side); }
+  else if (edgePair(s)) applyCtxAction('edgeDist');
   else if (s.lines.length === 1 && s.n === 1) dimLine(s.lines[0], false);
   else if (s.curves.length === 1 && s.n === 1) dimCurve(s.curves[0]);
   else if (s.openings.length === 1 && s.n === 1) editOpeningDim(s.openings[0], 'w');
+  // a corner where two lines meet: its angle
+  else if (s.points.length === 1 && s.n === 1 && cornerLines(sk, s.points[0])) applyCtxAction('cornerAngle');
+  else if (s.n === 2 && s.oanchors.length) applyCtxAction('anchorDist');
   else if (s.n === 2 && (s.openings.length === 2 || (s.openings.length === 1 && s.points.length === 1))) applyCtxAction('opDist');
   // two things selected: the dimension between them
   else if (s.n === 2 && s.lines.length === 2) dimTwoLines(s.lines[0], s.lines[1]);
@@ -187,18 +336,20 @@ export function plusAction(): void {
 
 export function deleteSelection(): void {
   if (!ed.sel.length) return;
-  const items = ed.sel.slice(), sk = SK();
-  if (items.length === 1 && items.some(s => s.type === 'point' && sk.points[s.id] && sk.points[s.id].origin)) { toast('The origin can’t be deleted.'); return; }
-  // the image underlay isn't part of the sketch history, so its removal gets its own undo
-  const removed = items.some(s => s.type === 'underlay') ? page().underlay : null;
+  if (wallDelete()) return;
+  // (a wall's edge picked: the wall)
+  const sk = SK(), wallType = (id: string) => (sk.lines[id] ? 'line' as const : sk.circles[id] ? 'circle' as const : 'arc' as const);
+  const items = ed.sel.map(x => (x.type === 'wface' ? { type: wallType(edgeOf(x.id)[0]), id: edgeOf(x.id)[0] } : x)).filter((x, i, a) => a.findIndex(y => y.type === x.type && y.id === x.id) === i);
+  if (items.length === 1 && items.some(s => s.type === 'point' && sk.points[s.id] && sk.points[s.id].origin)) { toast('The origin can’t be deleted.', { warn: true }); return; }
+  // images are part of the page's undo history, so they go in the same step as the rest
+  const imgIds = new Set(items.filter(s => s.type === 'underlay').map(s => s.id));
   const rest = items.filter(s => s.type !== 'underlay');
-  if (removed) page().underlay = null;
-  if (rest.length) { pushHistory(); deleteSel(sk, rest); }
+  pushHistory();
+  if (imgIds.size) page().underlays = page().underlays.filter(u => !imgIds.has(u.id));
+  if (rest.length) deleteSel(sk, rest);
   ed.sel = [];
   afterEdit();
-  toast(removed && !rest.length ? 'Image removed' : 'Deleted', {
-    action: { label: 'Undo', fn: () => { if (rest.length) undo(); if (removed && !page().underlay) { page().underlay = removed; afterEdit(); } } },
-  });
+  toast(imgIds.size && !rest.length ? (imgIds.size > 1 ? 'Images removed' : 'Image removed') : 'Deleted', { action: { label: 'Undo', fn: () => undo() } });
 }
 
 function consFromSel(type: ConsType): Constraint | null {
@@ -255,7 +406,7 @@ function applyMulti(type: ConsType, list: Constraint[]): void {
     if (r.ok) added++;
     else if (r.conflict) failed.push(c);
   }
-  if (!added && !failed.length) { dropHistory(); toast('They’re already ' + ADJ[type] + '.'); afterEdit(); return; }
+  if (!added && !failed.length) { dropHistory(); toast('They’re already ' + ADJ[type] + '.', { warn: true }); afterEdit(); return; }
   if (!added) dropHistory();
   // every selected line that now satisfies it (some may already have, through other constraints)
   const lines = (type === 'h' || type === 'v' ? list.length : list.length + 1) - failed.length;
@@ -272,7 +423,7 @@ function applyCons(type: ConsType): void {
   const multi = multiLineCons(type);
   if (multi && (multi.length > 1 || selInfo().lines.length > 2)) { applyMulti(type, multi); return; }
   const c = consFromSel(type);
-  if (!c) { toast('Select ' + (NEEDS[type] || 'geometry') + ' first.'); return; }
+  if (!c) { toast('Select ' + (NEEDS[type] || 'geometry') + ' first.', { warn: true }); return; }
   pushHistory();
   const r = tryAddConstraint(c, { onResolved: () => afterEdit() });
   if (!r.ok) dropHistory();
@@ -282,10 +433,21 @@ function applyCons(type: ConsType): void {
 
 /** Run a bottom-bar action. `anchor` is the button pressed, for actions that open a popover next to it. */
 export function applyCtxAction(act: string, anchor?: unknown): void {
+  if (wallAction(act)) return;
   const sk = SK(), s = selInfo();
   switch (act) {
     case 'fit': fitView(); return;
-    case 'elev': if (s.lines.length === 1) openElevation(s.lines[0]); return;
+    case 'elev':
+      if (s.lines.length === 1) openElevation(s.lines[0]);
+      // (an edge: seen from that face)
+      else if (s.wfaces.length === 1 && sk.lines[edgeOf(s.wfaces[0])[0]]) openElevation(...edgeOf(s.wfaces[0]));
+      return;
+    case 'edgeDist': dimEdges(ed.sel, id => thicknessPrompt([sk.lines[id] ?? sk.circles[id] ?? sk.arcs[id]])); return;
+    case 'dimFace0': case 'dimFace1': case 'dimFace2': {
+      const ch = s.dims.length === 1 && sk.cons[s.dims[0]] ? faceChoices(sk, sk.cons[s.dims[0]])[+act.slice(7)] : undefined;
+      if (ch) setDimFace(s.dims[0], ch);
+      return;
+    }
     case 'grid': settings.snapGrid = !settings.snapGrid; break;
     case 'autocons':
       settings.autoCons = !settings.autoCons;
@@ -299,25 +461,25 @@ export function applyCtxAction(act: string, anchor?: unknown): void {
     case 'dimPrint': ed.dimLayer = 'print'; break;
     case 'h': case 'v': case 'par': case 'perp': case 'col': case 'eq': case 'mid': case 'online': case 'oncircle': case 'tan': case 'eqr': case 'conc':
       applyCons(act); return;
-    case 'len': if (s.lines.length === 1) dimLine(s.lines[0], false); return;
+    case 'len':
+      if (s.lines.length === 1) dimLine(s.lines[0], false);
+      else if (s.wfaces.length === 1 && sk.lines[edgeOf(s.wfaces[0])[0]]) { const [lid, side] = edgeOf(s.wfaces[0]); dimLine(lid, false, side); }
+      return;
     case 'pdist': if (s.points.length === 2) dimPoints(s.points[0], s.points[1], false); return;
     case 'pldist': if (s.points.length === 1 && s.lines.length === 1) dimPointLine(s.points[0], s.lines[0]); return;
     case 'diam': if (s.curves.length === 1) dimCurve(s.curves[0]); return;
-    case 'angle': if (s.lines.length === 2) dimAngle(s.lines[0], s.lines[1]); return;
-    case 'cornerAngle': {
-      const pair = cornerLines(sk, s.points[0]);
-      if (!pair) return;
-      // 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); else dimAngle(pair[0], pair[1]);
+    case 'fillet': case 'chamfer': {
+      const p = s.points.length === 1 ? s.points[0] : filletCorner2();
+      if (p) (act === 'fillet' ? filletPrompt : chamferPrompt)(p);
       return;
     }
+    case 'cornerAngle': cornerAngle(s.points[0]); return;
     case 'merge': {
       pushHistory();
       const snap = JSON.stringify(sk);
-      if (mergePoints(sk, s.points[0], s.points[1])) {
+      if (joinPoints(sk, s.points[0], s.points[1])) {
         const r = solveSketch();
-        if (!r.ok) { page().sk = JSON.parse(snap) as Sketch; dropHistory(); toast('Can’t join those points — it conflicts with other constraints.', { warn: true }); }
+        if (!r.ok) { replaceSK(JSON.parse(snap) as Sketch); dropHistory(); toast('Can’t join those points — it conflicts with other constraints.', { warn: true }); }
         else { ed.sel = [{ type: 'point', id: s.points[0] }]; toast('Points joined'); }
       }
       afterEdit();
@@ -343,7 +505,7 @@ export function applyCtxAction(act: string, anchor?: unknown): void {
     }
     case 'constr':
       pushHistory();
-      s.lines.forEach(id => (sk.lines[id].constr = !sk.lines[id].constr));
+      s.lines.forEach(id => { if (!sk.lines[id].anchor) sk.lines[id].constr = !sk.lines[id].constr; });
       s.curves.forEach(id => { const ci = curveInfo(sk, id); if (ci) ci.o.constr = !ci.o.constr; });
       afterEdit();
       return;
@@ -353,24 +515,34 @@ export function applyCtxAction(act: string, anchor?: unknown): void {
       if (!targets.length) return;
       const toWall = !targets.every(t => t.kind === 'wall');
       pushHistory();
-      targets.forEach(t => { t.kind = toWall ? 'wall' : 'line'; t.thick = t.thick || 4.5; });
+      targets.forEach(t => { t.kind = toWall ? 'wall' : 'line'; t.thick = t.thick || 4.5; if (toWall && (t as { constr?: boolean }).constr) (t as { constr?: boolean }).constr = false; });
+      // made lines: what was measured on their faces is measured as they are now (nothing moves); the walls beside
+      // them keep theirs
+      if (!toWall) {
+        const ids = new Set([...s.lines, ...s.curves]);
+        for (const c of Object.values(sk.cons)) {
+          if (c.type === 'dist' && c.face && c.line && ids.has(c.line)) { delete c.face; if (c.driving !== false) c.value = measure(sk, c); }
+          if (c.type === 'diam' && c.face && c.c && ids.has(c.c)) { delete c.face; if (c.driving !== false) c.value = measure(sk, c); }
+          if (c.type === 'pldist' && c.faces && ((c.l && ids.has(c.l)) || (c.l2 && ids.has(c.l2)))) {
+            if (c.driving !== false) c.value = measure(sk, c);
+            if (c.faces[0] && c.l && ids.has(c.l)) c.faces = [0, c.faces[1]];
+            if (c.faces[1] && c.l2 && ids.has(c.l2)) c.faces = [c.faces[0], 0];
+            if (!c.faces[0] && !c.faces[1]) delete c.faces;
+          }
+        }
+      }
+      holdFaces();
       afterEdit();
       toast(targets.length > 1 ? (toWall ? targets.length + ' items are now walls' : targets.length + ' items are now lines') : toWall ? 'Now a wall' : 'Now a line');
       return;
     }
-    case 'thick': {
+    case 'thick':
       // straight and curved walls in the selection
-      const walls: { thick?: number }[] = [
+      thicknessPrompt([
         ...s.lines.map(id => sk.lines[id]).filter(l => l.kind === 'wall'),
         ...s.curves.map(id => curveInfo(sk, id)?.o).filter((o): o is NonNullable<typeof o> => !!o && o.kind === 'wall'),
-      ];
-      if (!walls.length) return;
-      openKeypad({
-        title: 'Wall thickness', sub: 'Finished face to face', initial: fmtLen(walls[0].thick || 4.5), selectAll: true,
-        onDone: v => { if (v <= 0) return; pushHistory(); walls.forEach(w => (w.thick = v)); afterEdit(); },
-      });
+      ]);
       return;
-    }
     case 'eqall': {
       // lines mixed with other things: equal across just the lines
       if (s.lines.length < 2) return;
@@ -395,20 +567,57 @@ export function applyCtxAction(act: string, anchor?: unknown): void {
       }
       return;
     }
+    case 'anchorDist': {
+      // from one end of a door or window to a point, another end, or another door or window (its nearer end): the
+      // second one picked is placed from the first (the other way round if that would tie them in a loop)
+      const end = (id: string) => { const [op, edge] = id.split('|'); return { op, edge: edge as OpeningEdge }; };
+      const [first, second] = ed.sel;
+      if (!first || !second) return;
+      if (first.type === 'point' || second.type === 'point') {
+        const e = end((first.type === 'oanchor' ? first : second).id), pt = (first.type === 'point' ? first : second).id;
+        addOpeningDim(e.op, e.edge, { pt });
+        return;
+      }
+      const nearer = (op: string, from: { op: string; edge: OpeningEdge }): OpeningEdge => {
+        const p = edgePoint(sk, from.op, from.edge), a = edgePoint(sk, op, 's0'), b = edgePoint(sk, op, 's1');
+        return !p || !a || !b || Math.hypot(a.x - p.x, a.y - p.y) <= Math.hypot(b.x - p.x, b.y - p.y) ? 's0' : 's1';
+      };
+      let a = first.type === 'oanchor' ? end(first.id) : null, b = second.type === 'oanchor' ? end(second.id) : null;
+      if (!a) a = { op: first.id, edge: nearer(first.id, b!) };
+      if (!b) b = { op: second.id, edge: nearer(second.id, a) };
+      if (a.op !== b.op && createsCycle(sk, b.op, { op: a.op, edge: a.edge })) [a, b] = [b, a];
+      addOpeningDim(b.op, b.edge, { op: a.op, edge: a.edge });
+      return;
+    }
     case 'palette': openPalette(anchor); return;
     case 'convert': convertNote(s.notes[0]); return;
+    case 'linkOpen': openSelectedLink(); return;
+    case 'linkSize': toggleTileSize(anchor); return;
+    case 'dimLinkOpen': if (s.dims.length === 1) openDimLink(s.dims[0]); return;
+    case 'dimUnlink': if (s.dims.length === 1) unlinkDim(s.dims[0]); return;
+    case 'dimSave': if (s.dims.length === 1) void saveDimToGroup(s.dims[0]); return;
+    case 'linkLeader': if (s.notes.length === 1) toggleLeader(s.notes[0]); return;
     case 'calibtool': setTool('calib'); return;
     case 'toggleUnderlay':
       settings.layers.underlay = !settings.layers.underlay;
       if (!settings.layers.underlay) ed.sel = ed.sel.filter(x => x.type !== 'underlay');
       break;
     case 'imgLock': {
-      const u = page().underlay;
-      if (!u) return;
+      const ims = selImages();
+      if (!ims.length) return;
+      const lock = !ims.every(u => u.locked), many = ims.length > 1;
       pushHistory();
-      u.locked = !u.locked;
+      ims.forEach(u => { u.locked = lock; });
       afterEdit();
-      toast(u.locked ? 'Image locked. It won’t move while you trace over it.' : 'Image unlocked. Drag it, or drag its handles to size it.');
+      toast(lock ? (many ? 'Images locked. They won’t move while you trace over them.' : 'Image locked. It won’t move while you trace over it.')
+        : many ? 'Images unlocked.' : 'Image unlocked. Drag it, or drag its handles to size it.');
+      return;
+    }
+    case 'imgOpacity': toggleImageOpacity(anchor); return;
+    case 'imgRotate': toggleImageRotation(anchor); return;
+    case 'imgFront': case 'imgBack': {
+      const ims = selImages();
+      if (ims.length === 1) restackImage(ims[0].id, act === 'imgFront' ? 'front' : 'back');
       return;
     }
   }