@reekon-tools/boldr-cad 1.4.0 → 1.5.0

package/src/tools/dim.ts

@@ -1,9 +1,9 @@
 import { afterEdit, holdGroups, tryAddConstraint } from '../app/edit';
 import { ed } from '../app/state';
 import { measure } from '../model/constraints';
-import { hyp, norm2, pointInPoly, projT } from '../model/geom';
+import { hyp, norm2, projT } from '../model/geom';
 import { dropHistory, pushHistory } from '../model/history';
-import { addCons, lengthDimOf, lineLen, roomValid } from '../model/sketch';
+import { lengthDimOf, lineLen } from '../model/sketch';
 import { SK } from '../model/store';
 import type { Constraint, LinkTarget, OpeningEdge, Sketch, WallFace, XY } from '../model/types';
 import { askLinkedChange, changesValue } from '../editor/linkWrite';
@@ -25,6 +25,7 @@ import type { PEv } from './registry';
 import { keypadFresh, keypadOpen, keypadSetReading } from '../editor/keypad';
 import { cornerLines } from '../editor/selection';
 import { closeKeypad, kpTyped, openKeypad, showConflict, toast, updateCtx, updateHint, type KeypadSpec } from '../editor/ports';
+import { noScaleYet, pendingLabel, startingValue } from '../editor/scaleGate';
 
 export const dimTool = {
   /** angle: the first pick is a corner whose angle keypad is open (the next tap closes it) */
@@ -66,7 +67,7 @@ export const dimTool = {
   move(ev: PEv) { this.hover(ev); },
   up(ev: PEv) {
     const h = pickForDim(ev);
-    const print = ed.dimLayer === 'print', st = this.st;
+    const st = this.st;
     // a corner's angle keypad is open: the next tap closes it and goes on (a second point measures from the corner)
     if (st.angle) { st.angle = false; if (keypadOpen()) closeKeypad(); }
     if (!h || h.type === 'room') { st.first = null; ed.pickedAnchor = null; ed.sel = []; ed.preview = null; updateHint(); requestDraw(); return; }
@@ -74,7 +75,6 @@ export const dimTool = {
     const picked = ed.pickedAnchor;
     if (h.type === 'oanchor') {
       const edge = h.part as OpeningEdge;
-      if (print) { toast('Print dimensions can’t attach to doors or windows yet. Switch to Driving in the bar below.', { warn: true }); return; }
       if (st.first) {
         const p = st.first; st.first = null; ed.sel = [];
         addOpeningDim(h.id, h.weak ? nearerEdge(SK(), h.id, p) : edge, { pt: p });
@@ -101,10 +101,10 @@ export const dimTool = {
       if (!st.first) {
         st.first = h.id; ed.sel = [{ type: 'point', id: h.id }];
         // a corner: its angle straight away (close the keypad to measure from the corner to another point instead)
-        if (!print) st.angle = cornerAngle(h.id, () => { this.st.first = null; this.st.angle = false; ed.sel = []; updateHint(); requestDraw(); }, true);
+        st.angle = cornerAngle(h.id, () => { this.st.first = null; this.st.angle = false; ed.sel = []; updateHint(); requestDraw(); }, true);
         updateHint(); requestDraw(); return;
       }
-      if (h.id !== st.first) dimPoints(st.first, h.id, print);
+      if (h.id !== st.first) dimPoints(st.first, h.id);
       st.first = null; updateHint();
       return;
     }
@@ -113,14 +113,14 @@ export const dimTool = {
     if (h.type === 'wface') {
       const [lid, side] = edgeOf(h.id);
       if (!SK().lines[lid]) { dimCurve(lid, side); return; }
-      if (st.first) { const p = st.first; st.first = null; if (print) dimPointLine(p, lid); else dimEdgePoint(lid, side, p); updateHint(); return; }
-      dimLine(lid, print, side);
+      if (st.first) { const p = st.first; st.first = null; dimEdgePoint(lid, side, p); updateHint(); return; }
+      dimLine(lid, side);
       return;
     }
     if (h.type === 'line') {
       if (h.side) ed.wallTap = { id: h.id, side: h.side };
       if (st.first) { dimPointLine(st.first, h.id); st.first = null; updateHint(); return; }
-      dimLine(h.id, print);
+      dimLine(h.id);
       return;
     }
     if (h.type === 'circle' || h.type === 'arc') {
@@ -131,7 +131,7 @@ export const dimTool = {
   hint() {
     if (ed.pickedAnchor) return 'Tap a corner or point to measure from. The door or window locks at that distance.';
     if (this.st.first) return 'Tap a second point, a door or window edge, or a line for the offset distance.';
-    return ed.dimLayer === 'print' ? 'Print dimensions are labels for the crew — they never move the drawing. Tap a line or two points.' : 'Tap a line, a circle, or two points — door and window edges count as points. Then type the value.';
+    return 'Tap a line, a circle, or two points — door and window edges count as points. Then type the value.';
   },
 };
 
@@ -153,34 +153,15 @@ function pickForDim(ev: PEv): Hit | null {
   return a ? { type: 'oanchor', id: a.id, part: a.edge, weak: true } : h;
 }
 
-/** +1 or -1: the side of a line that faces away from any room (for print dimension offsets). */
-function sideAwayFromRooms(lid: string): number {
-  const sk = SK(), l = sk.lines[lid], a = sk.points[l.a], b = sk.points[l.b];
-  const n = norm2(-(b.y - a.y), b.x - a.x);
-  const m = { x: (a.x + b.x) / 2 + n[0] * 12, y: (a.y + b.y) / 2 + n[1] * 12 };
-  for (const id in sk.rooms) { const r = sk.rooms[id]; if (roomValid(sk, r) && pointInPoly(m, r.loop.map(p => sk.points[p]))) return -1; }
-  return 1;
-}
-
 /**
  * Tap on a line (or its + chip): open the keypad for its length, or edit the existing length. A wall's is measured on
  * `side`, the edge picked — or, picked whole, on the side a space is on (the side it was tapped on, between two), and
  * along its centerline where there's no space; the keypad can switch it.
  */
-export function dimLine(lid: string, print: boolean, side?: 1 | -1): void {
+export function dimLine(lid: string, side?: 1 | -1): void {
   const sk = SK(), l = sk.lines[lid];
   if (!l) return;
   const wall = faced(sk, lid);
-  if (print) {
-    pushHistory();
-    // (on a wall's edge: that face's length, labelled on that side)
-    const f = wall ? side : undefined;
-    const off = (36 / V().s) * (f ?? sideAwayFromRooms(lid));
-    addCons(sk, { type: 'dist', a: l.a, b: l.b, kind: 'al', value: f ? faceLength(sk, lid, f) : lineLen(sk, l), line: lid, driving: false, layer: 'print', off, ...(f ? { face: f } : {}) });
-    afterEdit();
-    toast('Print dimension added. Drag it to move it.');
-    return;
-  }
   const ex = lengthDimOf(sk, lid);
   if (ex) { editDim(ex, undefined, false, wall && side ? { face: side } : undefined); return; }
   let face: 0 | 1 | -1 = wall ? side ?? defaultFace(sk, lid, ed.wallTap?.id === lid ? ed.wallTap.side : undefined) ?? 0 : 0;
@@ -190,10 +171,10 @@ export function dimLine(lid: string, print: boolean, side?: 1 | -1): void {
   const show = () => { ed.sel = face ? [{ type: 'wface', id: edgeId(lid, face) }] : [{ type: 'line', id: lid }]; requestDraw(); };
   show();
   const spec: KeypadSpec = {
-    title: 'Length', sub: wall ? lengthSub(sk, lid, face) : '', initial: fmtLen(len()), value: len(), selectAll: true, laser: true,
+    title: 'Length', sub: wall ? lengthSub(sk, lid, face) : '', ...startingValue(len()), selectAll: true, laser: true,
     extras: wall ? () => lengthChoices(sk, lid).map(ch => ({
       label: ch.label!, on: ch.face === face,
-      onPress: () => { face = ch.face!; spec.sub = lengthSub(sk, lid, face); show(); if (keypadFresh()) keypadSetReading(len()); },
+      onPress: () => { face = ch.face!; spec.sub = lengthSub(sk, lid, face); show(); if (keypadFresh() && !noScaleYet()) keypadSetReading(len()); },
     })) : undefined,
     onClose: () => { ed.sel = was; updateCtx(); requestDraw(); },
     onDone: (v, capture) => { if (v > 0) addLength(v, capture !== undefined ? { capture } : {}); },
@@ -305,7 +286,7 @@ export function faceChoices(sk: Sketch, c: Constraint): FaceChoice[] {
       const l = sk.lines[c.l], a = sk.points[l.a], b = sk.points[l.b], H = Math.abs(b.x - a.x) >= Math.abs(b.y - a.y) ? 'H' : '';
       return [
         { label: 'Inside faces', short: 'Inside', icon: 'spanIn' + H, faces: k(1) },
-        { label: 'Centerlines', short: 'Centers', icon: 'spanMid' + H, faces: [0, 0] },
+        { label: 'Centerlines', short: 'Center', icon: 'spanMid' + H, faces: [0, 0] },
         { label: 'Outside faces', short: 'Outside', icon: 'spanOut' + H, faces: k(-1) },
       ];
     }
@@ -408,22 +389,16 @@ export function dimEdges(items: { type: string; id: string }[], thickness: (lid:
   else if (other.type === 'line') dimTwoLines(lid, other.id, { [lid]: side });
 }
 
-export function dimPoints(a: string, b: string, print: boolean): void {
+export function dimPoints(a: string, b: string): void {
   const sk = SK(), A = sk.points[a], B = sk.points[b];
   const L = hyp(B.x - A.x, B.y - A.y);
-  if (print) {
-    pushHistory();
-    addCons(sk, { type: 'dist', a, b, kind: 'al', value: L, driving: false, layer: 'print', off: 30 / V().s });
-    afterEdit();
-    return;
-  }
   ed.sel = [];
   const n = norm2(-(B.y - A.y), B.x - A.x);
-  ed.preview = (c, T) => drawPendingDim(c, T, { from: A, to: B, a: A, b: B, nx: n[0], ny: n[1], off: 0, label: fmtLen(kpTyped() ?? L) });
+  ed.preview = (c, T) => drawPendingDim(c, T, { from: A, to: B, a: A, b: B, nx: n[0], ny: n[1], off: 0, label: pendingLabel(kpTyped(), L) });
   requestDraw();
   openKeypad({
     onClose: () => { ed.preview = null; requestDraw(); },
-    title: 'Distance', initial: fmtLen(L), value: L, selectAll: true, laser: true,
+    title: 'Distance', ...startingValue(L), selectAll: true, laser: true,
     onDone: (v, capture) => {
       pushHistory();
       const r = tryAddConstraint({ type: 'dist', a, b, kind: 'al', value: v, driving: true, off: 0, ...(capture !== undefined ? { capture } : {}) });
@@ -449,7 +424,7 @@ export function dimTwoLines(l1: string, l2: string, sides: Record<string, 0 | 1
   const kind = parallel ? 'pldist' : 'angle';
   const existing = Object.keys(sk.cons).find(id => {
     const c = sk.cons[id];
-    if (c.type !== kind || c.layer === 'print') return false;
+    if (c.type !== kind) return false;
     if (kind === 'angle') return (c.l1 === l1 && c.l2 === l2) || (c.l1 === l2 && c.l2 === l1);
     return (c.l === l1 && (c.p === L2.a || c.p === L2.b)) || (c.l === l2 && (c.p === L1.a || c.p === L1.b));
   });
@@ -487,15 +462,15 @@ export function dimPointLine(p: string, lid: string, opts: { keepParallel?: stri
   applyFace(c, { faces: opts.faces ?? [faceToward(sk, lid, P), 0] });
   const choices = faceChoices(sk, c);
   ed.sel = [];
-  ed.preview = (cx, T) => { const e = dimEnds(sk, c); if (e) drawPendingDim(cx, T, { from: e.a, to: e.b, a: e.a, b: e.b, nx: 0, ny: 0, off: 0, label: fmtLen(kpTyped() ?? measure(sk, c)) }); };
+  ed.preview = (cx, T) => { const e = dimEnds(sk, c); if (e) drawPendingDim(cx, T, { from: e.a, to: e.b, a: e.a, b: e.b, nx: 0, ny: 0, off: 0, label: pendingLabel(kpTyped(), measure(sk, c)) }); };
   requestDraw();
   const spec: KeypadSpec = {
     onClose: () => { ed.preview = null; requestDraw(); },
     // (which faces it's measured between: the choices beside the keys)
-    title: opts.title || 'Distance to line', sub: opts.keepParallel ? 'Measured square to the lines' : '', initial: fmtLen(measure(sk, c)), value: measure(sk, c), selectAll: true,
+    title: opts.title || 'Distance to line', sub: opts.keepParallel ? 'Measured square to the lines' : '', ...startingValue(measure(sk, c)), selectAll: true,
     extras: choices.length ? () => choices.map(ch => ({
       label: ch.label!, on: onChoice(c, ch),
-      onPress: () => { applyFace(c, ch); requestOverlayDraw(); if (keypadFresh()) keypadSetReading(measure(sk, c)); },
+      onPress: () => { applyFace(c, ch); requestOverlayDraw(); if (keypadFresh() && !noScaleYet()) keypadSetReading(measure(sk, c)); },
     })) : undefined,
     onDone: v => {
       pushHistory();
@@ -525,10 +500,10 @@ export function dimCurve(id: string, side?: 1 | -1): void {
   const show = () => { ed.sel = face ? [{ type: 'wface', id: edgeId(id, face) }] : [{ type, id }]; requestDraw(); };
   show();
   const spec: KeypadSpec = {
-    title: 'Diameter', sub: wall ? lengthSub(sk, id, face) : '', initial: fmtLen(now()), value: now(), selectAll: true,
+    title: 'Diameter', sub: wall ? lengthSub(sk, id, face) : '', ...startingValue(now()), selectAll: true,
     extras: wall ? () => curveChoices(sk, id).map(ch => ({
       label: ch.label!, on: ch.face === face,
-      onPress: () => { face = ch.face!; spec.sub = lengthSub(sk, id, face); show(); if (keypadFresh()) keypadSetReading(now()); },
+      onPress: () => { face = ch.face!; spec.sub = lengthSub(sk, id, face); show(); if (keypadFresh() && !noScaleYet()) keypadSetReading(now()); },
     })) : undefined,
     onClose: () => { ed.sel = was; requestDraw(); },
     onDone: v => {
@@ -549,7 +524,7 @@ export function cornerAngle(pid: string, done?: () => void, modeless = false): b
   const sk = SK(), pair = cornerLines(sk, pid);
   if (!pair) return false;
   // edit the corner's existing angle dimension rather than stacking a second one
-  const ex = Object.keys(sk.cons).find(id => { const c = sk.cons[id]; return c.type === 'angle' && c.layer !== 'print' && ((c.l1 === pair[0] && c.l2 === pair[1]) || (c.l1 === pair[1] && c.l2 === pair[0])); });
+  const ex = Object.keys(sk.cons).find(id => { const c = sk.cons[id]; return c.type === 'angle' && ((c.l1 === pair[0] && c.l2 === pair[1]) || (c.l1 === pair[1] && c.l2 === pair[0])); });
   if (ex) editDim(ex, done, modeless); else dimAngle(pair[0], pair[1], done, modeless);
   return true;
 }
@@ -605,7 +580,7 @@ export function editDim(id: string, done?: () => void, modeless = false, pick?:
   // (which faces it's measured on: the choices beside the keys)
   const spec: KeypadSpec = {
     title,
-    sub: c.driving === false ? (c.layer === 'print' ? 'Print dimension (label only)' : 'Reference — not driving the shape') : 'Driving dimension',
+    sub: c.driving === false ? 'Reference — not driving the shape' : 'Driving dimension',
     numeric: isAng, initial: isAng ? String(Math.round(now() * 10) / 10) : fmtLen(now()), selectAll: true, laser: !isAng, modeless,
     // (just the faces it's measured on: Reference and Delete are the bar's, for a dimension selected)
     extras: () => faceChoices(sk, withFace(c, face)).map(ch => ({
@@ -615,7 +590,7 @@ export function editDim(id: string, done?: () => void, modeless = false, pick?:
     onDone: (v, capture) => { setDimValue(id, v * k, face ?? undefined, { capture }); done?.(); },
     // a line's length or an angle: or one of the job's, from its list — the dimension takes it, linked to it (a
     // dimension already linked to another, re-linked)
-    measurements: ((c.type === 'dist' && c.line) || isAng) && c.layer !== 'print' && offersJobMeasurements() ? {
+    measurements: ((c.type === 'dist' && c.line) || isAng) && offersJobMeasurements() ? {
       kind: isAng ? 'angle' : 'length', pick: t => {
         const v = jobValue(t, isAng ? 'angle' : 'length');
         if (v == null) return;
@@ -671,7 +646,6 @@ function takeLink(c: Constraint, o: DimValueOpts): void {
 export function setDimValue(id: string, v: number, face?: FaceChoice, opts: DimValueOpts = {}): boolean {
   const sk = SK(), c = sk.cons[id];
   if (!c) return false;
-  if (c.layer === 'print') { toast('Print dimensions follow the drawing. Change a driving dimension instead.', { warn: true }); return false; }
   if (c.measurementRef && opts.link === undefined && !opts.asked && !opts.quiet && changesValue(c, v)) {
     askLinkedChange(c, v, unlink => setDimValue(id, v, face, { ...opts, asked: true, ...(unlink ? { link: null } : {}) }), opts.capture);
     return false;

package/src/tools/fillet.ts

@@ -9,6 +9,7 @@ import { requestDraw } from '../render/view';
 import { solver } from '../solver';
 import { fmtLen } from '../units';
 import { openKeypad, toast, updateCtx } from '../editor/ports';
+import { waitForScale } from '../editor/scaleGate';
 import { cornerAt, cutCorner } from './corner';
 
 /*
@@ -33,6 +34,8 @@ export function maxFillet(sk: Sketch, pid: string): number {
 export function filletPrompt(pid: string): void {
   const sk = SK();
   if (!cornerAt(sk, pid)) { toast('Select a corner where two lines meet to round it off.', { warn: true }); return; }
+  // (a radius typed is real: nothing drawn says what it is in a sketch without its scale yet — editor/scaleGate.ts)
+  if (waitForScale()) return;
   const most = maxFillet(sk, pid), start = Math.min(6, most * 0.5);
   openKeypad({
     title: 'Fillet radius', sub: 'Up to ' + fmtLen(most) + ' fits this corner', initial: fmtLen(Math.round(start * 16) / 16), value: Math.round(start * 16) / 16, selectAll: true, laser: true,

package/src/tools/freehand.ts

@@ -3,7 +3,6 @@ import { ed } from '../app/state';
 import { wallBand, type PEv } from './registry';
 import { hyp } from '../model/geom';
 import { dropHistory, pushHistory } from '../model/history';
-import { maybeRoom } from '../model/rooms';
 import { settings } from '../model/settings';
 import { addLine, addPoint } from '../model/sketch';
 import { deg, JOIN_PX, simplifyStroke, SQUARE_DEG, squareUp, turn } from '../model/stroke';
@@ -20,7 +19,6 @@ import { drawsWalls } from '../editor/mode';
   simplified, corners cleaned up, closed if it ends where it began, every segment within 15° of level, plumb or a
   45° diagonal snapped exactly to it (most site sketches are 90s and 45s), joined to points it starts or ends on,
   and (with auto-constrain on) level/plumb segments and square corners constrained, ready to adjust.
-  The same conversion turns a markup pen stroke into lines (convertNote).
 */
 
 /**
@@ -57,7 +55,7 @@ export function strokeToLines(stroke: XY[], opts: { constr?: boolean; kind?: Lin
       if (Math.abs(turn(p, q, r) - 90) < SQUARE_DEG) add({ type: 'perp', l1: lines[j], l2: lines[i] });
     }
   }
-  if (closed && !opts.constr) maybeRoom(sk, ids);
+  // (a closed shape is only a shape: the Space tool makes it a space, as the line tool's)
   return { lines, closed };
 }
 

package/src/tools/line.ts

@@ -2,15 +2,14 @@ import { afterEdit, analyze, tryAddConstraint } from '../app/edit';
 import { ed, type Guide, type Snap } from '../app/state';
 import { hyp, norm2 } from '../model/geom';
 import { pushHistory } from '../model/history';
-import { roomGeom, maybeRoom } from '../model/rooms';
 import { settings } from '../model/settings';
 import { addLine, gc, pinnedPoints } from '../model/sketch';
-import { SK, store } from '../model/store';
+import { isUnscaled, setScale } from '../model/scale';
+import { page, SK, store } from '../model/store';
 import type { LineKind } from '../model/types';
 import { TH } from '../render/theme';
 import { shiftSnap, snap45, snapAt } from '../render/snap';
 import { requestDraw, requestOverlayDraw, S } from '../render/view';
-import { fmtArea } from '../units';
 import { commitPoint, applyPending, lengthPreview, PT, rememberHover, wallBand, type PEv, type Tool } from './registry';
 import { openKeypad, toast, updateCtx, updateHint } from '../editor/ports';
 import type { KeyIn } from '../editor/keys';
@@ -138,19 +137,17 @@ export function makeLineTool(): LineTool {
       const closed = b.id === st.first && st.chain.length >= 3;
       st.chain.push(b.id); st.prev = lid; st.start = b.id;
       pinnedPoints.clear(); pinnedPoints.add(b.id);
-      if (closed) {
-        const loop = st.chain.slice(0, -1);
-        const sk = SK();
-        const rid = kindNow() === 'wall' || !ed.drawConstr ? maybeRoom(sk, loop) : null;
-        this.reset();
-        if (rid) toast(sk.rooms[rid].name + ' added — ' + fmtArea(roomGeom(sk, sk.rooms[rid]).area));
-      }
+      // a closed shape is only a shape: it's made a space by the Space tool, when the person picks it (the user's call,
+      // 2026-10-26: "By default i dont want spaces create at all")
+      if (closed) this.reset();
     },
     typeLength(initial: string) {
       const st = this.st;
       if (!st.start) return;
       const dirs: [string, [number, number]][] = [['→', [1, 0]], ['←', [-1, 0]], ['↑', [0, 1]], ['↓', [0, -1]]];
       let dir = st.dir || [1, 0];
+      // how long the segment is drawn so far (to the pointer: nothing, on a touch screen, after a tap)
+      const from = PT(st.start), drawn = ed.snapState ? hyp(ed.snapState.x - from.x, ed.snapState.y - from.y) : 0;
       openKeypad({
         title: 'Segment length', sub: 'Direction sets where it goes', initial: initial || '',
         extras: () => dirs.map(([label, d]) => ({
@@ -161,11 +158,15 @@ export function makeLineTool(): LineTool {
         })),
         onDone: v => {
           if (v <= 0) return;
+          pushHistory();
+          // the drawing's first length: the sketch is scaled so the segment, as drawn, is that long — as it is, when
+          // nothing was drawn to go by (model/scale.ts). Before it's read where the segment starts: that moves too.
+          const pg = page();
+          if (isUnscaled(pg.sk) && SK() === pg.sk) { setScale(pg, drawn > 1e-6 ? v / drawn : 1); requestDraw(); }
           const a = PT(st.start!);
           const guides: Guide[] = [];
           if (Math.abs(dir[1]) < 1e-9) guides.push({ kind: 'H', from: st.start! });
           else if (Math.abs(dir[0]) < 1e-9) guides.push({ kind: 'V', from: st.start! });
-          pushHistory();
           this.segmentTo({ x: a.x + dir[0] * v, y: a.y + dir[1] * v, kind: 'free', guides }, v);
           afterEdit();
         },

package/src/tools/modify.ts

@@ -15,6 +15,7 @@ import { placeTargets, snapSlide } from '../editor/elevation';
 import { fmtArea, fmtLen } from '../units';
 import type { PEv } from './registry';
 import { openKeypad, toast } from '../editor/ports';
+import { noScaleYet, waitForScale } from '../editor/scaleGate';
 
 /** Hover helper: highlight only geometry of the given types. */
 const hoverOnly = (types: string[]) => (ev: PEv) => {
@@ -118,6 +119,8 @@ export const offsetTool = {
 };
 
 export function offsetPrompt(lid: string, side: number): void {
+  // (a distance typed is real: nothing drawn says what it is in a sketch without its scale yet — editor/scaleGate.ts)
+  if (waitForScale()) return;
   ed.sel = [{ type: 'line', id: lid }];
   requestDraw();
   openKeypad({ title: 'Offset distance', sub: 'Copies the line, kept parallel', initial: '', onDone: v => { if (!v) return; offsetLine(lid, v * side); } });
@@ -185,7 +188,8 @@ export const roomTool = {
     if (!id) { dropHistory(); toast('That area is too small for a space.', { warn: true }); return; }
     ed.sel = [];
     afterEdit();
-    toast(sk.rooms[id].name + ' — ' + fmtArea(roomGeom(sk, sk.rooms[id]).area));
+    // (its area once the drawing has its scale: before, only a placeholder)
+    toast(sk.rooms[id].name + (noScaleYet() ? '' : ' — ' + fmtArea(roomGeom(sk, sk.rooms[id]).area)));
   },
   hint() { return 'Tap inside a closed shape to make a space. Area is measured to the inside face of walls.'; },
 };

package/src/tools/registry.ts

@@ -10,6 +10,7 @@ import { requestDraw, S, type Xform } from '../render/view';
 import { fmtLen } from '../units';
 import { onSessionReset } from '../model/session';
 import { updateCtx, updateHint, updateRail } from '../editor/ports';
+import { noScaleYet, toolWaitsForScale, waitForScale } from '../editor/scaleGate';
 import type { KeyIn } from '../editor/keys';
 import type { DrawCtx } from '../render/ctx';
 import { TH } from '../render/theme';
@@ -36,6 +37,11 @@ export interface Tool {
   hint?(): string;
   /** something half-done that Esc should cancel first (a line in progress, a picked first point…) */
   busy?(): boolean;
+  /**
+   * whether a finger or pencil pressed and moving is placing or dragging something, for a device's magnifier
+   * (render/lens.ts). Unset: whenever one is (a drawing tool places at it all the time).
+   */
+  magnify?(): boolean;
 }
 
 export const tools: Record<string, Tool> = {};
@@ -53,6 +59,8 @@ export function cancelTool(): void {
 }
 
 export function setTool(t: string): void {
+  // (doors, windows, cabinets and offsets have real sizes: they wait for the page's first length — editor/scaleGate.ts)
+  if (toolWaitsForScale(t) && waitForScale()) return;
   if (t === ed.tool && t !== 'select' && t !== 'aselect') { cancelTool(); updateCtx(); updateHint(); return; }
   cancelTool();
   ed.tool = t;
@@ -88,7 +96,8 @@ export function rememberHover(s: Snap | null): void {
 export function lengthPreview(c: DrawCtx, T: Xform, a: XY, b: XY, col?: string): void {
   const [x1, y1] = S(T, a.x, a.y), [x2, y2] = S(T, b.x, b.y);
   const L = hyp(b.x - a.x, b.y - a.y);
-  if (L * T.s < 6) return;
+  // (not on a page without its scale: the length is only a placeholder)
+  if (L * T.s < 6 || noScaleYet()) return;
   chip(c, fmtLen(L), (x1 + x2) / 2, (y1 + y2) / 2 - 16, { bg: '#fff', fg: '#0066FF', border: [col || '#0066FF', 1.5] });
 }
 

package/src/tools/select.ts

@@ -1,16 +1,16 @@
-import { dimEnds, dimRadius, edgeOf, gridSteps, openingFrame } from '../model/planGeom';
+import { angleCorner, angleSweep, arcAngles, dimEnds, dimRadius, edgeOf, gridSteps, inSweep, openingFrame } from '../model/planGeom';
 import { imageById } from '../model/images';
 import { editNoteText } from '../editor/markup';
 import { afterEdit, resolveOpeningsNow, solveSketch, tryAddConstraint } from '../app/edit';
 import { ed, isSel, type BoxSel, type Hit, type Snap } from '../app/state';
-import { clamp, hyp, norm2, projT, segInter } from '../model/geom';
+import { clamp, hyp, norm2, normAng, projT, segInter } from '../model/geom';
 import { dropHistory, pushHistory } from '../model/history';
 import { deep } from '../model/ids';
 import { settings } from '../model/settings';
 import { openingSpan, slideGroup, type SlideGroup } from '../model/openings';
-import { connectedGeometry, joinPoints, mergePoints, restorePos, snapshotPos } from '../model/sketch';
+import { circleEdge, connectedGeometry, joinPoints, mergePoints, restorePos, snapshotPos } from '../model/sketch';
 import { planSK, replaceSK, SK } from '../model/store';
-import type { Note, SelItem, Sketch, Underlay, WallFace } from '../model/types';
+import type { Note, SelItem, Sketch, Underlay, WallFace, XY } from '../model/types';
 import { cabOfPoint, cabPoints, faceEdit, openingOfPoint } from '../model/faces';
 import { pushedOut, syncFace, type Overflow } from '../model/facesolve';
 import { snapCabinetMove } from '../editor/face';
@@ -24,9 +24,16 @@ import type { PEv } from './registry';
 import { onSessionReset } from '../model/session';
 import { openDrawer, setCursor, toast, updateCtx, updateHint } from '../editor/ports';
 import { selectionHint } from '../editor/selection';
+import { openImageLink } from '../editor/linkActions';
+
+/**
+ * An arc the dragged point is an end of: its other end, which end the point is, how far round it goes (kept as it's
+ * dragged), and whether it's closed — dragged all the way round onto its other end (see closeArcs).
+ */
+interface ArcEnd { id: string; other: string; end: 'a' | 'b'; sweep: number; closed: boolean }
 
 type Drag =
-  | { kind: 'point'; id: string; start: { x: number; y: number }; grab: { x: number; y: number }; snap: Snap | null }
+  | { kind: 'point'; id: string; start: { x: number; y: number }; grab: { x: number; y: number }; snap: Snap | null; arcs: ArcEnd[] }
   /** cab: dragging a cabinet (its box where it started): it snaps to corners, the floor, other cabinets */
   | { kind: 'multi'; ids: string[]; start: { x: number; y: number }[]; grab: { x: number; y: number }; cab?: { id: string; box: { u0: number; u1: number; z0: number; z1: number } }; via?: string; gst?: number; gx?: number; gy?: number }
   /** size a circle by its edge; grab: how far out from its centreline it was picked up (a wall's outer face, say) */
@@ -34,6 +41,8 @@ type Drag =
   | { kind: 'dimoff'; id: string }
   /** swing a diameter's line around its circle and move the label in/out */
   | { kind: 'diamlabel'; id: string }
+  /** pull an angle's label off its corner: out (its arc's radius) and round between its two lines */
+  | { kind: 'anglelabel'; id: string }
   /** slide a door/window dimension (width or a placed one) toward or away from its wall */
   | { kind: 'odimoff'; id: string; part: string }
   /** slide a door/window (or the free chain of openings it's locked into) along its wall; grab: s where it was picked up */
@@ -179,6 +188,8 @@ export const selectTool = {
     else if (st.dragging && ed.boxSel) { boxSelect(ed.boxSel, ev.shift); ed.boxSel = null; }
     else if (st.hit) {
       const h = st.hit, now = performance.now();
+      // an expanded photo's badge, tapped: open what it's for
+      if (h.type === 'underlay' && h.part === 'link') { this.st = {}; openImageLink(h.id); updateCtx(); requestDraw(); return; }
       // a cabinet's footprint in the plan: open its wall, the cabinet selected
       if (h.type === 'cabfoot') { const [key, cab] = h.id.split('#'); this.st = {}; openCabinet(key, cab); return; }
       // with a finger or pencil, tapping the selected line again selects everything joined to it (as a double tap does)
@@ -220,6 +231,8 @@ export const selectTool = {
     this.st = {};
     updateCtx(); updateHint(); requestDraw();
   },
+  /** (something being dragged: not a box drawn round things, nor a press that hasn't moved anything) */
+  magnify() { return !!this.st.drag; },
   hint() {
     if (ed.sel.length) return selectionHint();
     return ed.lastPointerTouch
@@ -355,7 +368,11 @@ function beginDrag(h: Hit, down: PEv): Drag | null {
         if (it.type === 'point') s.add(it.id);
         if (it.type === 'arc') addArc(it.id);
         if (it.type === 'circle') { const ci = sk.circles[it.id]; if (ci) s.add(ci.c); }
-        if (it.type === 'room') { const r = sk.rooms[it.id]; if (r) r.loop.forEach(p => s.add(p)); }
+        if (it.type === 'room') {
+          const r = sk.rooms[it.id];
+          // (its corners — and the centre of a circle it runs round, which has none of its own)
+          if (r) { r.loop.forEach(p => s.add(p)); for (const e of r.edges ?? []) { const ce = circleEdge(e), ci = ce && sk.circles[ce.cid]; if (ci) s.add(ci.c); } }
+        }
       }
     } else {
       if (h.type === 'line') addL(h.id);
@@ -373,7 +390,7 @@ function beginDrag(h: Hit, down: PEv): Drag | null {
     if (p.fixed) { toast(p.origin ? 'The origin stays put. Lock or unlock other points from the bar below.' : p.anchor ? 'This corner is set by the plan — move the wall, door or window there.' : 'This point is locked. Unlock it to move it.', { warn: true }); return null; }
     // (one of several selected: the selection moves, as by one of its lines)
     if (several) return multi(ptsOf());
-    return { kind: 'point', id: h.id, start: { x: p.x, y: p.y }, grab: { x: wx, y: wy }, snap: null };
+    return { kind: 'point', id: h.id, start: { x: p.x, y: p.y }, grab: { x: wx, y: wy }, snap: null, arcs: arcEnds(sk, h.id) };
   }
   if (h.type === 'cab') {
     // a cabinet moves as a whole (and the rest of the selection with it, when it's part of it)
@@ -403,7 +420,10 @@ function beginDrag(h: Hit, down: PEv): Drag | null {
   if (h.type === 'dim') {
     const c = sk.cons[h.id];
     if (c.type === 'diam') return { kind: 'diamlabel', id: h.id };
-    if (c.type !== 'dist') return null;
+    if (c.type === 'angle') return { kind: 'anglelabel', id: h.id };
+    // (a distance between two parallel lines or walls slides along them: the user's call, 2026-10-24, when one made
+    // by selecting two walls across from each other wouldn't leave where it was first drawn)
+    if (c.type !== 'dist' && c.type !== 'pldist') return null;
     return { kind: 'dimoff', id: h.id };
   }
   if (h.type === 'opening') {
@@ -449,6 +469,41 @@ function groupDrag(sk: Sketch, h: Hit, wx: number, wy: number): Drag | null {
 /** How far things ran past their walls when each drag began: it may not go further. */
 const dragBase = new WeakMap<Drag, Overflow>();
 
+/** The arcs a point is an end of (not their centre), each with how far round it goes now. */
+function arcEnds(sk: Sketch, pid: string): ArcEnd[] {
+  const out: ArcEnd[] = [];
+  for (const id in sk.arcs) {
+    const a = sk.arcs[id];
+    if (a.a === a.b || a.c === pid || (a.a !== pid && a.b !== pid)) continue;
+    const g = arcAngles(sk, a);
+    out.push({ id, other: a.a === pid ? a.b : a.a, end: a.a === pid ? 'a' : 'b', sweep: g.full ? 2 * Math.PI : normAng(g.t1 - g.t0), closed: false });
+  }
+  return out;
+}
+
+/**
+ * An arc's end dragged all the way round onto its other end — or on past it — closes it (the user's call, 2026-10-29:
+ * "if u fully rotate it to reach around - it should create a circle"): it's held on the other end, drawn all the way
+ * round (arcAngles' `full`), and joined into a circle when it's let go (endDrag). Back the way it came, it opens again.
+ * Only from more than half way round: dragged back onto its start the short way, an arc shrinks — it isn't snapped onto
+ * its own other end, which would close it. `s` is where the end would go otherwise, `raw` the pointer; returns where it goes.
+ */
+function closeArcs(sk: Sketch, arcs: ArcEnd[], s: Snap, raw: XY, tol: number): Snap {
+  for (const t of arcs) {
+    const a = sk.arcs[t.id], o = a && sk.points[a.c], q = a && sk.points[t.other];
+    if (!a || !o || !q) continue;
+    // how far round it would go with the end at the pointer (from its other end, the way it runs: counter-clockwise a → b)
+    const th = Math.atan2(raw.y - o.y, raw.x - o.x), tq = Math.atan2(q.y - o.y, q.x - o.x);
+    const sweep = t.end === 'b' ? normAng(th - tq) : normAng(tq - th), near = hyp(raw.x - q.x, raw.y - q.y) <= tol;
+    if (t.closed) { if (sweep > 1.5 * Math.PI && !near) t.closed = false; }
+    else if ((near && t.sweep > Math.PI) || (t.sweep > 1.5 * Math.PI && sweep < 0.5 * Math.PI)) t.closed = true;
+    if (t.closed) return { x: q.x, y: q.y, kind: 'point', ref: t.other, label: 'Endpoint', guides: [] };
+    t.sweep = sweep;
+    if (s.kind === 'point' && s.ref === t.other) return { x: raw.x, y: raw.y, kind: 'free', ref: null, guides: [] };
+  }
+  return s;
+}
+
 function dragTo(d: Drag, ev: PEv): void {
   const sk = SK();
   const [wx, wy] = s2w(ev.sx, ev.sy);
@@ -482,16 +537,22 @@ function dragTo(d: Drag, ev: PEv): void {
     // (not a line already held level or plumb: its direction can't change)
     const squared = (l: { a: string; b: string }) => Object.values(sk.cons).some(c => (c.type === 'h' || c.type === 'v') && ((c.a === l.a && c.b === l.b) || (c.a === l.b && c.b === l.a)));
     const ends = ev.shift ? Object.values(sk.lines).filter(l => !l.anchor && (l.a === d.id || l.b === d.id) && !squared(l)).map(l => sk.points[l.a === d.id ? l.b : l.a]) : [];
+    let locked = false;
     if (ends.length) {
       const q = ends.map(o => snap45(o, { x: wx, y: wy })).reduce((m, c) => (hyp(c.x - wx, c.y - wy) < hyp(m.x - wx, m.y - wy) ? c : m));
       // where the drawing can't take it there (other constraints), it's an ordinary drag — never stuck
-      if (go([d.id], [{ x: q.x, y: q.y }])) { d.snap = null; ed.snapState = null; return; }
-      restoreFit(sk, held!);
+      locked = go([d.id], [{ x: q.x, y: q.y }]);
+      if (locked) { d.snap = null; ed.snapState = null; } else restoreFit(sk, held!);
+    }
+    // (either way on to what every step of a drag does below — its doors and windows, and drawing it again: returning
+    // here left a Shift-drag frozen on the screen until the pointer lifted)
+    if (!locked) {
+      // (an arc's end, round onto its other end: closed — see closeArcs)
+      const s = closeArcs(sk, d.arcs, snapAt(ev.sx, ev.sy, { exclude: new Set([d.id]), touch: ev.touch }), { x: wx, y: wy }, (ev.touch ? 16 : 10) / mainT().s);
+      d.snap = s.kind === 'point' || s.kind === 'mid' || s.kind === 'online' || s.kind === 'oncircle' ? s : null;
+      ed.snapState = d.snap ? s : null;
+      go([d.id], [{ x: s.x, y: s.y }]);
     }
-    const s = snapAt(ev.sx, ev.sy, { exclude: new Set([d.id]), touch: ev.touch });
-    d.snap = s.kind === 'point' || s.kind === 'mid' || s.kind === 'online' || s.kind === 'oncircle' ? s : null;
-    ed.snapState = d.snap ? s : null;
-    go([d.id], [{ x: s.x, y: s.y }]);
   } else if (d.kind === 'multi') {
     let mx = wx - d.grab.x, my = wy - d.grab.y;
     // Shift: moved level, plumb or 45° only
@@ -529,10 +590,20 @@ function dragTo(d: Drag, ev: PEv): void {
       c.ang = Math.atan2(wy - g.o.y, wx - g.o.x);
       c.off = Math.max(0, hyp(wx - g.o.x, wy - g.o.y) - g.r - 40 / mainT().s);
     }
+  } else if (d.kind === 'anglelabel') {
+    // (where the label's dragged: as far out from its corner, and round it as far as its two lines; never into it)
+    const c = sk.cons[d.id], g = angleCorner(sk, c);
+    if (g) {
+      const a = Math.atan2(wy - g.vtx.y, wx - g.vtx.x);
+      c.off = Math.max(24 / mainT().s, hyp(wx - g.vtx.x, wy - g.vtx.y));
+      c.ang = g.u1 && g.u2 ? (({ t1, sweep }) => inSweep(a, t1, sweep))(angleSweep(g.u1, g.u2)) : a;
+    }
   } else if (d.kind === 'dimoff') {
-    // (off the line it's drawn from: a wall's face, for a length measured on one)
-    const c = sk.cons[d.id], e = dimEnds(sk, c), a = e ? e.a : sk.points[c.a!], b = e ? e.b : sk.points[c.b!];
-    const n = norm2(-(b.y - a.y), b.x - a.x);
+    // (off the span it measures: a line, a wall's face for a length measured on one — or, for a distance between
+    // parallel lines or walls, along them)
+    const c = sk.cons[d.id], e = dimEnds(sk, c) ?? (c.a && c.b ? { a: sk.points[c.a], b: sk.points[c.b] } : null);
+    if (!e) return;
+    const { a, b } = e, n = norm2(-(b.y - a.y), b.x - a.x);
     c.off = (wx - (a.x + b.x) / 2) * n[0] + (wy - (a.y + b.y) / 2) * n[1];
   } else if (d.kind === 'wopening') {
     // a locked door won't move: say so once, then nothing
@@ -594,7 +665,17 @@ function endDrag(d: Drag): void {
   const sk = SK();
   ed.snapState = null;
   if (d.kind === 'wopening' && !d.drag.started) dropHistory(); // it didn't move
-  if (d.kind === 'point' && d.snap && settings.autoCons) {
+  // an arc dragged all the way round onto its start: its ends joined, it's a circle (gc: closeArc). It's what the drag
+  // was, so whether or not auto-constrain is on
+  const closed = d.kind === 'point' ? d.arcs.find(t => t.closed) : undefined;
+  if (closed && d.kind === 'point') {
+    const was = JSON.stringify(sk);
+    if (mergePoints(sk, closed.other, d.id)) {
+      const r = solveSketch();
+      if (!r.ok) { replaceSK(JSON.parse(was) as Sketch); toast('Can’t close that arc — it conflicts with other constraints.', { warn: true }); }
+      else { ed.sel = sk.circles[closed.id] ? [{ type: 'circle', id: closed.id }] : []; toast('Closed into a circle'); }
+    }
+  } else if (d.kind === 'point' && d.snap && settings.autoCons) {
     const s = d.snap;
     if (s.kind === 'point') {
       const snap = JSON.stringify(sk);