@reekon-tools/boldr-cad 1.4.0 → 1.6.0

package/dist/editor/actions.js

@@ -1,14 +1,14 @@
 import { afterEdit, holdFaces, solveSketch, tryAddConstraint, undo } from '../app/edit';
 import { ed } from '../app/state';
-import { CONS_LABEL, measure } from '../model/constraints';
+import { CONS_LABEL, consLabel, measure } from '../model/constraints';
 import { dropHistory, pushHistory } from '../model/history';
-import { createsCycle, edgePoint, facingEdges, nearerEdge } from '../model/openings';
+import { createsCycle, edgePoint, facingEdges, flipDoor, nearerEdge } from '../model/openings';
+import { roomSideOf } from '../model/elevation';
 import { cabOfPoint } from '../model/faces';
 import { settings } from '../model/settings';
 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 { 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';
@@ -17,40 +17,49 @@ import { chamferPrompt } from '../tools/chamfer';
 import { addOpeningDim, editOpeningDim, toggleOpeningDim } from '../tools/openings';
 import { setTool, tools } from '../tools/registry';
 import { fmtLen } from '../units';
-import { elevOpen, fitState, OPENING_SIZES, openElevation, openingLabel, overflow, restoreFit, TOO_SHORT, wallAction, wallBar, wallDelete, wallPlus } from './elevation';
+import { elevOpen, fitState, OPENING_SIZES, openElevation, 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 { dismissPopovers, 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';
+import { canExpand, canOpenLink, canSaveDim, linkSizeVisible, openDimLink, openSelectedLink, saveDimToGroup, selectedLink, toggleExpand, toggleLeader, unlinkDim } from './linkActions';
+/** A bar button shown as its icon alone, no name under it (the lead, and Lock). */
+export const iconAlone = (it) => !!(it.lead || it.bare);
 /** 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); });
+    // (a straight wall's edge: its wall, as if picked whole)
+    withEdges(sk, s).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 && !sk.points[id].anchor);
 }
 /**
- * Lock is always the first action, set off by a divider, and shows its state:
- * open padlock "Lock" (white) when free, closed padlock "Locked" (red) when locked.
+ * The bar leads with one button, its icon alone, set off by a divider (Figma's bars, 2528:101128: the user's call,
+ * 2026-10-27): Open, when what's selected is a link to something of the job's; otherwise Lock — an open padlock (white)
+ * when free, a closed one (red, "Locked") when locked. A link that can be locked too (an expanded photo) has Lock next,
+ * with a divider of its own. Lock is its icon alone wherever it is, locked or not (the user's call, 2026-10-30: "only
+ * display the icon - no text needed below it").
  */
-function arrangeLock(items) {
-    const i = items.findIndex(it => typeof it === 'object' && 'act' in it && (it.act === 'lock' || it.act === 'imgLock'));
-    if (i < 0)
-        return items;
-    const it = items[i];
-    const sk = SK();
-    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];
-    if (rest.length)
-        out.push('sep');
-    // tidy separators: none doubled, none leading or trailing
-    for (const e of rest)
-        if (!(e === 'sep' && (out[out.length - 1] === 'sep')))
+function arrangeLead(items) {
+    const find = (acts) => items.find((it) => typeof it === 'object' && 'act' in it && acts.includes(it.act));
+    const open = find(['linkOpen', 'dimLinkOpen']), lock = find(['lock', 'imgLock']);
+    if (lock) {
+        const sk = SK();
+        const locked = lock.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(lock, { ic: locked ? 'lock' : 'unlock', label: locked ? 'Locked' : 'Lock', on: undefined, locked, bare: true });
+    }
+    const lead = open ?? lock, out = [];
+    if (lead) {
+        lead.lead = true;
+        out.push(lead, 'sep');
+        if (open && lock)
+            out.push(lock, 'sep');
+    }
+    // the rest, with no divider doubled, first or last
+    for (const e of items)
+        if (e !== lead && !(open && e === lock) && !(e === 'sep' && (!out.length || out[out.length - 1] === 'sep')))
             out.push(e);
     while (out[out.length - 1] === 'sep')
         out.pop();
@@ -67,32 +76,27 @@ 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;
-        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') {
         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 (ims.length === 1 && !ims[0].locked)
+            // a photo of the job's, expanded from its tile: opening it, and Expand (on) to fold it back into its tile
+            const lk = ims.length === 1 ? ims[0].link : undefined;
+            if (lk && canOpenLink(lk))
+                add('open', 'Open', 'linkOpen');
+            // locked: unlocking it, and opening what it's a photo of — nothing that changes it (the user's call,
+            // 2026-10-30: "images in locked state: shouldn't have these options - only lock and link should be available")
+            if (ims.every(u => u.locked))
+                return items;
+            if (lk)
+                add('expand', 'Expand', 'linkExpand', { on: true });
+            if (ims.length === 1)
                 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)
+            if (ims.length === 1)
                 add('rotate', 'Rotate', 'imgRotate');
             if (ims.length === 1 && page().underlays.length > 1) {
                 const at = page().underlays.indexOf(ims[0]), last = page().underlays.length - 1;
@@ -108,20 +112,19 @@ function ctxItems() {
             // 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');
+            // (a photo's: the photo whole, as one of the page's images)
+            if (canExpand(lk))
+                add('expand', 'Expand', 'linkExpand', { on: false });
             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]);
-            if (n && n.type === 'pen' && s.notes.length === 1)
-                add('convert', 'To lines', 'convert');
-            if (linkSizeVisible())
-                add('tilesize', 'Size', 'linkSize');
-        }
+        // markup: nothing of its own — a pen stroke as any other (no To lines: the user's call, 2026-10-27), and no Color
+        // (the rail's colour dot styles what's selected); with tiles among it, their size
+        if (s.notes.length && 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;
@@ -143,11 +146,6 @@ function ctxItems() {
             add('finish', 'Finish', 'finish');
         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).
     // 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)))
@@ -161,15 +159,41 @@ function ctxItems() {
             add(it.ic, it.label, it.act);
         return items;
     }
+    /*
+      Figma's bars (2528:101128, the user's call, 2026-10-27): Lock first, its icon alone (arrangeLead); then what the lines
+      and curves are (kind); then what ties them, or edits them. The yellow + measures: no Distance of its own here.
+    */
     // 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)
+    /**
+     * What the selected lines and curves are, and its divider: walls — one straight wall's wall view, and their Thickness;
+     * otherwise To wall, and Guide (Solid, when they all are guides). A wall is always solid, so with one among them
+     * there's no Guide (the user's call, 2026-11-03: a wall and a line picked together offered it) — only Solid, for a
+     * wall that's a guide from before; on a wall face, Guide alone. `walls`: the walls of picked edges, as if picked whole.
+     */
+    const kind = (walls = []) => {
+        const objs = [...s.lines.map(id => sk.lines[id]), ...walls.map(id => sk.lines[id]), ...s.curves.map(id => curveInfo(sk, id)?.o)].filter((o) => !!o);
+        if (!objs.length)
+            return;
+        if (objs.every(o => o.kind === 'wall')) {
+            if (wall)
+                return;
+            if (s.n === 1 && L === 1)
+                add('elev', 'Elevation', 'elev');
+            add('thick', 'Thickness', 'thick');
+            if (objs.some(o => o.constr))
+                add('constr', 'Solid', 'constr');
+        }
+        else {
+            if (!wall)
+                add('wall', 'To wall', 'kind');
+            if (!objs.some(o => o.kind === 'wall'))
+                add('constr', objs.every(o => o.constr) ? 'Solid' : 'Guide', 'constr');
+        }
+        items.push('sep');
+    };
+    // a wall's edge: named, with its wall view (with another edge, a line or a point, the + is the distance between them)
     if (s.wfaces.length) {
         // (a curved wall has no wall view: just its name)
         if (s.n === 1) {
@@ -178,16 +202,34 @@ function ctxItems() {
             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');
+        else if (s.n === 2 && straightEdges(sk, s).length === s.wfaces.length) {
+            /*
+              A straight wall's edge with a point or a line: the bar the wall picked whole has (the user's call, 2026-11-03:
+              "add equal, lock, and to wall to both bottom bars"), each acting on what's picked — the point On face; Parallel
+              and Perpendicular, the wall (a face runs with its centreline); Collinear, the line along the face (both its ends
+              on it); Equal, the face's length, corner to corner. (Two edges: no Collinear — their faces flush is another thing.)
+            */
+            // (the two edges of one wall: nothing but the + — its thickness)
+            const pair = new Set(withEdges(sk, s)).size === 2;
+            if (P === 1 || pair)
+                add('lock', 'Lock', 'lock', { key: '⇧F' });
+            if (P === 1)
+                add('online', 'On face', 'online', { key: '⇧O' });
+            else if (pair) {
+                kind(straightEdges(sk, s).map(([id]) => id));
+                add('par', 'Parallel', 'par', { key: '⇧P' });
+                add('perp', 'Perpendicular', 'perp', { key: '⇧R' });
+                if (L === 1)
+                    add('col', 'Collinear', 'col', { key: '⇧L' });
+                add('eq', 'Equal', 'eq', { key: '⇧E' });
+            }
         }
         return items;
     }
     if (s.n === 1 && s.dims.length) {
         const c = sk.cons[s.dims[0]];
         // 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)
+        // call, 2026-10-21; its chip is drawn linked)
         if (c.measurementRef) {
             const t = c.measurementRef;
             if (canOpenLink(t))
@@ -196,10 +238,7 @@ function ctxItems() {
         }
         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');
+        // (no Reference: Figma's dimension bars have none, 2026-10-27)
         // 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)
@@ -220,96 +259,71 @@ 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
+    // one end of a door or window: named (with another point, end or door/window, the + is 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');
+    if (s.oanchors.length || (s.n === 2 && (s.openings.length === 2 || (s.openings.length === 1 && s.points.length === 1))))
         return items;
-    }
     if (s.n === 1 && s.openings.length) {
-        // 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) });
+        // its sizes (no +: it isn't one dimension), with nothing saying them — the drawing does (the user's call, 2026-10-27);
+        // a door's Swing too, round its four ways (it was Flip: the user's call, 2026-10-27, "ok do swing instead"). (The
+        // type is fixed once placed: Door and Window are separate tools.)
         for (const it of OPENING_SIZES)
             add(it.ic, it.label, it.act);
-        if (o.type === 'door') {
+        if (sk.openings[s.openings[0]].type === 'door') {
             items.push('sep');
-            add('flip', 'Flip', 'opFlip');
+            add('flip', 'Swing', 'opFlip');
         }
         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;
+    add('lock', 'Lock', 'lock', { key: '⇧F' });
     if (L === 1 && s.n === 1) {
-        const l = sk.lines[s.lines[0]];
+        kind();
+        // (its length: the yellow +)
         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('v', 'Vertical', 'v', { key: '⇧V' });
         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) {
-        // (no Angle here: the yellow + is the angle between them — or, parallel, the distance)
+        // (no Angle: the yellow + is the angle between them — or, parallel, the distance)
+        kind();
         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()) {
+            items.push('sep');
             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;
+    // a corner where exactly two lines meet: rounding it off or cutting it off (its angle is the yellow +)
     if (P === 1 && s.n === 1) {
-        // 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;
     }
-    if (P === 2 && s.n === 2) {
+    // points: joined into the first picked, or level or plumb with it
+    if (P >= 2 && s.n === P) {
+        add('merge', 'Join', 'merge');
         add('h', 'Horizontal', 'h');
         add('v', 'Vertical', 'v');
-        add('dim', 'Distance', 'pdist');
-        add('merge', 'Join', 'merge');
         return items;
     }
     if (P === 1 && L === 1 && s.n === 2) {
-        add('mid', 'Midpoint', 'mid', { key: '⇧M' });
         add('online', 'On line', 'online', { key: '⇧O' });
-        add('dim', 'Distance', 'pldist');
+        add('mid', 'Midpoint', 'mid', { key: '⇧M' });
         return items;
     }
     if (P === 1 && C === 1 && s.n === 2) {
@@ -317,51 +331,35 @@ function ctxItems() {
         return items;
     }
     if (L === 1 && C === 1 && s.n === 2) {
+        kind();
         add('tan', 'Tangent', 'tan', { key: '⇧T' });
-        wallItems();
         return items;
     }
     // a circle or arc: the yellow + sets its diameter
     if (C === 1 && s.n === 1) {
-        const ci = curveInfo(sk, s.curves[0]);
-        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');
+        kind();
         return items;
     }
     if (C === 2 && s.n === 2) {
-        add('eq', 'Equal', 'eqr');
+        kind();
         add('conc', 'Concentric', 'conc');
-        wallItems();
+        add('eq', 'Equal', 'eqr');
         return items;
     }
     // 3+ lines (only lines): the constraints that make sense across many, each tied to the first line picked
     if (L >= 3 && s.n === L) {
+        kind();
         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('lock', 'Lock', 'lock');
-        guide();
-        wallItems();
         return items;
     }
     if (L >= 2) {
+        kind();
         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. */
@@ -400,7 +398,7 @@ function filletCorner2() {
     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());
+export const barItems = () => arrangeLead(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() {
@@ -431,12 +429,8 @@ export function plusAction() {
     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.', { warn: true });
-        else
-            editDim(s.dims[0]);
-    }
+    if (s.dims.length === 1 && s.n === 1)
+        editDim(s.dims[0]);
     else if (s.odims.length === 1 && s.n === 1) {
         const [op, part] = s.odims[0].split('|');
         editOpeningDim(op, part);
@@ -446,14 +440,14 @@ export function plusAction() {
     else if (s.wfaces.length === 1 && s.n === 1) {
         const [id, side] = edgeOf(s.wfaces[0]);
         if (sk.lines[id])
-            dimLine(id, false, side);
+            dimLine(id, 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);
+        dimLine(s.lines[0]);
     else if (s.curves.length === 1 && s.n === 1)
         dimCurve(s.curves[0]);
     else if (s.openings.length === 1 && s.n === 1)
@@ -469,7 +463,7 @@ export function plusAction() {
     else if (s.n === 2 && s.lines.length === 2)
         dimTwoLines(s.lines[0], s.lines[1]);
     else if (s.n === 2 && s.points.length === 2)
-        dimPoints(s.points[0], s.points[1], false);
+        dimPoints(s.points[0], s.points[1]);
     else if (s.n === 2 && s.points.length === 1 && s.lines.length === 1)
         dimPointLine(s.points[0], s.lines[0]);
     else
@@ -499,6 +493,10 @@ export function deleteSelection() {
     afterEdit();
     toast(imgIds.size && !rest.length ? (imgIds.size > 1 ? 'Images removed' : 'Image removed') : 'Deleted', { action: { label: 'Undo', fn: () => undo() } });
 }
+/** The picked edges of straight walls, as [wall, side] (a curved wall's edge has no line to stand for it). */
+const straightEdges = (sk, s) => s.wfaces.map(edgeOf).filter(([id]) => !!sk.lines[id]);
+/** The picked lines, and the walls of the picked straight edges. */
+const withEdges = (sk, s) => [...s.lines, ...straightEdges(sk, s).map(([id]) => id)];
 function consFromSel(type) {
     const sk = SK(), s = selInfo(), L = s.lines.map(id => sk.lines[id]);
     switch (type) {
@@ -510,13 +508,28 @@ function consFromSel(type) {
                 return { type, a: s.points[0], b: s.points[1] };
             return null;
         case 'par':
-        case 'perp':
+        case 'perp': {
+            // (a wall's edge: its wall — the same thing, square to something)
+            const ls = withEdges(sk, s);
+            return ls.length === 2 && ls[0] !== ls[1] ? { type, l1: ls[0], l2: ls[1] } : null;
+        }
         case 'col':
-        case 'eq':
             return s.lines.length === 2 ? { type, l1: s.lines[0], l2: s.lines[1] } : null;
+        case 'eq': {
+            // (a wall's edge: that face's length, corner to corner)
+            const ls = withEdges(sk, s), f = straightEdges(sk, s);
+            if (ls.length !== 2 || ls[0] === ls[1])
+                return null;
+            return f.length ? { type, l1: ls[0], l2: ls[1], faces: ls.map((_, i) => (i < s.lines.length ? 0 : f[i - s.lines.length][1])) } : { type, l1: ls[0], l2: ls[1] };
+        }
         case 'mid':
-        case 'online':
+        case 'online': {
+            // (a point and a wall's edge: on that face)
+            const f = straightEdges(sk, s);
+            if (type === 'online' && s.n === 2 && s.points.length === 1 && f.length === 1)
+                return { type, p: s.points[0], l: f[0][0], face: f[0][1] };
             return s.points.length === 1 && s.lines.length === 1 ? { type, p: s.points[0], l: s.lines[0] } : null;
+        }
         case 'oncircle':
             return s.points.length === 1 && s.curves.length === 1 ? { type, p: s.points[0], c: s.curves[0] } : null;
         case 'tan': {
@@ -540,9 +553,14 @@ const NEEDS = {
     h: 'a line or two points', v: 'a line or two points', par: 'two lines', perp: 'two lines', col: 'two lines', eq: 'two lines', mid: 'a point and a line',
     online: 'a point and a line', oncircle: 'a point and a circle', tan: 'a line and a circle or arc', eqr: 'two circles', conc: 'two circles',
 };
-/** H/V on each selected line, or parallel/collinear/equal from the first selected line to each of the others. */
+/**
+ * H/V on each selected line, or parallel/collinear/equal from the first selected line to each of the others; three
+ * or more points, each level or plumb with the first picked.
+ */
 function multiLineCons(type) {
     const sk = SK(), s = selInfo();
+    if ((type === 'h' || type === 'v') && s.n === s.points.length && s.points.length >= 3)
+        return s.points.slice(1).map(id => ({ type, a: s.points[0], b: id }));
     if (s.n !== s.lines.length || s.lines.length < (type === 'h' || type === 'v' ? 2 : 3))
         return null;
     if (type === 'h' || type === 'v')
@@ -552,8 +570,11 @@ function multiLineCons(type) {
     return null;
 }
 const ADJ = { h: 'horizontal', v: 'vertical', par: 'parallel', col: 'collinear', eq: 'equal' };
-/** Apply one constraint type across several lines as one undo step. A conflict opens the conflict sheet for the first one that fails. */
-function applyMulti(type, list) {
+/**
+ * Apply one constraint type across several lines (or `points`, each tied to the first) as one undo step. A conflict
+ * opens the conflict sheet for the first one that fails.
+ */
+function applyMulti(type, list, points = false) {
     pushHistory();
     let added = 0;
     const failed = [];
@@ -572,9 +593,9 @@ function applyMulti(type, list) {
     }
     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;
-    const nLines = lines + ' line' + (lines === 1 ? '' : 's');
+    // every selected line (or point) that now satisfies it (some may already have, through other constraints)
+    const lines = ((type === 'h' || type === 'v') && !points ? list.length : list.length + 1) - failed.length;
+    const nLines = lines + (points ? ' point' : ' line') + (lines === 1 ? '' : 's');
     if (failed.length) {
         // explain the first conflict; the sheet's Remove re-applies it
         tryAddConstraint(failed[0], { onResolved: () => afterEdit() });
@@ -585,10 +606,49 @@ function applyMulti(type, list) {
         toast(CONS_LABEL[type] + ' added to ' + nLines + '.');
     afterEdit();
 }
+/** A line and a straight wall's edge picked: the line along that face, both its ends on it (Collinear, with a face). */
+function alongFace() {
+    const sk = SK(), s = selInfo(), f = straightEdges(sk, s);
+    if (s.n !== 2 || s.lines.length !== 1 || f.length !== 1 || f[0][0] === s.lines[0])
+        return null;
+    const [l, face] = f[0], ln = sk.lines[s.lines[0]];
+    return [ln.a, ln.b].map(p => ({ type: 'online', p, l, face }));
+}
+/** A line along a face (alongFace), as one undo step: its ends on it, or the conflict sheet for the first that can't be. */
+function applyAlong(list) {
+    pushHistory();
+    let added = 0;
+    const failed = [];
+    for (const c of list) {
+        const r = tryAddConstraint(c, { silent: true });
+        if (r.ok)
+            added++;
+        else if (r.conflict)
+            failed.push(c);
+    }
+    if (!added && !failed.length) {
+        dropHistory();
+        toast('It’s already along that face.', { warn: true });
+        afterEdit();
+        return;
+    }
+    if (!added)
+        dropHistory();
+    if (failed.length)
+        tryAddConstraint(failed[0], { onResolved: () => afterEdit() });
+    else
+        toast(CONS_LABEL.col + ' added');
+    afterEdit();
+}
 function applyCons(type) {
-    const multi = multiLineCons(type);
-    if (multi && (multi.length > 1 || selInfo().lines.length > 2)) {
-        applyMulti(type, multi);
+    const along = type === 'col' ? alongFace() : null;
+    if (along) {
+        applyAlong(along);
+        return;
+    }
+    const multi = multiLineCons(type), s = selInfo(), points = s.points.length > 2 && s.n === s.points.length;
+    if (multi && (multi.length > 1 || s.lines.length > 2 || points)) {
+        applyMulti(type, multi, points);
         return;
     }
     const c = consFromSel(type);
@@ -601,7 +661,7 @@ function applyCons(type) {
     if (!r.ok)
         dropHistory();
     else
-        toast(CONS_LABEL[c.type] + ' added');
+        toast(consLabel(c) + ' added');
     afterEdit();
 }
 /** Run a bottom-bar action. `anchor` is the button pressed, for actions that open a popover next to it. */
@@ -654,12 +714,6 @@ export function applyCtxAction(act, anchor) {
             tools[ed.tool].finish();
             updateCtx();
             return;
-        case 'dimDrive':
-            ed.dimLayer = 'drive';
-            break;
-        case 'dimPrint':
-            ed.dimLayer = 'print';
-            break;
         case 'h':
         case 'v':
         case 'par':
@@ -676,15 +730,15 @@ export function applyCtxAction(act, anchor) {
             return;
         case 'len':
             if (s.lines.length === 1)
-                dimLine(s.lines[0], false);
+                dimLine(s.lines[0]);
             else if (s.wfaces.length === 1 && sk.lines[edgeOf(s.wfaces[0])[0]]) {
                 const [lid, side] = edgeOf(s.wfaces[0]);
-                dimLine(lid, false, side);
+                dimLine(lid, side);
             }
             return;
         case 'pdist':
             if (s.points.length === 2)
-                dimPoints(s.points[0], s.points[1], false);
+                dimPoints(s.points[0], s.points[1]);
             return;
         case 'pldist':
             if (s.points.length === 1 && s.lines.length === 1)
@@ -705,9 +759,17 @@ export function applyCtxAction(act, anchor) {
             cornerAngle(s.points[0]);
             return;
         case 'merge': {
+            // (every one into the first picked)
+            if (s.points.length < 2)
+                return;
             pushHistory();
             const snap = JSON.stringify(sk);
-            if (joinPoints(sk, s.points[0], s.points[1])) {
+            if (!s.points.slice(1).every(id => joinPoints(sk, s.points[0], id))) {
+                replaceSK(JSON.parse(snap));
+                dropHistory();
+                toast('Two locked points can’t be joined. Unlock one first.', { warn: true });
+            }
+            else {
                 const r = solveSketch();
                 if (!r.ok) {
                     replaceSK(JSON.parse(snap));
@@ -747,14 +809,22 @@ export function applyCtxAction(act, anchor) {
             requestDraw();
             break;
         }
-        case 'constr':
+        case 'constr': {
+            // all guides, or all solid again if they all are — one setting for the whole selection, as To wall is (flipping
+            // each swapped a guide and a line picked together). A wall is always solid: never made a guide, and one that's a
+            // guide from before goes back to solid
+            const objs = [...s.lines.filter(id => !sk.lines[id].anchor).map(id => sk.lines[id]), ...s.curves.map(id => curveInfo(sk, id)?.o)]
+                .filter((o) => !!o);
+            const lines = objs.filter(o => o.kind !== 'wall'), walls = objs.filter(o => o.kind === 'wall' && o.constr);
+            if (!lines.length && !walls.length)
+                return;
+            const guide = !lines.every(o => o.constr);
             pushHistory();
-            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; });
+            lines.forEach(o => { o.constr = guide; });
+            walls.forEach(o => { o.constr = false; });
             afterEdit();
             return;
+        }
         case 'kind': {
             // one setting for the whole selection: all walls, unless they all are already (then all lines)
             const targets = [...s.lines.map(id => sk.lines[id]), ...s.curves.map(id => curveInfo(sk, id)?.o).filter((o) => !!o)];
@@ -797,9 +867,9 @@ export function applyCtxAction(act, anchor) {
             return;
         }
         case 'thick':
-            // straight and curved walls in the selection
+            // straight and curved walls in the selection (an edge's: its wall)
             thicknessPrompt([
-                ...s.lines.map(id => sk.lines[id]).filter(l => l.kind === 'wall'),
+                ...withEdges(sk, s).map(id => sk.lines[id]).filter(l => l.kind === 'wall'),
                 ...s.curves.map(id => curveInfo(sk, id)?.o).filter((o) => !!o && o.kind === 'wall'),
             ]);
             return;
@@ -824,10 +894,11 @@ export function applyCtxAction(act, anchor) {
         case 'renameRoom':
             editRoomName(s.rooms[0]);
             return;
+        // (the room is on the left of the wall's start → end when there's none either side of it)
         case 'opFlip': {
             pushHistory();
             const o = sk.openings[s.openings[0]];
-            o.flip = !o.flip;
+            flipDoor(o, roomSideOf(sk, o.line) === -1 ? -1 : 1);
             afterEdit();
             return;
         }
@@ -876,12 +947,12 @@ export function applyCtxAction(act, anchor) {
         case 'palette':
             openPalette(anchor);
             return;
-        case 'convert':
-            convertNote(s.notes[0]);
-            return;
         case 'linkOpen':
             openSelectedLink();
             return;
+        case 'linkExpand':
+            toggleExpand();
+            return;
         case 'linkSize':
             toggleTileSize(anchor);
             return;
@@ -916,6 +987,9 @@ export function applyCtxAction(act, anchor) {
             const lock = !ims.every(u => u.locked), many = ims.length > 1;
             pushHistory();
             ims.forEach(u => { u.locked = lock; });
+            // (locked, its bar is Lock and Open alone: an opacity or turning slider open over it goes with the rest)
+            if (lock)
+                dismissPopovers();
             afterEdit();
             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.');