@reekon-tools/boldr-cad 1.4.0 → 1.6.0

package/src/editor/elevation.ts

@@ -24,6 +24,7 @@ import { fmtLen } from '../units';
 import { addCabinet, addHeightLine, CAB, cabinetSpot, deleteCabinets, dimensionFace, editCabinet, editCabinetDepth, snapObjectMove } from './face';
 import type { RailItem } from './mode';
 import { openKeypad, refreshModes, renderElevation, toast, updateCtx, updateHint, updateRail, updateTopBar } from './ports';
+import { waitForScale } from './scaleGate';
 
 /*
   The wall view: one straight wall seen straight on, edited with the plan's own tools. Opening a wall makes the
@@ -50,8 +51,12 @@ export const elevOpen = (): boolean => elev.lid != null;
 const wallBox = () => (elev.frame ? { x0: elev.frame.face[0], y0: 0, x1: elev.frame.face[1], y1: elev.frame.H } : null);
 
 /** Open the wall view of a straight wall, seen from the room side. */
-/** Open a wall's view: from the side a room is on — or `side`, the face to the left (+1) or right (−1) of its A → B. */
+/**
+ * Open a wall's view: from the side a room is on — or `side`, the face to the left (+1) or right (−1) of its A → B.
+ * Not before the page's first length: the wall's height is real, its length only a placeholder until then.
+ */
 export function openElevation(lid: string, side?: 1 | -1): void {
+  if (waitForScale()) return;
   if (!elevFrame(planSK(), lid)) { toast('Elevations work on straight walls. Turn the line into a wall first.', { warn: true }); return; }
   cancelTool();
   elev.lid = lid; elev.flip = side != null && side !== (roomSideOf(planSK(), lid) || 1);
@@ -331,7 +336,7 @@ export const elevAct = (id: string): ElevAct => JSON.parse(id) as ElevAct;
 /** A chip's name, as the bar shows it. */
 export function elevChipName(a: ElevAct): string {
   if (a.k === 'gap') return a.title;
-  if (a.k === 'len') return 'Wall length · set in the floor plan';
+  if (a.k === 'len') return 'Wall length';
   if (a.k === 'wallH') return 'Wall height';
   if (a.k === 'pos') return a.title;
   if (a.k === 'fdim') return 'Dimension';
@@ -698,7 +703,8 @@ export function wallBar(): { label?: string; items: WallBarItem[]; plus: boolean
   if (pair) {
     const name = (id: string) => (planSK().openings[id]?.type === 'door' ? 'Door' : 'Window');
     const label = name(pair.op) + ' + ' + ('op' in pair.other ? name(pair.other.op).toLowerCase() : 'corner');
-    return { label, items: [{ ic: 'dim', label: 'Distance', act: 'wallDist' }], plus: true };
+    // (the distance between them: the yellow +)
+    return { label, items: [], plus: true };
   }
   if (ed.sel.length !== 1) return null;
   const s = ed.sel[0], sk = planSK();
@@ -706,19 +712,10 @@ export function wallBar(): { label?: string; items: WallBarItem[]; plus: boolean
     const a = elevAct(s.id);
     return { label: elevChipName(a), items: a.k === 'len' ? [{ ic: 'back', label: 'Go to plan', act: 'wallGoPlan' }] : [], plus: a.k !== 'len' };
   }
-  // a door, window or cabinet picked as a whole: its sizes to set, by name (no + — it isn't one dimension)
-  if (s.type === 'opening') {
-    const o = sk.openings[s.id];
-    if (!o) return null;
-    return { label: openingLabel(o), items: OPENING_SIZES, plus: false };
-  }
-  if (s.type === 'cab') {
-    const face = SK() as WallFace, b = cabBox(face, s.id), cb = face.cabs[s.id];
-    return {
-      label: 'Cabinet' + (b ? ' ' + fmtLen(b.u1 - b.u0) + ' L × ' + fmtLen(b.z1 - b.z0) + ' H × ' + fmtLen(cb.depth) + ' D' : ''),
-      items: [{ ic: 'v', label: 'Height', act: 'cabH' }, { ic: 'h', label: 'Length', act: 'cabW' }, { ic: 'thick', label: 'Depth', act: 'cabD' }], plus: false,
-    };
-  }
+  // a door, window or cabinet picked as a whole: its sizes to set (no + — it isn't one dimension), with nothing saying
+  // them: the wall view shows them (the user's call, 2026-10-27: "get rid of extra dimensions text")
+  if (s.type === 'opening') return sk.openings[s.id] ? { items: OPENING_SIZES, plus: false } : null;
+  if (s.type === 'cab') return { items: [{ ic: 'v', label: 'Height', act: 'cabH' }, { ic: 'h', label: 'Length', act: 'cabW' }, { ic: 'thick', label: 'Depth', act: 'cabD' }], plus: false };
   const face = SK() as WallFace;
   if (s.type === 'line' && face.lines[s.id]?.anchor) return { label: anchorName(s.id), items: [], plus: false };
   if (s.type === 'line' && face.lines[s.id]?.cab) return { label: 'Cabinet edge', items: [], plus: false };

package/src/editor/gestures.ts

@@ -17,7 +17,8 @@ import type { SelItem } from '../model/types';
 /*
   Pointer routing for the plan canvas, whatever delivers the pointers (DOM pointer events, React Native touches).
   Pen draws, fingers navigate: once a pen has been seen, touch only pans and zooms. Without a pen, one finger drives
-  the tool and a second finger turns the action into a pan/pinch. Two-finger tap undoes, three-finger tap redoes.
+  the tool and a second finger turns the action into a pan/pinch — a finger's press waits a moment for one first
+  (pressTiming). Two-finger tap undoes, three-finger tap redoes.
   Mouse: middle or right button, or Space held, drags to pan; the wheel zooms.
   With a sheet up over the drawing (the keypad, a conflict, a question), the drawing only pans and zooms, by any
   pointer, and a tap on it closes the sheet. View only, a tap on a link's tile asks to open what it's for.
@@ -52,22 +53,40 @@ export function setHostNavigation(on: boolean): void { hostNavigates = on; }
  */
 const MOTION_PX = 14;
 
+/**
+ * How long a finger's press waits before the tool hears of it (ms), unless it lifts or moves past a tap first: time
+ * for a second finger to land and make it a pan or pinch from the start. Then the first finger never pressed anything:
+ * nothing is picked, no bar or sheet shows for it, and nothing is drawn where it landed (the user's report, 2026-10-30:
+ * zooming, "there is a brief moment where my touch brings up a bottom sheet"). A pinch's fingers land a few tens of
+ * milliseconds apart; iOS holds a scroll view's touches 150 ms and Android a pressed look 100 ms, for the same reason.
+ * A second finger after the wait still undoes the press (cancelPrimary). A mouse and a Pencil press at once.
+ */
+export const pressTiming = {
+  /** tests pin it (0: a finger presses at once) */
+  holdMs: 120,
+};
+
 const ptrs = new Map<number, PointerIn>();
 let penSeen = false, gesture: Gesture | null = null, primary: PointerIn | null = null;
 /** close: a press under a sheet (see sheetUp) — a tap closes it; open: a view-only press — a tap opens a link's tile */
 let panDrag: { x: number; y: number; id: number; moved: number; close?: boolean; open?: boolean } | null = null;
 /** where the primary pointer went down, and whether a gesture on the drawing is in motion */
 let primaryAt: { x: number; y: number } | null = null, inMotion = false;
+/** the primary pointer has moved past a tap since it went down (see lensPointer) */
+let primaryMoved = false;
 /**
  * What a press can change, as it was before the primary pointer went down: if a second finger turns the press into a
  * pan or pinch, it's put back (see cancelPrimary). A tool's own state is kept a level deep — its presses set its fields,
  * they don't change what's in them.
  */
 let beforePress: { tool: string; st: unknown; sel: SelItem[]; preview: Preview | null; snap: Snap | null } | null = null;
+/** A finger down whose press is waiting (pressTiming): the pointer, where it landed, and each move it's made since. */
+let held: { p: PointerIn; at: PointerIn; moves: PointerIn[]; timer: ReturnType<typeof setTimeout> } | null = null;
 let wheelT: ReturnType<typeof setTimeout> | undefined;
 export const keys = { spaceDown: false };
 onSessionReset(() => {
-  ptrs.clear(); penSeen = false; gesture = null; primary = null; panDrag = null; keys.spaceDown = false; primaryAt = null; beforePress = null;
+  ptrs.clear(); penSeen = false; gesture = null; primary = null; panDrag = null; keys.spaceDown = false; primaryAt = null; beforePress = null; primaryMoved = false;
+  dropHeld();
   setMotion(false);
   clearTimeout(wheelT);
 });
@@ -164,6 +183,39 @@ function cancelPrimary(): void {
   updateCtx(); updateHint(); requestDraw();
 }
 
+/** The primary pointer's press: the tool hears it land where `at` says (its pointer `p` may have moved on since). */
+function press(p: PointerIn, at: PointerIn): void {
+  primary = p; primaryMoved = false;
+  primaryAt = { x: at.x, y: at.y };
+  // (what it lands on is picked from the drawing as it is now, not as the last frame painted it)
+  paintPending();
+  const t = curTool();
+  beforePress = { tool: ed.tool, st: t && t.st && typeof t.st === 'object' ? { ...t.st } : t?.st, sel: [...ed.sel], preview: ed.preview, snap: ed.snapState };
+  if (t && t.down) t.down(evOf(at));
+}
+
+/** The primary pointer moved: past a tap, a gesture is in motion (and the lens may show); the tool follows it. */
+function movePrimary(e: PointerIn): void {
+  if (primaryAt && hyp(e.x - primaryAt.x, e.y - primaryAt.y) >= MOTION_PX) { setMotion(true); primaryMoved = true; }
+  const t = curTool();
+  if (t && t.move) t.move(evOf(e));
+}
+
+function dropHeld(): void {
+  if (held) clearTimeout(held.timer);
+  held = null;
+}
+
+/** A finger's waiting press goes ahead: the tool hears it land where it did, then each move it's made since. */
+function releaseHeld(): void {
+  const h = held;
+  dropHeld();
+  // (something else took the drawing meanwhile: a mouse or Pencil press, a sheet, view only)
+  if (!h || primary || navigationOnly()) return;
+  press(h.p, h.at);
+  for (const m of h.moves) movePrimary(m);
+}
+
 function endPtr(e: PointerIn, cancel: boolean): void {
   const p = ptrs.get(e.id);
   ptrs.delete(e.id);
@@ -175,6 +227,8 @@ function endPtr(e: PointerIn, cancel: boolean): void {
     return;
   }
   if (gesture && p && p.kind === 'touch') { if (!touchList().length) endGesture(e.t); return; }
+  // (a finger let go while its press waited: a tap, pressed and let go now; lost, it did nothing)
+  if (held && e.id === held.at.id) { if (cancel) dropHeld(); else releaseHeld(); }
   if (primary && e.id === primary.id) {
     primary = null;
     const t = curTool();
@@ -199,6 +253,8 @@ export function pointerDown(e: PointerIn): void {
   if (e.kind === 'touch') {
     const touches = touchList();
     if (penSeen || touches.length >= 2 || navOnly) {
+      // (a second finger while the first one's press waited: that never pressed anything)
+      dropHeld();
       if (primary && primary.kind === 'touch') cancelPrimary();
       // (a finger joining one already moving the view: the pinch is measured from here, none of its first move lost)
       if (!gesture) startGesture(e.t); else { gesture.max = Math.max(gesture.max, touches.length); gesture.last = gState(touches); }
@@ -206,13 +262,13 @@ export function pointerDown(e: PointerIn): void {
     }
   }
   if (primary || navOnly) return;
-  primary = p;
-  primaryAt = { x: e.x, y: e.y };
-  // (what it lands on is picked from the drawing as it is now, not as the last frame painted it)
-  paintPending();
-  const t = curTool();
-  beforePress = { tool: ed.tool, st: t && t.st && typeof t.st === 'object' ? { ...t.st } : t?.st, sel: [...ed.sel], preview: ed.preview, snap: ed.snapState };
-  if (t && t.down) t.down(evOf(e));
+  // a finger's press waits a moment, in case another finger lands (pressTiming)
+  if (e.kind === 'touch' && pressTiming.holdMs > 0) {
+    dropHeld();
+    held = { p, at: { ...e }, moves: [], timer: setTimeout(releaseHeld, pressTiming.holdMs) };
+    return;
+  }
+  press(p, e);
 }
 
 export function pointerMove(e: PointerIn): void {
@@ -225,15 +281,29 @@ export function pointerMove(e: PointerIn): void {
   }
   if (p) { p.x = e.x; p.y = e.y; }
   if (gesture && p && p.kind === 'touch') { updateGesture(); return; }
+  // (a finger whose press is waiting: its moves wait with it, and one past a tap sends them all now — a drag)
+  if (held && e.id === held.at.id) {
+    held.moves.push({ ...e });
+    if (hyp(e.x - held.at.x, e.y - held.at.y) >= MOTION_PX) releaseHeld();
+    return;
+  }
   const t = curTool();
   if (!t) return;
-  if (primary && e.id === primary.id) {
-    if (primaryAt && hyp(e.x - primaryAt.x, e.y - primaryAt.y) >= MOTION_PX) setMotion(true);
-    if (t.move) t.move(evOf(e));
-  }
+  if (primary && e.id === primary.id) movePrimary(e);
   else if (!primary && e.kind !== 'touch' && !navigationOnly()) { ed.lastPointerTouch = false; if (t.hover) t.hover(evOf(e)); }
 }
 
+/**
+ * The finger or Apple Pencil working the drawing, where it is on the canvas, once it's moved past a tap placing or
+ * dragging something (Tool.magnify): what a device's magnifier is centred on (render/lens.ts). Null for a mouse, a tap,
+ * a pan or a pinch, and a drawing that can't be edited or has a sheet up.
+ */
+export function lensPointer(): { x: number; y: number } | null {
+  if (!primary || primary.kind === 'mouse' || !primaryMoved || navigationOnly()) return null;
+  const t = curTool();
+  return t && (!t.magnify || t.magnify()) ? { x: primary.x, y: primary.y } : null;
+}
+
 export function pointerUp(e: PointerIn): void { endPtr(e, false); settle(); }
 export function pointerCancel(e: PointerIn): void { endPtr(e, true); settle(); }
 

package/src/editor/keys.ts

@@ -5,7 +5,7 @@ import { saveSoon } from '../model/store';
 import { fitView, requestDraw } from '../render/view';
 import { cancelTool, setTool, tools } from '../tools/registry';
 import { applyCtxAction, deleteSelection } from './actions';
-import { addLinks, linkPlusVisible, openSelectedLink, selectedLink } from './linkActions';
+import { addLinks, linkPlusVisible, openSelectedLink, selectedLink, selectedLinkedImage } from './linkActions';
 import { keys } from './gestures';
 import { keypadApply, keypadDeleteLast, keypadInsert, keypadOpen } from './keypad';
 import { confirmCancel, confirmChoose, confirmOpen } from './confirm';
@@ -89,7 +89,8 @@ export function keyDown(e: KeyIn): boolean {
   }
   // Annotate: + adds files and measurements (the + by the rail), Enter opens the selected link
   if ((e.key === '+' || e.key === '=') && linkPlusVisible()) { void addLinks(); return true; }
-  if (e.key === 'Enter' && ed.mode === 'annotate' && selectedLink()) { openSelectedLink(); return true; }
+  // (⇧Enter: beside the drawing, where the host can show it there)
+  if (e.key === 'Enter' && ed.mode === 'annotate' && (selectedLink() || selectedLinkedImage())) { openSelectedLink(e.shift ? 'beside' : 'auto'); return true; }
   if (e.shift) {
     const c = SHIFT_CONS[e.key.toUpperCase()];
     if (c && ed.mode === 'draft') { applyCtxAction(c); return true; }

package/src/editor/laser.ts

@@ -17,10 +17,11 @@ import { selInfo } from './selection';
 
 /*
   Measure-then-assign for laser and tape readings (inches), whatever device sends them: a reading goes into an open
-  keypad, onto the one selected line, or to the tray, where it can be dragged onto a line later.
+  keypad, or onto the one selected line; one with nowhere to go is kept for a keypad's Laser key (and, in the harness,
+  its tray, where it can be dragged onto a line later).
 */
 
-/** A reading, and the host's record of it (laserReading's `capture`), kept with it in the tray. */
+/** A reading, and the host's record of it (laserReading's `capture`), kept with it until it's used. */
 export interface Reading { id: string; v: number; capture?: unknown }
 /** `external`: a real measure the host app is connected to (otherwise the harness's simulated one). */
 export const laser = sessionState(() => ({ on: false, external: false, readings: [] as Reading[] }));
@@ -100,7 +101,9 @@ function appliedTo(id: string): string {
 }
 
 /**
- * A reading arrived: into the keypad, onto the selected line or curve, or into the tray (newest first, at most 8).
+ * A reading arrived: into the keypad, onto the selected line or curve, or — with nowhere to go — kept for a keypad's
+ * Laser key (newest first, at most 8) and said so. The hosts show no tray of them (the user's call, 2026-11-03: "get rid
+ * of the long laser reading pop up … it is not needed"); the harness's own still lists them (ui/laser.ts).
  * `capture` is the host's record of it (its device, its number), kept with the dimension it sets until that's saved
  * to the group — or handed to the job with it, for one linked to a measurement there.
  */
@@ -117,7 +120,7 @@ export function applyReading(v: number, capture?: unknown): void {
   laser.readings.unshift({ id: uid('m'), v, ...(capture !== undefined ? { capture } : {}) });
   laser.readings = laser.readings.slice(0, 8);
   refreshTray();
-  toast('Reading ' + fmtLen(v) + ' saved to the tray');
+  toast('Select a line, then take the reading.', { warn: true });
 }
 
 /**

package/src/editor/linkActions.ts

@@ -3,17 +3,20 @@ import { ed } from '../app/state';
 import { clamp } from '../model/geom';
 import { pushHistory } from '../model/history';
 import { uid } from '../model/ids';
-import { isLink, LINK_COLOR, LINK_MAX_IN, LINK_MIN_IN, LINK_TILE_PX, linkInfoOf, linkName, linkSide, linkSnapshot } from '../model/links';
+import { isLink, LINK_COLOR, LINK_HARD_MAX_IN, LINK_HARD_MIN_IN, LINK_MAX_IN, LINK_MIN_IN, LINK_SIDE_IN, LINK_TILE_PX, linkInfoOf, linkName, linkSide, linkSnapshot } from '../model/links';
 import { dimMeasurement } from '../model/measurement';
-import { linkAt } from '../render/hit';
+import { imageLinkAt, linkAt } from '../render/hit';
 import { askConfirm } from './confirm';
-import { SK, store } from '../model/store';
-import type { LinkTarget, Note } from '../model/types';
-import { cvs, linkBox, mainT, requestDraw, s2w } from '../render/view';
+import { imageById } from '../model/images';
+import { settings } from '../model/settings';
+import { page, SK, store } from '../model/store';
+import type { LinkTarget, Note, Sketch, Underlay } from '../model/types';
+import { tileTypeOf } from '../render/linkTile';
+import { cvs, linkBox, linkThumb, mainT, requestDraw, s2w, underlayMid } from '../render/view';
 import { setTool } from '../tools/registry';
 import { elevOpen } from './elevation';
 import { is3d } from './view3dState';
-import { canLink, linksHost, openLink, pickLinks } from './links';
+import { besideOpen, canLink, canOpenBeside, linksHost, openLink, openLinkBeside, pickLinks } from './links';
 import { toast } from './ports';
 
 /*
@@ -65,6 +68,8 @@ export async function addLinks(): Promise<void> {
   let k = 0;
   while (k < 40 && spots.some(([x, y]) => taken(x + k * step, y - k * step))) k++;
   pushHistory();
+  // (the page's first tiles: the size they're placed at is their 100%)
+  if (pageLinkSize(sk) == null) sk.tileRef = ts;
   const ids = picked.map((t, i) => {
     const n: Note = { id: uid('lk'), type: 'link', x: spots[i][0] + k * step, y: spots[i][1] - k * step, ts, color: LINK_COLOR, link: linkSnapshot(t) };
     sk.notes.push(n);
@@ -80,7 +85,9 @@ const LINK_GAP_PX = 16;
 
 /*
   Every tile on a page is one size, on the drawing (so it zooms with the plan and prints at that size): the Tile size
-  slider above the bar, shown while a tile is selected, sizes them all together.
+  slider above the bar, shown while a tile is selected, sizes them all together. It says how big in percent of the size
+  they were first placed at (the user's call, 2026-11-03): a tile has no real size, and before the page's first length
+  its inches are only placeholders, so feet and metres said nothing true.
 */
 
 /** The size of the page's tiles, inches on the drawing (null: it has none). */
@@ -96,21 +103,44 @@ export function linkSizeVisible(): boolean {
   return ed.sel.some(x => x.type === 'note' && sk.notes.find(n => n.id === x.id)?.type === 'link');
 }
 
+/** What the page's tiles call 100%, inches on the drawing: the size they were first placed at (a page from before: theirs now). */
+const tileRef = (sk: Sketch): number => sk.tileRef ?? pageLinkSize(sk) ?? LINK_SIDE_IN;
+
+/** How big the page's tiles are, in percent of the size they were first placed at (null: it has none). */
+export function pageTilePct(sk = SK()): number | null {
+  const s = pageLinkSize(sk);
+  return s == null ? null : Math.round((s / tileRef(sk)) * 100);
+}
+
+/** The slider's range, percent. */
+export const TILE_PCT_MIN = 10, TILE_PCT_MAX = 1000;
+
 /**
- * Size every tile on the page (inches, to the quarter, from LINK_MIN_IN to LINK_MAX_IN), drawn at once — for the slider
- * as it moves. The caller makes the undo step before, and finishes the edit after.
+ * Size every tile on the page to `pct` percent (TILE_PCT_MIN to TILE_PCT_MAX; and never past LINK_HARD_MIN_IN to
+ * LINK_HARD_MAX_IN on the drawing — placing's 6"–40' bounds would cut the range short), drawn at once — for the slider as
+ * it moves. The caller makes the undo step before, and finishes the edit after. (A page from before keeps its 100% from
+ * here on.)
  */
-export function setLinkSize(inches: number): void {
-  const v = Math.round(clamp(inches, LINK_MIN_IN, LINK_MAX_IN) * 4) / 4;
-  for (const n of SK().notes) if (isLink(n)) n.ts = v;
+export function setTilePct(pct: number): void {
+  const sk = SK(), ref = tileRef(sk), v = clamp((ref * clamp(pct, TILE_PCT_MIN, TILE_PCT_MAX)) / 100, LINK_HARD_MIN_IN, LINK_HARD_MAX_IN);
+  sk.tileRef = ref;
+  for (const n of sk.notes) if (isLink(n)) n.ts = v;
   requestDraw();
 }
 
-/** The slider runs along a log scale (a few inches to many feet, each step as noticeable as the last): 0 to SIZE_STEPS. */
+/**
+ * The slider runs along a log scale (each step as noticeable as the last), 0 to SIZE_STEPS, 100% in the middle; it
+ * catches at 100%, so the size they came in at is easy to find again, and says round numbers: whole percents to 200%,
+ * then fives, then tens from 500%.
+ */
 export const SIZE_STEPS = 1000;
-const LOG_MIN = Math.log(LINK_MIN_IN), LOG_SPAN = Math.log(LINK_MAX_IN) - LOG_MIN;
-export const sizeToStep = (inches: number): number => Math.round(((Math.log(clamp(inches, LINK_MIN_IN, LINK_MAX_IN)) - LOG_MIN) / LOG_SPAN) * SIZE_STEPS);
-export const stepToSize = (step: number): number => Math.exp(LOG_MIN + (clamp(step, 0, SIZE_STEPS) / SIZE_STEPS) * LOG_SPAN);
+const LOG_MIN = Math.log(TILE_PCT_MIN), LOG_SPAN = Math.log(TILE_PCT_MAX) - LOG_MIN;
+export const pctToStep = (pct: number): number => Math.round(((Math.log(clamp(pct, TILE_PCT_MIN, TILE_PCT_MAX)) - LOG_MIN) / LOG_SPAN) * SIZE_STEPS);
+export function stepToPct(step: number): number {
+  const p = Math.exp(LOG_MIN + (clamp(step, 0, SIZE_STEPS) / SIZE_STEPS) * LOG_SPAN);
+  if (Math.abs(p - 100) < 4) return 100;
+  return p >= 500 ? Math.round(p / 10) * 10 : p >= 200 ? Math.round(p / 5) * 5 : Math.round(p);
+}
 
 /** A tile's leader on or off. On, it points out beside the tile (to the right, or the left near the screen's edge). */
 export function toggleLeader(id: string): void {
@@ -126,24 +156,134 @@ export function toggleLeader(id: string): void {
   afterEdit();
 }
 
-/** Open what the selected tile is for. */
-export function openSelectedLink(): void {
-  const n = selectedLink();
-  if (!n) return;
-  if (!canOpenLink(n.link)) { toast(linkInfoOf(n.link)?.exists === false ? 'That’s been removed from the job, so it can’t be opened.' : 'That can’t be opened from here.', { warn: true }); return; }
-  openLink(n.link);
+/*
+  Open, for what a link is for: the host's own way (another screen, a sheet over the drawing), or — the user's call,
+  2026-10-30 — in a pane beside the drawing, a split view, where the host has one (CadLinks.openBeside). The bar's Open
+  asks which while no pane is open (opensWithChoice); once one is, Open goes to it.
+*/
+
+/** How Open opens: `here`, the host's own way; `beside`, in a pane beside the drawing; `auto`, beside if one's open. */
+export type OpenHow = 'auto' | 'here' | 'beside';
+
+/** Open what the selected tile, or the selected expanded photo, is for. */
+export function openSelectedLink(how: OpenHow = 'auto'): void {
+  const t = selectedLink()?.link ?? selectedLinkedImage()?.link;
+  if (t) openLinkTarget(t, how);
+}
+
+/** What the bar's Open is for: the selected tile's or expanded photo's link, or the selected linked dimension's. */
+export function selectedOpenTarget(): LinkTarget | null {
+  const t = selectedLink()?.link ?? selectedLinkedImage()?.link;
+  if (t) return t;
+  const s = ed.sel;
+  return s.length === 1 && s[0].type === 'dim' ? SK().cons[s[0].id]?.measurementRef ?? null : null;
+}
+
+/** Whether Open asks how to open `t`: the host can show it beside the drawing, and no pane's open yet. */
+export function opensWithChoice(t: LinkTarget): boolean {
+  return canOpenLink(t) && canOpenBeside(t) && !besideOpen();
+}
+
+/** Open what `t` is for, `how` it's asked to (see OpenHow); one that's gone, or can't be, says so instead. */
+export function openLinkTarget(t: LinkTarget, how: OpenHow = 'auto'): void {
+  if (!canOpenLink(t)) {
+    const gone = linkInfoOf(t)?.exists === false;
+    toast(!gone ? 'That can’t be opened from here.'
+      : t.kind === 'measurement' ? 'That measurement has been removed from the job, so it can’t be opened.'
+      : 'That’s been removed from the job, so it can’t be opened.', { warn: true });
+    return;
+  }
+  if ((how === 'beside' || (how === 'auto' && besideOpen())) && canOpenBeside(t)) openLinkBeside(t);
+  else openLink(t);
+}
+
+/** An expanded photo's badge, tapped: what it's for opens (beside the drawing, if a pane's open there). */
+export function openImageLink(id: string): void {
+  const t = imageById(id)?.link;
+  if (t) openLinkTarget(t);
+}
+
+/*
+  A photo's tile expands into the photo whole, and back (the user's call, 2026-10-26: "for image objects … you should
+  be able to expand and condense the tile … this is how skia works, it expands the image to full size + shows a link
+  icon in the corner"). Expanded, it's one of the page's images — moved, sized, cropped, turned, faded and locked as
+  any is — with the link's badge in its corner; Expand in the bar (on) folds it back into its tile where it is. An image
+  from the computer has no link, so none of this. Each way is one undo step, and what was selected stays selected.
+*/
+
+/** The one selected image, if it's a photo expanded from its tile and all that's selected. */
+export function selectedLinkedImage(): (Underlay & { link: LinkTarget }) | null {
+  if (ed.sel.length !== 1 || ed.sel[0].type !== 'underlay') return null;
+  const u = imageById(ed.sel[0].id);
+  return u?.link ? (u as Underlay & { link: LinkTarget }) : null;
+}
+
+/** Whether a tile can expand: a photo's (not a sketch's, a document's or a measurement's), and the photo still there. */
+export function canExpand(n: Note & { link: LinkTarget }): boolean {
+  const info = linkInfoOf(n.link);
+  return tileTypeOf(n, info) === 'image' && info?.exists !== false;
+}
+
+/**
+ * A photo's tile, expanded: the photo whole where the tile was, as big as it fits in 60% of the screen across and 80%
+ * down (an image from the computer is placed 60% across), at full strength, free to move.
+ */
+export function expandLink(id: string): void {
+  const sk = SK(), at = sk.notes.findIndex(x => x.id === id), n = sk.notes[at];
+  if (!n || !isLink(n) || !canExpand(n) || ed.readOnly) return;
+  const url = linkInfoOf(n.link)?.thumbUrl, im = url ? linkThumb(url) : null;
+  if (!im?.complete || !im.naturalWidth) { toast('The photo is still loading. Try again in a moment.', { warn: true }); return; }
+  const T = mainT(), aspect = (im.naturalHeight || 1) / im.naturalWidth;
+  const w = Math.min(cvs.W * 0.6, (cvs.H * 0.8) / aspect) / T.s, h = w * aspect;
+  const { x = 0, y = 0, link, ...tile } = n;
+  pushHistory();
+  sk.notes.splice(at, 1);
+  const u: Underlay = { id: uid('img'), src: '', x: x - w / 2, y: y + h / 2, w, h, opacity: 1, locked: false, link, tile };
+  page().underlays.push(u);
+  settings.layers.underlay = true;
+  ed.sel = [{ type: 'underlay', id: u.id }];
+  afterEdit();
+}
+
+/** An expanded photo, folded back into its tile: where the photo's middle is, the page's tiles' size, its leader back. */
+export function collapseLink(id: string): void {
+  const u = imageById(id);
+  if (!u?.link || ed.readOnly) return;
+  if (u.locked) { toast('This photo is locked. Unlock it to fold it back into its tile.', { warn: true }); return; }
+  const sk = SK(), m = underlayMid(u), was = u.tile ? (JSON.parse(JSON.stringify(u.tile)) as Omit<Note, 'x' | 'y' | 'link'>) : null;
+  const ts = pageLinkSize(sk) ?? was?.ts ?? Math.round(clamp(LINK_TILE_PX / mainT().s, LINK_MIN_IN, LINK_MAX_IN) * 4) / 4;
+  const n: Note = { ...(was ?? { id: '', type: 'link', color: LINK_COLOR }), type: 'link', x: m.x, y: m.y, ts, link: u.link };
+  if (!n.id || sk.notes.some(x => x.id === n.id)) n.id = uid('lk');
+  pushHistory();
+  // (the page's only tile, back: its size is the 100%, unless the page already has one)
+  if (pageLinkSize(sk) == null && sk.tileRef == null) sk.tileRef = ts;
+  page().underlays.splice(page().underlays.indexOf(u), 1);
+  sk.notes.push(n);
+  ed.sel = [{ type: 'note', id: n.id }];
+  afterEdit();
+}
+
+/** Expand in the bar: the selected photo's tile expanded, or the selected expanded photo folded back. */
+export function toggleExpand(): void {
+  const n = selectedLink(), u = selectedLinkedImage();
+  if (n) expandLink(n.id);
+  else if (u) collapseLink(u.id);
 }
 
-/** A view-only tap on the plan: on a link's tile, the person is asked, then what it's for opens. */
+/** A view-only tap on the plan: on a link's tile or an expanded photo's badge, the person is asked, then what it's for opens. */
 export function readOnlyTap(sx: number, sy: number, touch: boolean): void {
   if (!ed.readOnly || !canLink()) return;
-  const n = linkAt(sx, sy, touch);
-  if (!n || !canOpenLink(n.link)) return;
-  const t = n.link, where = linkInfoOf(t)?.groupName ?? t.groupName;
+  const t = linkAt(sx, sy, touch)?.link ?? imageLinkAt(sx, sy, touch)?.link;
+  if (!t || !canOpenLink(t)) return;
+  const where = linkInfoOf(t)?.groupName ?? t.groupName;
   askConfirm({
     title: 'Open ' + linkName(t) + '?',
     msg: where ? 'It’s in ' + where + '.' : undefined,
-    choices: [{ label: 'Open', run: () => openLink(t) }, { label: 'Cancel', run: () => {} }],
+    choices: [
+      { label: 'Open', run: () => openLinkTarget(t, 'here') },
+      ...(canOpenBeside(t) ? [{ label: 'Open side by side', run: () => openLinkTarget(t, 'beside') }] : []),
+      { label: 'Cancel', run: () => {} },
+    ],
   });
 }
 
@@ -157,11 +297,9 @@ export function unlinkDim(id: string): void {
 }
 
 /** Open the measurement a dimension is linked to. */
-export function openDimLink(id: string): void {
+export function openDimLink(id: string, how: OpenHow = 'auto'): void {
   const t = SK().cons[id]?.measurementRef;
-  if (!t) return;
-  if (!canOpenLink(t)) { toast(linkInfoOf(t)?.exists === false ? 'That measurement has been removed from the job, so it can’t be opened.' : 'That can’t be opened from here.', { warn: true }); return; }
-  openLink(t);
+  if (t) openLinkTarget(t, how);
 }
 
 /**

package/src/editor/links.ts

@@ -1,4 +1,4 @@
-import { linkInfo, linkKey, linkTargets } from '../model/links';
+import { linkInfo, linkInfoOf, linkKey, linkTargets } from '../model/links';
 import { onSessionReset } from '../model/session';
 import { store } from '../model/store';
 import type { LinkInfo, LinkTarget } from '../model/types';
@@ -67,6 +67,13 @@ export interface CadLinks {
   subscribe(targets: LinkTarget[], cb: (info: Record<string, LinkInfo>) => void): () => void;
   /** Open what `target` is for (another screen, or a sheet over the drawing). */
   open(target: LinkTarget): void;
+  /**
+   * Open what `target` is for in a pane beside the drawing (a split view), the drawing staying as it is. With this, the
+   * bar's Open asks how — Open, or Open side by side — until a pane is open (besideOpen), when Open goes to it.
+   */
+  openBeside?(target: LinkTarget): void;
+  /** Whether a pane is open beside the drawing now (with openBeside). */
+  besideOpen?(): boolean;
   /** Change a linked measurement (micrometres, or degrees), the person having said to; `capture` as saveMeasurement's. */
   update?(target: LinkTarget, value: number, capture?: unknown): void;
   /** Save a dimension as a new measurement in the drawing's own group; resolves with it (null: not saved). */
@@ -179,3 +186,12 @@ export async function pickJobMeasurement(kind: MeasurementKind): Promise<LinkTar
 
 /** Open what a link is for. */
 export function openLink(t: LinkTarget): void { host?.open(t); }
+
+/** Open what a link is for in a pane beside the drawing (CadLinks.openBeside). */
+export function openLinkBeside(t: LinkTarget): void { host?.openBeside?.(t); }
+
+/** Whether the host can show `t` in a pane beside the drawing. */
+export function canOpenBeside(t: LinkTarget): boolean { return !!host?.openBeside && linkInfoOf(t)?.canOpenBeside !== false; }
+
+/** Whether a pane is open beside the drawing now. */
+export function besideOpen(): boolean { return !!host?.besideOpen?.(); }

package/src/editor/mode.ts

@@ -58,12 +58,14 @@ export const railIcon = (id: string): string => WALL_ICON[id] ?? id;
 /** The tool rail for each mode. 'toggle' items switch something on and off; 'act' items run an action. */
 export const RAIL: Record<Mode, RailItem[]> = {
   draft: [
-    // drawing; then the building (walls, what goes in them, spaces); then measuring and guides
-    ['select', 'Select', 'V'], ['line', 'Line', 'L'], ['freehand', 'Draw to shape', 'S'], ['rect', 'Rectangle', 'R'], ['circle', 'Circle', 'C'], ['arc', 'Arc', 'A'], '|',
+    // drawing, and Trim last of it (the user's call, 2026-11-03); then the building (walls, what goes in them, spaces);
+    // then guides
+    ['select', 'Select', 'V'], ['line', 'Line', 'L'], ['freehand', 'Draw to shape', 'S'], ['rect', 'Rectangle', 'R'], ['circle', 'Circle', 'C'], ['arc', 'Arc', 'A'], ['trim', 'Trim', 'T'], '|',
     ['door', 'Door', 'B'], ['window', 'Window', 'N'], ['room', 'Space', 'M'], '|',
-    // Trim (T) and Offset (O) stay on the keyboard; Offset is also in the bar for a selected line.
+    // Offset (O) and Dimension (D) stay on the keyboard; Offset is also in the bar for a selected line, and measuring is
+    // the yellow + for what's selected (the user's call, 2026-10-24: no Dimension on the rail).
     // The toggles together: what's drawn is walls, or guides (one or the other, never both)
-    ['dim', 'Dimension', 'D'], ['wall', 'Walls', 'W', 'toggle'], ['constr', 'Construction lines', 'X', 'toggle'], '|',
+    ['wall', 'Walls', 'W', 'toggle'], ['constr', 'Construction lines', 'X', 'toggle'], '|',
     ['undo', 'Undo', '⌘Z', 'act'], ['redo', 'Redo', '⇧⌘Z', 'act'],
   ],
   annotate: [
@@ -78,7 +80,8 @@ export const RAIL: Record<Mode, RailItem[]> = {
 /**
  * Tools that share one place on a phone's rail, which has no room for each: a tap draws with the one used last (the
  * place shows it), and a long press opens a menu of them all (react/ShapeMenu.tsx) — Draft's Line, Rectangle, Circle
- * and Arc, and Annotate's markup shapes. A tablet's or a browser's rail shows every one in its own place.
+ * and Arc, and Annotate's markup shapes. A tablet's or a browser's rail shows every one in its own place. (Trim isn't
+ * one of them: on a phone it has its own place, under Draw to shape — the user's call, 2026-11-03.)
  */
 export const SHAPE_TOOLS = ['line', 'rect', 'circle', 'arc'];
 export const SHAPES_GROUP = 'shapes';

package/src/editor/project.ts

@@ -83,11 +83,10 @@ export type LayerKey = keyof Layers | 'showCons';
 export const LAYER_ROWS: [LayerKey, string, string][] = [
   ['construction', 'Construction lines', 'Dashed guides'],
   ['dims', 'Driving dimensions', 'Blue chips that set sizes'],
-  ['print', 'Print dimensions', 'Labels for the crew; never move geometry'],
   ['rooms', 'Spaces', 'Fill, name and area'],
   ['cabinets', 'Cabinets', 'Their footprints, from each wall’s view'],
   ['annot', 'Markup', 'Pen, arrows, shapes, clouds and notes'],
-  ['showCons', 'Constraint icons', 'H, V, ∥, ⊥ badges'],
+  ['showCons', 'Constraint icons', 'H, V, ∥, ⊥ and lock badges'],
 ];
 
 export const layerOn = (k: LayerKey): boolean => (k === 'showCons' ? settings.showCons : settings.layers[k]);