@reekon-tools/boldr-cad 1.4.0 → 1.6.0

package/src/editor/actions.ts

@@ -1,15 +1,15 @@
 import { afterEdit, holdFaces, solveSketch, tryAddConstraint, undo } from '../app/edit';
 import { ed, type OpeningDimPart } 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 type { Constraint, ConsType, OpeningEdge, Sketch, Underlay, WallFace } from '../model/types';
+import type { Constraint, ConsType, OpeningEdge, Sketch, Underlay } from '../model/types';
 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 type { LineTool } from '../tools/line';
@@ -20,13 +20,13 @@ 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';
 
 /*
   The contextual bottom bar's decisions: which actions fit the tool and the selection, what the yellow + measures,
@@ -34,32 +34,43 @@ import { canOpenLink, canSaveDim, linkSizeVisible, openDimLink, openSelectedLink
   barItems() / plusVisible() and calls applyCtxAction() / plusAction() / deleteSelection().
 */
 
-export interface CtxItem { ic: string; label: string; act: string; on?: boolean; key?: string; locked?: boolean }
+/**
+ * A bar button; `lead`: the bar's first, its icon alone (see arrangeLead). `bare`: its icon alone too, wherever it is
+ * (Lock). Either way its name is its label for a screen reader.
+ */
+export interface CtxItem { ic: string; label: string; act: string; on?: boolean; key?: string; locked?: boolean; lead?: boolean; bare?: boolean }
+
+/** A bar button shown as its icon alone, no name under it (the lead, and Lock). */
+export const iconAlone = (it: CtxItem): boolean => !!(it.lead || it.bare);
 
 /** Points a Lock on the current selection would pin (the origin is always fixed). */
 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); });
+  // (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: CtxEntry[]): CtxEntry[] {
-  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] as CtxItem;
-  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: CtxEntry[] = [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'))) out.push(e);
+function arrangeLead(items: CtxEntry[]): CtxEntry[] {
+  const find = (acts: string[]) => items.find((it): it is CtxItem => 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: CtxEntry[] = [];
+  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();
   return out;
 }
@@ -79,24 +90,22 @@ 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') {
     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) add('calib', 'Set scale', 'calibtool');
+      // 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) add('rotate', 'Rotate', 'imgRotate');
+      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;
         if (at < last) add('tofront', 'To front', 'imgFront');
@@ -108,18 +117,17 @@ function ctxItems(): CtxEntry[] {
     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');
+      // (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;
@@ -138,7 +146,6 @@ function ctxItems(): CtxEntry[] {
     if (n >= 1) 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))) return items;
@@ -149,39 +156,70 @@ function ctxItems(): CtxEntry[] {
     for (const it of wb.items) 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: string[] = []) => {
+    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 is NonNullable<typeof 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) {
       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');
+    } 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)) 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');
+    // (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) items.push('sep');
@@ -196,70 +234,55 @@ 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
+  // 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'); return items; }
+  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') { items.push('sep'); add('flip', 'Flip', 'opFlip'); }
+    if (sk.openings[s.openings[0]].type === 'door') { items.push('sep'); 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]];
-    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'); 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'); }
-    }
+    kind();
+    // (its length: the yellow +)
+    add('h', 'Horizontal', 'h', { key: '⇧H' }); add('v', 'Vertical', 'v', { key: '⇧V' }); add('split', 'Split', 'split'); add('offset', 'Offset', 'offset');
     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()) { add('fillet', 'Fillet', 'fillet'); add('chamfer', 'Chamfer', 'chamfer'); }
-    wallItems();
+    if (filletCorner2()) { items.push('sep'); add('fillet', 'Fillet', 'fillet'); add('chamfer', 'Chamfer', 'chamfer'); }
     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) { 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'); return items; }
+  // 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'); return items; }
+  if (P === 1 && L === 1 && s.n === 2) { add('online', 'On line', 'online', { key: '⇧O' }); add('mid', 'Midpoint', 'mid', { key: '⇧M' }); return items; }
   if (P === 1 && C === 1 && s.n === 2) { add('oncircle', 'On circle', 'oncircle'); return items; }
-  if (L === 1 && C === 1 && s.n === 2) { add('tan', 'Tangent', 'tan', { key: '⇧T' }); wallItems(); return items; }
+  if (L === 1 && C === 1 && s.n === 2) { kind(); add('tan', 'Tangent', 'tan', { key: '⇧T' }); 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');
-    return items;
-  }
-  if (C === 2 && s.n === 2) { add('eq', 'Equal', 'eqr'); add('conc', 'Concentric', 'conc'); wallItems(); return items; }
+  if (C === 1 && s.n === 1) { kind(); return items; }
+  if (C === 2 && s.n === 2) { kind(); add('conc', 'Concentric', 'conc'); 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) { add('eq', 'Equal', 'eqall'); add('lock', 'Lock', 'lock'); guide(); wallItems(); return items; }
-  add('lock', 'Lock', 'lock');
+  if (L >= 2) { kind(); add('eq', 'Equal', 'eqall'); }
   return items;
 }
 
@@ -296,7 +319,7 @@ function filletCorner2(): string | null {
 }
 
 /** Buttons for the bottom bar: they adapt to the tool and the selection (Lock first, when offered). */
-export const barItems = (): CtxEntry[] => arrangeLock(ctxItems());
+export const barItems = (): CtxEntry[] => 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']);
@@ -324,13 +347,13 @@ export function plusAction(): void {
   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.', { 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 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 (s.wfaces.length === 1 && s.n === 1) { const [id, side] = edgeOf(s.wfaces[0]); if (sk.lines[id]) 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);
+  else if (s.lines.length === 1 && s.n === 1) 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) editOpeningDim(s.openings[0], 'w');
   // a corner where two lines meet: its angle
@@ -339,7 +362,7 @@ export function plusAction(): void {
   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]);
-  else if (s.n === 2 && s.points.length === 2) dimPoints(s.points[0], s.points[1], false);
+  else if (s.n === 2 && s.points.length === 2) 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 setTool('dim');
 }
@@ -362,6 +385,11 @@ export function deleteSelection(): void {
   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: Sketch, s: ReturnType<typeof selInfo>): [string, 1 | -1][] => s.wfaces.map(edgeOf).filter(([id]) => !!sk.lines[id]);
+/** The picked lines, and the walls of the picked straight edges. */
+const withEdges = (sk: Sketch, s: ReturnType<typeof selInfo>): string[] => [...s.lines, ...straightEdges(sk, s).map(([id]) => id)];
+
 function consFromSel(type: ConsType): Constraint | null {
   const sk = SK(), s = selInfo(), L = s.lines.map(id => sk.lines[id]);
   switch (type) {
@@ -369,10 +397,25 @@ function consFromSel(type: ConsType): Constraint | null {
       if (s.lines.length === 1) return { type, a: L[0].a, b: L[0].b };
       if (s.points.length === 2) return { type, a: s.points[0], b: s.points[1] };
       return null;
-    case 'par': case 'perp': case 'col': case 'eq':
+    case 'par': 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':
       return s.lines.length === 2 ? { type, l1: s.lines[0], l2: s.lines[1] } : null;
-    case 'mid': case 'online':
+    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])) as [number, number] } : { type, l1: ls[0], l2: ls[1] };
+    }
+    case 'mid': 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': {
@@ -395,9 +438,13 @@ const NEEDS: Partial<Record<ConsType, string>> = {
   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: ConsType): Constraint[] | null {
   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') return s.lines.map(id => ({ type, a: sk.lines[id].a, b: sk.lines[id].b }));
   if (type === 'par' || type === 'col' || type === 'eq') return s.lines.slice(1).map(id => ({ type, l1: s.lines[0], l2: id }));
@@ -406,8 +453,11 @@ function multiLineCons(type: ConsType): Constraint[] | null {
 
 const ADJ: Partial<Record<ConsType, string>> = { 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: ConsType, list: Constraint[]): void {
+/**
+ * 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: ConsType, list: Constraint[], points = false): void {
   pushHistory();
   let added = 0;
   const failed: Constraint[] = [];
@@ -418,9 +468,9 @@ function applyMulti(type: ConsType, list: Constraint[]): void {
   }
   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;
-  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() });
@@ -429,15 +479,42 @@ function applyMulti(type: ConsType, list: Constraint[]): void {
   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(): Constraint[] | null {
+  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' as const, 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: Constraint[]): void {
+  pushHistory();
+  let added = 0;
+  const failed: Constraint[] = [];
+  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: ConsType): void {
-  const multi = multiLineCons(type);
-  if (multi && (multi.length > 1 || selInfo().lines.length > 2)) { applyMulti(type, multi); return; }
+  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);
   if (!c) { toast('Select ' + (NEEDS[type] || 'geometry') + ' first.', { warn: true }); return; }
   pushHistory();
   const r = tryAddConstraint(c, { onResolved: () => afterEdit() });
   if (!r.ok) dropHistory();
-  else toast(CONS_LABEL[c.type] + ' added');
+  else toast(consLabel(c) + ' added');
   afterEdit();
 }
 
@@ -468,15 +545,13 @@ export function applyCtxAction(act: string, anchor?: unknown): void {
     // (the Line tool's, or the templator's: both close and finish a run of points)
     case 'closeShape': (tools[ed.tool] as LineTool | SurveyTool).closeShape(); updateCtx(); return;
     case 'finish': (tools[ed.tool] as LineTool | SurveyTool).finish(); updateCtx(); return;
-    case 'dimDrive': ed.dimLayer = 'drive'; break;
-    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);
-      else if (s.wfaces.length === 1 && sk.lines[edgeOf(s.wfaces[0])[0]]) { const [lid, side] = edgeOf(s.wfaces[0]); dimLine(lid, false, side); }
+      if (s.lines.length === 1) 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, side); }
       return;
-    case 'pdist': if (s.points.length === 2) dimPoints(s.points[0], s.points[1], false); return;
+    case 'pdist': if (s.points.length === 2) dimPoints(s.points[0], s.points[1]); 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 'fillet': case 'chamfer': {
@@ -486,9 +561,13 @@ export function applyCtxAction(act: string, anchor?: unknown): void {
     }
     case 'cornerAngle': 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) as Sketch); 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) 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'); }
@@ -514,12 +593,21 @@ export function applyCtxAction(act: string, anchor?: unknown): void {
       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 is NonNullable<typeof 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: { kind?: 'line' | 'wall'; thick?: number }[] = [...s.lines.map(id => sk.lines[id]), ...s.curves.map(id => curveInfo(sk, id)?.o).filter((o): o is NonNullable<typeof o> => !!o)];
@@ -548,9 +636,9 @@ export function applyCtxAction(act: string, anchor?: unknown): void {
       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 is NonNullable<typeof o> => !!o && o.kind === 'wall'),
       ]);
       return;
@@ -564,7 +652,8 @@ export function applyCtxAction(act: string, anchor?: unknown): void {
     case 'toggleref': toggleRef(s.dims[0]); return;
     case 'odimRef': { const [op, part] = s.odims[0].split('|'); toggleOpeningDim(op, part.slice(2)); return; }
     case 'renameRoom': editRoomName(s.rooms[0]); return;
-    case 'opFlip': { pushHistory(); const o = sk.openings[s.openings[0]]; o.flip = !o.flip; afterEdit(); 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]]; flipDoor(o, roomSideOf(sk, o.line) === -1 ? -1 : 1); afterEdit(); return; }
     case 'opDist': {
       const ops = ed.sel.filter(x => x.type === 'opening').map(x => x.id);
       if (ops.length === 2) {
@@ -601,8 +690,8 @@ export function applyCtxAction(act: string, anchor?: unknown): void {
       return;
     }
     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;
     case 'dimLinkOpen': if (s.dims.length === 1) openDimLink(s.dims[0]); return;
     case 'dimUnlink': if (s.dims.length === 1) unlinkDim(s.dims[0]); return;
@@ -619,6 +708,8 @@ export function applyCtxAction(act: string, anchor?: unknown): void {
       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.');