@reekon-tools/boldr-cad 1.3.0 → 1.5.0

package/src/app/edit.ts

@@ -6,6 +6,7 @@ import { pushedOut, syncFaces } from '../model/facesolve';
 import { elevSyncFrame, fitState, overflow, pastWallMsg, restoreFit } from '../editor/elevation';
 import { resolveOpenings } from '../model/openings';
 import { gc, restorePos, snapshotPos } from '../model/sketch';
+import { factorFor, isEnteredLength, isUnscaled, scalePage, setScale } from '../model/scale';
 import { page, planSK, saveSoon, SK } from '../model/store';
 import type { Constraint, SelItem, Sketch, WallFace } from '../model/types';
 import { cabOfPoint, cabPoints } from '../model/faces';
@@ -141,11 +142,34 @@ export function holdGroups(sk: Sketch, c: Constraint): string[][] {
   return groups;
 }
 
+/**
+ * The drawing's first length (entered on an unscaled page's plan): the page is scaled so that what it measures is
+ * already that long, its view zoomed to match, so nothing moves on the screen (model/scale.ts). Returns how to take
+ * that back — the length was refused — or null when it isn't the first.
+ */
+function scaleForFirstLength(c: Constraint): (() => void) | null {
+  const pg = page();
+  if (!isUnscaled(pg.sk) || SK() !== pg.sk || !isEnteredLength(c)) return null;
+  const k = factorFor(pg.sk, c, c.value!);
+  if (k == null) return null;
+  setScale(pg, k);
+  requestDraw();
+  // (in place, not a copy put back: callers keep using the sketch they had)
+  return () => { scalePage(pg, 1 / k); pg.sk.unscaled = true; delete pg.sk.scaledBy; requestDraw(); };
+}
+
 /**
  * Add a constraint through the solver and explain the outcome:
  * reference dimension → toast, conflict → conflict sheet (unless silent).
  */
-export function tryAddConstraint(c: Constraint, { silent = false, onResolved = null as (() => void) | null } = {}): AddResult {
+export function tryAddConstraint(c: Constraint, opts: { silent?: boolean; onResolved?: (() => void) | null } = {}): AddResult {
+  const unscale = scaleForFirstLength(c);
+  const r = addThroughSolver(c, opts);
+  if (unscale && !r.ok) unscale();
+  return r;
+}
+
+function addThroughSolver(c: Constraint, { silent = false, onResolved = null as (() => void) | null } = {}): AddResult {
   // nothing may be pushed past its wall (in the wall view, past the wall; in the plan, a wall made shorter than
   // what's on it): a constraint that would is taken back
   const sk = SK(), was = overflow(sk), held = fitState(sk);

package/src/app/state.ts

@@ -12,13 +12,12 @@ export interface Hit {
   /** 'cabfoot': a cabinet's footprint in the plan (id: its wall face's key, '#', its id) */
   type: SelType | 'odim' | 'oanchor' | 'uhandle' | 'nhandle' | 'cabfoot';
   id: string;
-  /** a print dimension label */
-  print?: boolean;
   /** low-priority hit (room fill) */
   weak?: boolean;
   /**
    * 'odim': 'w' width, 'a'/'b' distance to a wall end, or 'd:<id>' a placed dimension. 'oanchor': 's0'/'s1' edge.
-   * 'note', a link's tile: 'tip' its leader's tip, 'leader' along its leader (unset: its card).
+   * 'note', a link's tile: 'tip' its leader's tip, 'leader' along its leader (unset: its card). 'underlay', an expanded
+   * photo: 'link' its badge (a tap opens it).
    */
   part?: string;
   /** a wall picked whole: the side of its centreline the pointer was on (+1 the left of its A → B; a curved one's, outside) */
@@ -50,7 +49,7 @@ export interface Snap {
 /** Screen-space hit region registered while drawing chips, badges and labels. */
 export interface HitChip {
   /** 'elev': one of the wall view's dimension chips (id: what it measures, as JSON) */
-  kind: 'dim' | 'pdim' | 'cons' | 'room' | 'odim' | 'elev';
+  kind: 'dim' | 'cons' | 'room' | 'odim' | 'elev';
   part?: string;
   id: string;
   x: number; y: number; w: number; h: number;
@@ -83,7 +82,6 @@ export const ed = sessionState(() => ({
   drawConstr: false,
   /** the rail's Walls toggle: what's drawn (lines, rectangles, circles, arcs, Draw to shape) is walls */
   drawWalls: false,
-  dimLayer: 'drive' as 'drive' | 'print',
   openingType: 'door' as 'door' | 'window',
   /** new markup's look (the stroke panel sets them; selected markup changes with them) */
   noteColor: DEFAULT_NOTE_COLOR,

package/src/data/sync.ts

@@ -8,6 +8,7 @@ import { newPage } from '../model/demo';
 import { allCons } from '../model/faces';
 import { syncFaces } from '../model/facesolve';
 import { clearPageHistory, imageStored } from '../model/history';
+import { rezoomAcrossScale, settleScale } from '../model/scale';
 import { defaultLayers, settings } from '../model/settings';
 import { store, type Persistence } from '../model/store';
 import type { Constraint, Page, Project } from '../model/types';
@@ -61,7 +62,7 @@ export interface CadSync {
 
 /**
  * A driving dimension's value as BOLDR keeps it: lengths in micrometres, angles in degrees. Null for what isn't one of
- * the drawing's own measurements: reference and print dimensions, constraints without a value, and dimensions linked
+ * the drawing's own measurements: reference dimensions, constraints without a value, and dimensions linked
  * to a measurement of the job (the job's, not the drawing's: see editor/links.ts).
  */
 export function measurementOf(c: Constraint): CadMeasurementValue | null {
@@ -165,9 +166,12 @@ export function openCadDrawing(provider: CadDataProvider, opts: CadSyncOptions =
     for (const [id, doc] of Object.entries(pages)) {
       if (doc.rev?.clientId === clientId) continue; // our own write coming back
       if (writing.has(id)) continue; // ours is on its way: this snapshot is older than what's here
+      settleScale(doc.sk); // (before it's compared: settled, it's what was saved, not an edit here)
       const json = pageJson(doc), local = project.pages.find(p => p.id === id);
       if (local) {
         if (pageJson(local) !== saved.get(id) || json === saved.get(id)) continue; // edited here since, or nothing new
+        // (given its scale elsewhere, or taken back: the view here zooms to match, so the drawing stays put on screen)
+        rezoomAcrossScale(local, local.sk, doc.sk);
         local.name = doc.name; local.sk = doc.sk; local.underlays = imagesOf(doc);
         clearPageHistory(id);
         if (id === store.curPageId) curChanged = true;
@@ -263,7 +267,8 @@ export function openCadDrawing(provider: CadDataProvider, opts: CadSyncOptions =
       if (!file.meta && !opts.initialize) { stop(); reject(new NotACadDrawing('legacy')); return; }
       const order = file.meta?.pageOrder ?? [];
       const ids = [...order.filter(id => pages![id]), ...Object.keys(pages!).filter(id => !order.includes(id))];
-      project = { name: file.name, pages: ids.map(id => ({ id, name: pages![id].name, sk: pages![id].sk, underlays: imagesOf(pages![id]), view: null })) };
+      // (each page's scale settled before what was saved is noted: model/scale.ts)
+      project = { name: file.name, pages: ids.map(id => ({ id, name: pages![id].name, sk: settleScale(pages![id].sk), underlays: imagesOf(pages![id]), view: null })) };
       for (const id of ids) saved.set(id, pageJson(pages![id]));
       if (file.meta) savedMeta = JSON.stringify(file.meta);
       // a new drawing (or one whose pages are all gone) starts with one empty page, saved straight away; its id is

package/src/editor/actions.ts

@@ -2,14 +2,14 @@ import { afterEdit, holdFaces, solveSketch, tryAddConstraint, undo } from '../ap
 import { ed, type OpeningDimPart } from '../app/state';
 import { CONS_LABEL, 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,7 +34,14 @@ 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[] {
@@ -45,21 +52,24 @@ function lockTargets(): string[] {
 }
 
 /**
- * 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 +89,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 +116,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 +145,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,14 +155,31 @@ 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; on a wall face, Guide alone.
+   */
+  const kind = () => {
+    const objs = [...s.lines.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' && !o.constr)) {
+      if (wall) return;
+      if (s.n === 1 && L === 1) add('elev', 'Elevation', 'elev');
+      add('thick', 'Thickness', 'thick');
+    } else {
+      if (!wall) add('wall', 'To wall', 'kind');
+      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) {
@@ -164,24 +187,18 @@ function ctxItems(): CtxEntry[] {
       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]];
     // 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 +213,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 +298,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 +326,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 +341,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');
 }
@@ -395,9 +397,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 +412,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 +427,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() });
@@ -430,8 +439,8 @@ function applyMulti(type: ConsType, list: Constraint[]): void {
 }
 
 function applyCons(type: ConsType): void {
-  const multi = multiLineCons(type);
-  if (multi && (multi.length > 1 || selInfo().lines.length > 2)) { applyMulti(type, multi); 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();
@@ -468,15 +477,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 +493,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'); }
@@ -564,7 +575,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 +613,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 +631,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.');