@reekon-tools/boldr-cad 0.1.0 → 1.0.0

package/dist/editor/actions.js

@@ -1,28 +1,36 @@
-import { afterEdit, solveSketch, tryAddConstraint, undo } from '../app/edit';
+import { afterEdit, holdFaces, solveSketch, tryAddConstraint, undo } from '../app/edit';
 import { ed } 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 { connectedGeometry, curveInfo, deleteSel, joinPoints } from '../model/sketch';
+import { page, planSK, replaceSK, saveSoon, SK } from '../model/store';
 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 { 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';
 /** Points a Lock on the current selection would pin (the origin is always fixed). */
 function lockTargets() {
     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);
 }
 /**
  * Lock is always the first action, set off by a divider, and shows its state:
@@ -34,7 +42,7 @@ function arrangeLock(items) {
         return items;
     const it = items[i];
     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 = [it];
@@ -48,11 +56,21 @@ function arrangeLock(items) {
         out.pop();
     return out;
 }
+/** What the bar calls one end of a door or window. */
+function anchorLabel(id) {
+    return (planSK().openings[id.split('|')[0]]?.type === 'door' ? 'Door' : 'Window') + ' edge';
+}
+/** The selected images. */
+const selImages = () => ed.sel.filter(x => x.type === 'underlay').map(x => imageById(x.id)).filter((u) => !!u);
+/** 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() {
     const items = [], sk = SK(), s = selInfo();
     const add = (ic, label, act, o = {}) => 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;
@@ -64,52 +82,118 @@ function ctxItems() {
             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)
+            if (ims.length === 1 && !ims[0].locked)
                 add('calib', 'Set scale', 'calibtool');
-            add('eye', 'Hide image', 'toggleUnderlay');
+            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');
+            if (linkSizeVisible())
+                add('tilesize', 'Size', 'linkSize');
         }
-        else {
-            add('color', 'Color', 'palette');
-            if (page().underlay) {
-                add('calib', 'Scale', 'calibtool');
-                add('eye', settings.layers.underlay ? 'Hide image' : 'Show image', 'toggleUnderlay');
-            }
-        }
+        // 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].st;
-        if (st.start) {
-            add('typelen', 'Type length', 'typelen');
-            if (st.chain.length >= 3)
-                add('closeShape', 'Close', 'closeShape');
-            add('finish', 'Finish', 'finish');
+        // 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')
+    // 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')
+        // 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.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) {
@@ -125,53 +209,82 @@ function ctxItems() {
         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')
+        // 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('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');
-        }
+        if (l.constr)
+            add('constr', 'Solid', 'constr');
         else
-            add('wall', 'To wall', 'kind');
-        if (l.kind === 'wall' && !l.constr) {
-            items.push('sep');
-            add('elev', 'Elevation', 'elev');
+            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) {
+        // (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' });
-        add('angle', 'Angle', 'angle');
+        // 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;
     }
@@ -200,7 +313,9 @@ function ctxItems() {
     // 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');
@@ -223,40 +338,91 @@ function ctxItems() {
         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');
+        guide();
         wallItems();
         return items;
     }
     if (L >= 2) {
         add('eq', 'Equal', 'eqall');
-        add('chain', 'Connected', 'chain');
         add('lock', 'Lock', 'lock');
-        add('constr', 'Guide', 'constr');
+        guide();
         wallItems();
         return items;
     }
     add('lock', 'Lock', 'lock');
     return items;
 }
+/** The keypad for walls' thickness, finished face to face. */
+function thicknessPrompt(walls) {
+    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() {
+    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 = () => 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() {
+    // 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 = () => (ed.mode === 'annotate' ? 'Add a note' : 'Add a measurement');
-/** The yellow +: a note in Annotate; otherwise the measurement that fits the selection (opens the keypad). */
+export const plusLabel = () => 'Add a measurement';
+/** The yellow +: the measurement that fits the selection (opens the keypad). */
 export function plusAction() {
-    if (ed.mode === 'annotate') {
-        setTool('text');
+    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.');
+            toast('Print dimensions are labels only — drag to move them.', { warn: true });
         else
             editDim(s.dims[0]);
     }
@@ -264,12 +430,28 @@ export function plusAction() {
         const [op, part] = s.odims[0].split('|');
         editOpeningDim(op, part);
     }
+    // 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
@@ -285,29 +467,26 @@ export function plusAction() {
 export function deleteSelection() {
     if (!ed.sel.length)
         return;
-    const items = ed.sel.slice(), sk = SK();
+    if (wallDelete())
+        return;
+    // (a wall's edge picked: the wall)
+    const sk = SK(), wallType = (id) => (sk.lines[id] ? 'line' : sk.circles[id] ? 'circle' : 'arc');
+    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.');
+        toast('The origin can’t be deleted.', { warn: true });
         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;
+    // 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();
+    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) {
     const sk = SK(), s = selInfo(), L = s.lines.map(id => sk.lines[id]);
@@ -376,7 +555,7 @@ function applyMulti(type, list) {
     }
     if (!added && !failed.length) {
         dropHistory();
-        toast('They’re already ' + ADJ[type] + '.');
+        toast('They’re already ' + ADJ[type] + '.', { warn: true });
         afterEdit();
         return;
     }
@@ -403,7 +582,7 @@ function applyCons(type) {
     }
     const c = consFromSel(type);
     if (!c) {
-        toast('Select ' + (NEEDS[type] || 'geometry') + ' first.');
+        toast('Select ' + (NEEDS[type] || 'geometry') + ' first.', { warn: true });
         return;
     }
     pushHistory();
@@ -416,6 +595,8 @@ function applyCons(type) {
 }
 /** Run a bottom-bar action. `anchor` is the button pressed, for actions that open a popover next to it. */
 export function applyCtxAction(act, anchor) {
+    if (wallAction(act))
+        return;
     const sk = SK(), s = selInfo();
     switch (act) {
         case 'fit':
@@ -424,7 +605,21 @@ export function applyCtxAction(act, anchor) {
         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;
@@ -470,6 +665,10 @@ export function applyCtxAction(act, anchor) {
         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)
@@ -483,29 +682,23 @@ export function applyCtxAction(act, anchor) {
             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);
+                    replaceSK(JSON.parse(snap));
                     dropHistory();
                     toast('Can’t join those points — it conflicts with other constraints.', { warn: true });
                 }
@@ -544,7 +737,8 @@ export function applyCtxAction(act, anchor) {
         }
         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();
@@ -556,26 +750,47 @@ export function applyCtxAction(act, anchor) {
                 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.constr)
+                t.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 = [
+            thicknessPrompt([
                 ...s.lines.map(id => sk.lines[id]).filter(l => l.kind === 'wall'),
                 ...s.curves.map(id => curveInfo(sk, id)?.o).filter((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)
@@ -620,12 +835,60 @@ export function applyCtxAction(act, anchor) {
             }
             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) => { const [op, edge] = id.split('|'); return { op, edge: edge }; };
+            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, from) => {
+                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;
@@ -635,13 +898,28 @@ export function applyCtxAction(act, anchor) {
                 ed.sel = ed.sel.filter(x => x.type !== 'underlay');
             break;
         case 'imgLock': {
-            const u = page().underlay;
-            if (!u)
+            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;
         }
     }