@reekon-tools/boldr-cad 1.3.0 → 1.5.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,7 @@ 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; }
+  if (e.key === 'Enter' && ed.mode === 'annotate' && (selectedLink() || selectedLinkedImage())) { openSelectedLink(); return true; }
   if (e.shift) {
     const c = SHIFT_CONS[e.key.toUpperCase()];
     if (c && ed.mode === 'draft') { applyCtxAction(c); return true; }

package/src/editor/linkActions.ts

@@ -5,11 +5,14 @@ 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 { 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, 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';
@@ -126,20 +129,94 @@ export function toggleLeader(id: string): void {
   afterEdit();
 }
 
-/** Open what the selected tile is for. */
+/** Open what the selected tile, or the selected expanded photo, 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);
+  const t = selectedLink()?.link ?? selectedLinkedImage()?.link;
+  if (t) openTarget(t);
 }
 
-/** A view-only tap on the plan: on a link's tile, the person is asked, then what it's for opens. */
+function openTarget(t: LinkTarget): void {
+  if (!canOpenLink(t)) { toast(linkInfoOf(t)?.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(t);
+}
+
+/** An expanded photo's badge, tapped: what it's for opens. */
+export function openImageLink(id: string): void {
+  const t = imageById(id)?.link;
+  if (t) openTarget(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, stretched, 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();
+  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 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,

package/src/editor/mode.ts

@@ -58,12 +58,13 @@ 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
+    // drawing; 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'], '|',
     ['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.
+    // Trim (T), 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: [

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]);

package/src/editor/scaleGate.ts

@@ -0,0 +1,32 @@
+import { isUnscaled } from '../model/scale';
+import { planSK } from '../model/store';
+import { fmtLen } from '../units';
+import { toast } from './ports';
+
+/*
+  Before a new page's first length (model/scale.ts), its sizes are placeholders. So nothing shows one as if it were
+  real, and what needs real sizes waits: the 3D view, the wall view, doors, windows and cabinets (the user's call,
+  2026-10-29), and the tools whose typed size has nothing drawn to be compared with (offset, fillet, chamfer).
+*/
+
+/** The page being drawn has no scale yet: its sizes are placeholders. */
+export const noScaleYet = (): boolean => isUnscaled(planSK());
+
+export const NEEDS_SCALE = 'Enter a length first: select a line and tap +. It sets the size of the whole drawing.';
+
+/** What needs real sizes, asked for before the page has its scale: says what to do first, and true (wait). */
+export function waitForScale(): boolean {
+  if (!noScaleYet()) return false;
+  toast(NEEDS_SCALE, { warn: true });
+  return true;
+}
+
+/** Tools that place something with a real size, or take one typed: doors, windows and cabinets (the plan's and the wall view's), offsets. */
+const SIZED_TOOLS = new Set(['door', 'window', 'wdoor', 'wwindow', 'cabinet', 'height', 'offset']);
+export const toolWaitsForScale = (t: string): boolean => SIZED_TOOLS.has(t);
+
+/** A length being entered, as its label shows it: what's typed, else what it measures now — nothing while that's a placeholder. */
+export const pendingLabel = (typed: number | null, now: number): string => (typed != null ? fmtLen(typed) : noScaleYet() ? '' : fmtLen(now));
+
+/** A keypad's starting value: what it measures now, or nothing while that's only a placeholder. */
+export const startingValue = (v: number): { initial: string; value?: number } => (noScaleYet() ? { initial: '' } : { initial: fmtLen(v), value: v });

package/src/editor/selection.ts

@@ -11,9 +11,13 @@ import { faceLength } from '../model/wallfaces';
 import { planSK, SK } from '../model/store';
 import type { Sketch } from '../model/types';
 import { fmtArea, fmtLen } from '../units';
+import { noScaleYet } from './scaleGate';
 
 /* What is selected, grouped by kind, and the one-line hint describing it (bold parts in <b>). */
 
+/** A size in a hint, after a space — none on a drawing without its scale yet (a placeholder isn't a size). */
+const sized = (text: string): string => (noScaleYet() ? '' : ' ' + text);
+
 export function selInfo() {
   const g = (t: string) => ed.sel.filter(s => s.type === t).map(s => s.id);
   const circles = g('circle'), arcs = g('arc');
@@ -54,13 +58,13 @@ export function selectionHint(): string {
   if (s.n === 1 && s.lines.length && sk.lines[s.lines[0]]?.anchor) return '<b>Set by the plan</b> · pick a point or line too, to constrain or dimension to it';
   if (s.n === 1 && s.lines.length) {
     const l = sk.lines[s.lines[0]];
-    return '<b>' + (l.kind === 'wall' ? 'Wall' : l.constr ? 'Construction line' : 'Line') + ' ' + fmtLen(lineLen(sk, l)) + '</b> · ' + (lineDefined(ed.ana, l) ? 'fully defined' : lengthDimOf(sk, s.lines[0]) ? 'pick a constraint below or drag to adjust' : 'tap <b>+</b> below ' + forLength() + ', or pick a constraint');
+    return '<b>' + (l.kind === 'wall' ? 'Wall' : l.constr ? 'Construction line' : 'Line') + sized(fmtLen(lineLen(sk, l))) + '</b> · ' + (lineDefined(ed.ana, l) ? 'fully defined' : lengthDimOf(sk, s.lines[0]) ? 'pick a constraint below or drag to adjust' : 'tap <b>+</b> below ' + forLength() + ', or pick a constraint');
   }
   if (s.n === 1 && s.wfaces.length) {
     const [id, side] = edgeOf(s.wfaces[0]);
     // (a curved wall's: its diameter across it)
-    if (!sk.lines[id]) return '<b>' + edgeLabel(sk, id, side) + ' Ø ' + fmtLen(measure(sk, { type: 'diam', c: id, face: side })) + '</b> · tap <b>+</b> for its diameter';
-    return '<b>' + edgeLabel(sk, id, side) + ' ' + fmtLen(faceLength(sk, id, side)) + '</b> · tap <b>+</b> ' + forLength() + ', or pick another edge or a point to measure from it';
+    if (!sk.lines[id]) return '<b>' + edgeLabel(sk, id, side) + sized('Ø ' + fmtLen(measure(sk, { type: 'diam', c: id, face: side }))) + '</b> · tap <b>+</b> for its diameter';
+    return '<b>' + edgeLabel(sk, id, side) + sized(fmtLen(faceLength(sk, id, side))) + '</b> · tap <b>+</b> ' + forLength() + ', or pick another edge or a point to measure from it';
   }
   if (edgePair(s)) {
     const one = s.wfaces.length === 2 && edgeOf(s.wfaces[0])[0] === edgeOf(s.wfaces[1])[0];
@@ -75,6 +79,7 @@ export function selectionHint(): string {
   if (s.n === 1 && s.cons.length) return '<b>' + consLabel(sk.cons[s.cons[0]]) + '</b> constraint · delete it to free the shape';
   if (s.n === 1 && s.rooms.length) {
     const r = sk.rooms[s.rooms[0]], g = roomGeom(sk, r);
+    if (noScaleYet()) return '<b>' + r.name + '</b> · its area shows once the drawing has a length';
     return '<b>' + r.name + '</b> · ' + fmtArea(g.area) + ' · ' + fmtLen(g.per) + ' perimeter';
   }
   if (s.n === 1 && s.openings.length) {
@@ -86,7 +91,6 @@ export function selectionHint(): string {
   }
   if (s.n === 1 && s.dims.length) {
     const c = sk.cons[s.dims[0]];
-    if (c.layer === 'print') return '<b>Print dimension</b> · drag to move the label';
     if (c.measurementRef) return '<b>' + consLabel(c) + '</b> · linked to <b>' + linkName(c.measurementRef) + '</b> · tap <b>+</b> to change it';
     return '<b>' + consLabel(c) + '</b> · tap <b>+</b> to change it';
   }
@@ -96,9 +100,11 @@ export function selectionHint(): string {
     if (part === 'w') return '<b>' + (planSK().openings[s.odims[0].split('|')[0]]?.type === 'door' ? 'Door' : 'Window') + ' width</b> · tap <b>+</b> to change it';
     return part.startsWith('d:') ? '<b>Door/window dimension</b> · tap <b>+</b> to change it' : '<b>Distance to the wall end</b> · tap <b>+</b> to lock it';
   }
-  if (s.n === 1 && s.image) return imageById(ed.sel[0].id)?.locked
-    ? '<b>Image</b> · locked — tap Unlock to move or resize it'
-    : '<b>Image</b> · drag to move · corners scale, side handles stretch';
+  if (s.n === 1 && s.image) {
+    // (a photo of the job's, expanded from its tile: its link opens it, and Expand folds it back)
+    const u = imageById(ed.sel[0].id), what = u?.link ? '<b>Photo</b>' : '<b>Image</b>', link = u?.link ? ' · its link opens it' : '';
+    return u?.locked ? what + ' · locked — tap Unlock to move or resize it' + link : what + ' · drag to move · corners scale, side handles stretch' + link;
+  }
   if (s.n === 1 && s.notes.length && SK().notes.find(n => n.id === s.notes[0])?.type === 'link') return '<b>Link</b> · drag to move · open it, or point it at the drawing with a leader, below · Size sizes every tile on the page';
   if (s.notes.length) return 'Drag to move. Turn a pen stroke into lines below.';
   return '<b>' + s.n + ' selected</b> · choose a constraint below';

package/src/editor/tooltips.ts

@@ -1,5 +1,6 @@
 import { ed } from '../app/state';
 import { settings } from '../model/settings';
+import { noScaleYet, toolWaitsForScale } from './scaleGate';
 
 /*
   What a tool does, said in a line when it's picked from the rail (a quick note under the Annotate / Draft tabs that
@@ -34,14 +35,21 @@ const TIPS: Record<string, string> = {
   text: 'Tap where it goes, then type.',
 };
 
+/** The tools that draw shapes: on a page without its scale, what they draw is a sketch. */
+const SKETCHING = new Set(['line', 'freehand', 'rect', 'circle', 'arc']);
+
 /**
  * The line for a rail item just picked (its name in bold), or null if it has none (Undo, a colour, an action) or the
  * notes are turned off (••• → Tool tips).
  */
 export function toolTip(id: string, label: string): string | null {
   if (settings.toolTips === false) return null;
+  // (on a page without its scale a door, a window or an offset isn't picked: a toast says to enter a length first)
+  if (toolWaitsForScale(id) && noScaleYet()) return null;
   if (id === 'constr') return ed.drawConstr ? '<b>Construction lines on</b> · new lines are dashed guides.' : '<b>Construction lines off</b> · new lines are solid.';
   if (id === 'wall') return ed.drawWalls ? '<b>Walls on</b> · what you draw is walls.' : '<b>Walls off</b> · what you draw is lines.';
   const t = TIPS[id];
+  // drawing on a page without its scale: sketched in proportion, sized by its first length (editor/scaleGate.ts)
+  if (t && SKETCHING.has(id) && noScaleYet()) return '<b>' + label + '</b> · ' + t + ' Your first length sets the size.';
   return t ? '<b>' + label + '</b> · ' + t : null;
 }

package/src/editor/view3d.ts

@@ -16,6 +16,7 @@ import type { KeyIn } from './keys';
 import { setMode } from './mode';
 import { dismissConflict, dismissPopovers, refreshModes, updateCtx, updateHint, updateRail } from './ports';
 import { command3d, pick3d, v3 } from './view3dState';
+import { waitForScale } from './scaleGate';
 
 /*
   The 3D tab: opening and leaving it, its rail's views, what the bar shows for something tapped in it (its sizes, the
@@ -30,9 +31,12 @@ import { command3d, pick3d, v3 } from './view3dState';
 export const view3dKey = (): string =>
   [store.curPageId, ed.editSeq, settings.wallH, v3.cutaway, v3.cmd.seq, v3.pick ? v3.pick.kind + ':' + v3.pick.id : ''].join('|');
 
-/** Show the 3D tab: whatever tool was in hand is put down, and nothing is selected. */
+/**
+ * Show the 3D tab: whatever tool was in hand is put down, and nothing is selected. Not before the page's first length:
+ * its walls' heights are real and their lengths only placeholders until then (editor/scaleGate.ts).
+ */
 export function open3d(): void {
-  if (v3.open) return;
+  if (v3.open || waitForScale()) return;
   cancelTool();
   dismissPopovers();
   if (elevOpen()) closeElevation();

package/src/export/pdf.ts

@@ -20,10 +20,13 @@ const SCALES: [k: number, label: string][] = [
   [3 / 16, '3/16"'], [1 / 8, '1/8"'], [3 / 32, '3/32"'], [1 / 16, '1/16"'], [1 / 32, '1/32"'],
 ];
 
-/** Pick a scale for a drawing w × h inches: points per world inch, and its label. */
-export function pickScale(w: number, h: number): { s: number; label: string } {
+/**
+ * Pick a scale for a drawing w × h inches: points per world inch, and its label. A sketch without a scale yet (its
+ * sizes only placeholders: model/scale.ts) is fitted to the sheet, not to scale.
+ */
+export function pickScale(w: number, h: number, sketchOnly = false): { s: number; label: string } {
   const aw = AREA.x1 - AREA.x0, ah = AREA.y1 - AREA.y0;
-  for (const [k, label] of SCALES) {
+  if (!sketchOnly) for (const [k, label] of SCALES) {
     const s = (72 * k) / 12;
     if (w * s <= aw && h * s <= ah) return { s, label: label + " = 1'-0\"" };
   }
@@ -166,7 +169,7 @@ export function sketchToPdf(sk: Sketch, opts: PdfOptions = {}): string {
   const rec = new Recorder();
   emitDrawing(sk, rec, opts);
   const bb = rec.bbox();
-  const { s, label } = bb ? pickScale(bb.x1 - bb.x0, bb.y1 - bb.y0) : { s: 1, label: 'Not to scale' };
+  const { s, label } = bb ? pickScale(bb.x1 - bb.x0, bb.y1 - bb.y0, !!sk.unscaled) : { s: 1, label: 'Not to scale' };
   const cx = bb ? (bb.x0 + bb.x1) / 2 : 0, cy = bb ? (bb.y0 + bb.y1) / 2 : 0;
   const ox = (AREA.x0 + AREA.x1) / 2, oy = (AREA.y0 + AREA.y1) / 2;
   const T = (p: XY): XY => ({ x: ox + (p.x - cx) * s, y: oy + (p.y - cy) * s });