@reekon-tools/boldr-cad 1.4.0 → 1.6.0

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 crop' + 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
@@ -14,6 +15,7 @@ const TIPS: Record<string, string> = {
   rect: 'Tap or drag corner to corner.',
   circle: 'Tap the center, then the edge.',
   arc: 'Tap both ends, then drag to bend.',
+  trim: 'Tap or drag across the pieces to cut away.',
   door: 'Tap a wall to add a 3\'-0" door.',
   window: 'Tap a wall to add a 3\'-0" window.',
   room: 'Tap inside a closed shape.',
@@ -34,14 +36,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 });

package/src/export/plan.ts

@@ -1,10 +1,10 @@
 import { isDim, measure } from '../model/constraints';
 import { hyp, norm2, pointInPoly } from '../model/geom';
-import { edgeS, measureOpeningDim, openingSpan, refPoint, refS } from '../model/openings';
+import { edgeS, hingeEdge, measureOpeningDim, openingSpan, refPoint, refS } from '../model/openings';
 import { roomGeom } from '../model/rooms';
 import { smoothPolyline } from '../model/smooth';
 import { roomValid } from '../model/sketch';
-import { dimEnds, dimRadius } from '../model/planGeom';
+import { angleLabel, dimEnds, dimRadius } from '../model/planGeom';
 import { wallPieces } from '../model/wallshape';
 import { cabinetFootprints } from '../model/facesolve';
 import { isSegment, noteLook, noteTextIn, shapeOutline } from '../model/markup';
@@ -41,7 +41,7 @@ export interface Plan {
 }
 
 export interface DrawOptions {
-  /** include dimensions (driving, reference, print, door/window) — default true */
+  /** include dimensions (driving, reference, door/window) — default true */
   dims?: boolean;
   /** include markup (pen, lines, arrows, shapes, clouds, notes) — default true */
   markup?: boolean;
@@ -59,7 +59,7 @@ const defaultLinkLabel = (t: LinkTarget): { name: string; value?: string } => {
   const info = linkInfoOf(t);
   return { name: (info?.exists === false ? 'Removed: ' : '') + linkName(t), value: t.kind === 'measurement' ? info?.text ?? t.text : undefined };
 };
-const KIND_WORD: Record<string, string> = { photo: 'Photo', pdf: 'PDF', note: 'Note', calculator: 'Calculator', label: 'Label', drawing: 'Drawing' };
+const KIND_WORD: Record<string, string> = { photo: 'Photo', pdf: 'PDF', note: 'Note', calculator: 'Calculator', conversion: 'Conversion', label: 'Label', drawing: 'Sketch', cad: 'CAD' };
 
 /**
  * A name on paper, where nothing can be measured (a DXF has no fonts): about `perLine` characters a line, broken at a
@@ -201,7 +201,8 @@ export function emitDrawing(sk: Sketch, d: Plan, opts: DrawOptions = {}): void {
     if (o.type === 'window') {
       for (const k of [t / 6, -t / 6]) d.line(layer, Q(s0, k), Q(s1, k));
     } else {
-      const f = o.flip ? -1 : 1, hinge = Q(s0, (f * t) / 2), leaf = Q(s0, f * (t / 2 + g.w)), shut = Q(s1, (f * t) / 2);
+      const f = o.flip ? -1 : 1, [hs, ls] = hingeEdge(o) === 's1' ? [s1, s0] : [s0, s1];
+      const hinge = Q(hs, (f * t) / 2), leaf = Q(hs, f * (t / 2 + g.w)), shut = Q(ls, (f * t) / 2);
       d.line(layer, hinge, leaf);
       // swing: from the closed position to the open leaf, the short way round
       const a0 = Math.atan2(shut.y - hinge.y, shut.x - hinge.x), a1 = Math.atan2(leaf.y - hinge.y, leaf.x - hinge.x);
@@ -219,14 +220,15 @@ export function emitDrawing(sk: Sketch, d: Plan, opts: DrawOptions = {}): void {
     if (!roomValid(sk, r)) continue;
     const g = roomGeom(sk, r);
     d.text('SPACES', { x: g.c.x, y: g.c.y + 4 }, 6, r.name);
-    d.text('SPACES', { x: g.c.x, y: g.c.y - 4 }, TEXT_H, fmtArea(g.area));
+    // (a sketch without its scale yet: its area is only a placeholder)
+    if (!sk.unscaled) d.text('SPACES', { x: g.c.x, y: g.c.y - 4 }, TEXT_H, fmtArea(g.area));
   }
 
   if (opts.dims !== false) {
     for (const id in sk.cons) {
       const c = sk.cons[id];
       if (!isDim(c)) continue;
-      const ref = c.driving === false && c.layer !== 'print';
+      const ref = c.driving === false;
       const v = c.driving === false ? measure(sk, c) : c.value!;
       const wrap = (s: string) => (ref ? '(' + s + ')' : s);
       if (c.type === 'dist') {
@@ -241,11 +243,11 @@ export function emitDrawing(sk: Sketch, d: Plan, opts: DrawOptions = {}): void {
         const off = c.off || (c.line ? WALL_DIM_OFF * outsideSide(sk, c.line) : 0);
         linearDim(d, a, b, n, off, wrap(fmtLen(v)));
       } else if (c.type === 'pldist') {
-        // (between walls' faces: face to face)
+        // (between walls' faces: face to face, where it was slid to along them)
         const e = dimEnds(sk, c);
         if (!e) continue;
         const n = norm2(-(e.b.y - e.a.y), e.b.x - e.a.x);
-        linearDim(d, e.a, e.b, n, 0, wrap(fmtLen(v)));
+        linearDim(d, e.a, e.b, n, c.off || 0, wrap(fmtLen(v)));
       } else if (c.type === 'diam') {
         // (across a curved wall's face: on that face)
         const g = dimRadius(sk, c);
@@ -261,7 +263,9 @@ export function emitDrawing(sk: Sketch, d: Plan, opts: DrawOptions = {}): void {
         if (!sh) continue;
         const s = P(sh), o1 = P(l1.a === sh ? l1.b : l1.a), o2 = P(l2.a === sh ? l2.b : l2.a);
         const u1 = norm2(o1.x - s.x, o1.y - s.y), u2 = norm2(o2.x - s.x, o2.y - s.y), bis = norm2(u1[0] + u2[0], u1[1] + u2[1]);
-        d.text('DIMENSIONS', { x: s.x + bis[0] * 18, y: s.y + bis[1] * 18 }, TEXT_H, wrap(fmtAng(v)));
+        // (pulled off its corner: where it was left)
+        const moved = angleLabel(sk, c);
+        d.text('DIMENSIONS', moved ? { x: moved.vtx.x + Math.cos(moved.ang) * moved.r, y: moved.vtx.y + Math.sin(moved.ang) * moved.r } : { x: s.x + bis[0] * 18, y: s.y + bis[1] * 18 }, TEXT_H, wrap(fmtAng(v)));
       }
     }
     // door/window dimensions: placed ones, and the width

package/src/index.ts

@@ -10,6 +10,7 @@ export type { CadDataProvider, CadFileMeta, CadMeasurements, CadMeasurementValue
 export type { Unit } from './units';
 export { memoryProvider } from './data/memory';
 export { setFileSaver } from './react/ports';
+export { BESIDE as CAD_BESIDE } from './react/pageLock';
 export { laserReading, setLaserConnected, surveyClose, surveyCursor, surveyPoint } from './react/host';
 export type { HostKeypad, HostKeypadExtra, HostKeypadRequest, MeasurementList, MeasurementListPage } from './react/hostKeypad';
 export type { CadLinkPick, CadLinks, CadSaveMeasurement, MeasurementKind } from './editor/links';

package/src/model/constraints.ts

@@ -16,6 +16,7 @@ export function consLabel(c: Constraint): string {
   if (c.type === 'dist' || c.type === 'pldist') return (c.type === 'dist' ? (c.line ? 'Length ' : 'Distance ') : 'Offset ') + fmtLen(c.value!);
   if (c.type === 'diam') return c.rad ? 'Radius ' + fmtLen(c.value! / 2) : 'Diameter ' + fmtLen(c.value!);
   if (c.type === 'angle') return 'Angle ' + fmtAng(c.value!);
+  if (c.type === 'online' && c.face) return 'Point on face';
   return CONS_LABEL[c.type] || c.type;
 }
 

package/src/model/demo.ts

@@ -24,8 +24,9 @@ export function demoSketch(): Sketch {
   return sk;
 }
 
+/** A page: a copy's drawing (`sk`), or a new one's — without a scale until its first length (model/scale.ts). */
 export function newPage(name: string, sk?: Sketch): Page {
-  return { id: uid('pg'), name, sk: sk || emptySketch(), underlays: [], view: null };
+  return { id: uid('pg'), name, sk: sk || { ...emptySketch(), unscaled: true }, underlays: [], view: null };
 }
 
 export function seedProject(): Project {

package/src/model/elevation.ts

@@ -1,5 +1,5 @@
 import { hyp, pointInPoly } from './geom';
-import { edgeS, openingSpan } from './openings';
+import { edgeS, hingeEdge, openingSpan } from './openings';
 import { roomGeom } from './rooms';
 import { settings } from './settings';
 import { roomValid } from './sketch';
@@ -87,7 +87,7 @@ export function elevFrame(sk: Sketch, lid: string, flip = false): ElevFrame | nu
 
 export interface ElevOpening {
   id: string; type: Opening['type']; u0: number; u1: number; sill: number; head: number;
-  /** the door's hinge edge as seen (doors hinge at their s0 edge) */
+  /** the door's hinge edge as seen (Opening.hinge) */
   hinge: 'l' | 'r';
   /** the opening's edge (anchor) at u0 and at u1 */
   e0: OpeningEdge; e1: OpeningEdge;
@@ -101,8 +101,8 @@ export function elevOpenings(sk: Sketch, f: ElevFrame): ElevOpening[] {
     if (o.line !== f.lid) continue;
     const g = openingSpan(sk, o);
     if (!g) continue;
-    const a = toU(f, edgeS(o, g.w, 's0')), b = toU(f, edgeS(o, g.w, 's1'));
-    out.push({ id, type: o.type, u0: Math.min(a, b), u1: Math.max(a, b), ...openingHeights(o), hinge: a <= b ? 'l' : 'r', e0: a <= b ? 's0' : 's1', e1: a <= b ? 's1' : 's0' });
+    const a = toU(f, edgeS(o, g.w, 's0')), b = toU(f, edgeS(o, g.w, 's1')), left = (hingeEdge(o) === 's1' ? b <= a : a <= b);
+    out.push({ id, type: o.type, u0: Math.min(a, b), u1: Math.max(a, b), ...openingHeights(o), hinge: left ? 'l' : 'r', e0: a <= b ? 's0' : 's1', e1: a <= b ? 's1' : 's0' });
   }
   return out.sort((p, q) => p.u0 - q.u0);
 }

package/src/model/geom.ts

@@ -34,6 +34,16 @@ export function lineCircleT(A: XY, B: XY, c: XY, r: number): number[] {
   return [(-b - s) / (2 * a), (-b + s) / (2 * a)].filter(t => t > 1e-6 && t < 1 - 1e-6);
 }
 
+/** Where circle (c1, r1) crosses circle (c2, r2): none, one where they touch, or two. */
+export function circleCircle(c1: XY, r1: number, c2: XY, r2: number): XY[] {
+  const dx = c2.x - c1.x, dy = c2.y - c1.y, d = hyp(dx, dy);
+  if (d < 1e-12 || d > r1 + r2 + 1e-9 || d < Math.abs(r1 - r2) - 1e-9) return [];
+  const a = (r1 * r1 - r2 * r2 + d * d) / (2 * d), h2 = r1 * r1 - a * a, h = h2 > 0 ? Math.sqrt(h2) : 0;
+  const mx = c1.x + (dx * a) / d, my = c1.y + (dy * a) / d;
+  if (h < 1e-12) return [{ x: mx, y: my }];
+  return [{ x: mx - (dy * h) / d, y: my + (dx * h) / d }, { x: mx + (dy * h) / d, y: my - (dx * h) / d }];
+}
+
 /** Circumcenter of three points, or null if they are collinear. */
 export function circum(a: XY, b: XY, c: XY): XY | null {
   const d = 2 * (a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y));

package/src/model/history.ts

@@ -1,4 +1,5 @@
 import { page, store } from './store';
+import { rezoomAcrossScale } from './scale';
 import type { Underlay } from './types';
 import { onSessionReset } from './session';
 
@@ -20,8 +21,10 @@ function take(): Snap {
 }
 
 function restore(s: Snap): void {
-  const pg = page();
+  const pg = page(), was = pg.sk;
   pg.sk = JSON.parse(s.sk);
+  // the step that gave the drawing its scale zoomed the view to match (views aren't kept here): zoom back, or again
+  rezoomAcrossScale(pg, was, pg.sk);
   // an image uploaded since keeps its stored address (not the local copy it had when this was taken)
   const now = new Map(pg.underlays.map(u => [u.id, u.src]));
   pg.underlays = s.imgs.map(u => ({ ...u, src: stored(u.src, now.get(u.id)) }));

package/src/model/links.ts

@@ -22,8 +22,13 @@ export const isLink = (n: Note): n is Note & { link: LinkTarget } => n.type ===
 
 /** How big a tile is on the screen as it's placed (points): its side on the drawing is what that is at the zoom then. */
 export const LINK_TILE_PX = 96;
-/** How big a tile can be on the drawing, inches; unset (never, once placed), this. */
+/** How big a tile can be on the drawing as it's placed, inches; unset (never, once placed), this. */
 export const LINK_MIN_IN = 6, LINK_MAX_IN = 480, LINK_SIDE_IN = 24;
+/**
+ * How big the Tile size slider can make one, inches: wide enough that its 10%–1000% of the size tiles came in at is
+ * there to reach, and inside what the tile's drawing clips to (render/linkTile.ts: clipToBar).
+ */
+export const LINK_HARD_MIN_IN = 1, LINK_HARD_MAX_IN = 2400;
 /**
  * On the screen, points: from LINK_FULL_PX across a tile shows its picture or icon and its name; under LINK_PIN_PX it's
  * a pin of that size, however far out the drawing is.
@@ -64,10 +69,16 @@ export function sketchLinks(sk: Sketch): LinkTarget[] {
   return out;
 }
 
-/** Everything a project links to, each once: its pages' tiles and the measurements its dimensions show. */
+/**
+ * Everything a project links to, each once: its pages' tiles, the photos expanded from tiles among their images, and
+ * the measurements its dimensions show.
+ */
 export function linkTargets(p: Project): LinkTarget[] {
   const out = new Map<string, LinkTarget>();
-  for (const pg of p.pages) for (const t of sketchLinks(pg.sk)) if (!out.has(linkKey(t))) out.set(linkKey(t), t);
+  for (const pg of p.pages) {
+    for (const t of sketchLinks(pg.sk)) if (!out.has(linkKey(t))) out.set(linkKey(t), t);
+    for (const u of pg.underlays ?? []) if (u.link && !out.has(linkKey(u.link))) out.set(linkKey(u.link), u.link);
+  }
   return [...out.values()];
 }
 

package/src/model/measurement.ts

@@ -9,11 +9,11 @@ import type { Constraint } from './types';
 const LENGTHS = new Set<Constraint['type']>(['dist', 'pldist', 'diam']);
 
 /**
- * Dimension `c`'s value (or `value`, one it's about to have) as a measurement. Null for what isn't one: reference and
- * print dimensions, measured-only ones, and constraints without a value.
+ * Dimension `c`'s value (or `value`, one it's about to have) as a measurement. Null for what isn't one: reference
+ * dimensions, measured-only ones, and constraints without a value.
  */
 export function dimMeasurement(c: Constraint, value = c.value): CadMeasurementValue | null {
-  if (c.driving === false || c.layer === 'print' || value == null || c.auto) return null;
+  if (c.driving === false || value == null || c.auto) return null;
   if (c.type === 'angle') return { kind: 'angle', value: Math.round(value * 100) / 100 };
   // a fillet's radius is kept as its diameter; BOLDR keeps the radius
   if (LENGTHS.has(c.type)) return { kind: 'length', value: Math.round((c.rad ? value / 2 : value) * 25400) };

package/src/model/openings.ts

@@ -28,6 +28,24 @@ export function openingSpan(sk: Sketch, o: Opening): Span | null {
 /** Position of an edge, inches along the opening's line. */
 export const edgeS = (o: Opening, w: number, edge: OpeningEdge): number => (edge === 's0' ? o.at - w / 2 : o.at + w / 2);
 
+/** The jamb a door hangs on (Opening.hinge): the plan, the wall view, 3D and exports all draw its leaf from there. */
+export const hingeEdge = (o: Opening): OpeningEdge => o.hinge ?? 's0';
+
+/**
+ * A door turned to the next of its four ways round, by Swing in the bar (the user's call, 2026-10-27: "4 options of flippings instead of 2
+ * (inner, outer, inner left, outer left) pressing the one button should toggle between the different options"):
+ * swinging into the room, it swings out on the same jamb; swinging out, it swings back in, hung on its other jamb. So
+ * inner, outer, inner left, outer left, and inner again, from whichever it was. `inside`: the side of its wall the
+ * room is on (+1: the left of its line's start → end).
+ */
+export function flipDoor(o: Opening, inside: 1 | -1): void {
+  if ((o.flip ? -1 : 1) !== inside) {
+    if (hingeEdge(o) === 's0') o.hinge = 's1';
+    else delete o.hinge;
+  }
+  o.flip = !o.flip;
+}
+
 /** World position of an opening edge anchor. */
 export function edgePoint(sk: Sketch, opId: string, edge: OpeningEdge): XY | null {
   const o = sk.openings[opId], g = o && openingSpan(sk, o);

package/src/model/planGeom.ts

@@ -1,6 +1,6 @@
 import { clamp, hyp, norm2, normAng, pointInPoly } from './geom';
-import { roomGeom } from './rooms';
-import { frameMemo, roomValid } from './sketch';
+import { roomGeom, roomOutline } from './rooms';
+import { circleEdge, frameMemo, roomValid } from './sketch';
 import type { Arc, Constraint, LineKind, Sketch, XY } from './types';
 import { faceCorner } from './wallfaces';
 import { getUnitPrefs, isMetric, type Unit } from '../units';
@@ -52,9 +52,16 @@ export function openingFrame(sk: Sketch, id: string): OpeningFrame | null {
   return { A, ux, uy, nx: -uy, ny: ux, s0: at - w / 2, s1: at + w / 2, at, w, t: l.kind === 'wall' ? l.thick : 2 };
 }
 
-export function arcAngles(sk: Sketch, a: Arc): { o: XY; r: number; t0: number; t1: number } {
+/**
+ * An arc's centre, radius and angles: it runs counter-clockwise from t0 (its start, a) to t1 (its end, b). `full`: its
+ * ends have met — dragged all the way round onto its start — so it goes all the way round (t1 is t0 + 2π), as the
+ * circle it becomes when they join (select.ts; gc in model/sketch.ts), not nothing.
+ */
+export function arcAngles(sk: Sketch, a: Arc): { o: XY; r: number; t0: number; t1: number; full: boolean } {
   const o = sk.points[a.c], s = sk.points[a.a], e = sk.points[a.b];
-  return { o, r: hyp(s.x - o.x, s.y - o.y), t0: Math.atan2(s.y - o.y, s.x - o.x), t1: Math.atan2(e.y - o.y, e.x - o.x) };
+  const r = hyp(s.x - o.x, s.y - o.y), t0 = Math.atan2(s.y - o.y, s.x - o.x);
+  const full = a.a === a.b || hyp(e.x - s.x, e.y - s.y) <= r * 1e-7;
+  return { o, r, t0, t1: full ? t0 + 2 * Math.PI : Math.atan2(e.y - o.y, e.x - o.x), full };
 }
 
 /** +1 or -1: the side of a line facing away from any room (where opening dimensions go). */
@@ -65,7 +72,7 @@ export function outsideSide(sk: Sketch, lid: string): number {
   // (asked for every door and window on every frame: the rooms' outlines, and the boxes around them, are worked out
   // once a frame — a room the box rules out isn't looked at more closely)
   const rooms = frameMemo(sk, 'roomOutlines', () => Object.values(sk.rooms).filter(r => roomValid(sk, r)).map(r => {
-    const poly = r.loop.map(p => sk.points[p]), xs = poly.map(p => p.x), ys = poly.map(p => p.y);
+    const poly = roomOutline(sk, r), xs = poly.map(p => p.x), ys = poly.map(p => p.y);
     return { poly, x0: Math.min(...xs), x1: Math.max(...xs), y0: Math.min(...ys), y1: Math.max(...ys) };
   }));
   for (const r of rooms) if (m.x >= r.x0 && m.x <= r.x1 && m.y >= r.y0 && m.y <= r.y1 && pointInPoly(m, r.poly)) return -1;
@@ -88,13 +95,14 @@ export function curveFrame(sk: Sketch, id: string): { o: XY; r: number; arc?: {
   const a = sk.arcs[id];
   if (!a || !sk.points[a.c] || !sk.points[a.a] || !sk.points[a.b]) return null;
   const g = arcAngles(sk, a);
-  return { o: g.o, r: g.r, arc: { t0: g.t0, t1: g.t1 } };
+  // (its ends met: all the way round, framed as the circle it's becoming)
+  return g.full ? { o: g.o, r: g.r } : { o: g.o, r: g.r, arc: { t0: g.t0, t1: g.t1 } };
 }
 
 /**
  * The space against one side of a wall, if any (a point just past its face there is inside it): its id. A straight
- * wall's sides are the left (+1) and right (−1) of its A → B; a curved one's, its outer (+1) and inner (−1) faces —
- * nothing is inside a circle (a space has corners: it can't be bounded by one).
+ * wall's sides are the left (+1) and right (−1) of its A → B; a curved one's, its outer (+1) and inner (−1) faces — a
+ * circle's inside too, a round space (model/rooms.ts).
  */
 export function spaceBeside(sk: Sketch, id: string, side: 1 | -1): string | null {
   const l = sk.lines[id];
@@ -105,21 +113,25 @@ export function spaceBeside(sk: Sketch, id: string, side: 1 | -1): string | null
   const m = { x: (a.x + b.x) / 2 + n[0] * k, y: (a.y + b.y) / 2 + n[1] * k };
   for (const rid in sk.rooms) {
     const r = sk.rooms[rid];
-    if (roomValid(sk, r) && pointInPoly(m, r.loop.map(p => sk.points[p]))) return rid;
+    if (roomValid(sk, r) && pointInPoly(m, roomOutline(sk, r))) return rid;
   }
   return null;
 }
 
 function curveSpaceBeside(sk: Sketch, id: string, side: 1 | -1): string | null {
   const f = curveFrame(sk, id), w = sk.circles[id] ?? sk.arcs[id];
-  if (!f || !w || (side === -1 && !f.arc)) return null;
+  if (!f || !w) return null;
   // (just past the face at the middle of the arc, or anywhere around a circle)
   const at = f.arc ? f.arc.t0 + normAng(f.arc.t1 - f.arc.t0) / 2 : 0, rr = f.r + side * (wallThick(w) / 2 + 1);
   if (rr <= 0) return null;
   const m = { x: f.o.x + Math.cos(at) * rr, y: f.o.y + Math.sin(at) * rr };
+  // inside a circle: only a space it bounds — a round column's inside isn't the room it stands in (a space has no
+  // holes: the room's outline goes over it)
+  const own = !f.arc && side === -1;
   // (a space's outline as it's drawn: its arcs as arcs, not chords)
   for (const rid in sk.rooms) {
     const r = sk.rooms[rid];
+    if (own && !(r.edges ?? []).some(e => circleEdge(e)?.cid === id)) continue;
     if (roomValid(sk, r) && pointInPoly(m, roomGeom(sk, r).poly)) return rid;
   }
   return null;
@@ -188,6 +200,54 @@ export function dimEnds(sk: Sketch, c: Constraint): { a: XY; b: XY } | null {
   return null;
 }
 
+/**
+ * An angle dimension's corner: where its two lines meet, with `u1`/`u2` along each away from it (`len1`/`len2`: as far
+ * as each goes), and the bisector. For two lines that don't meet: the middle of the first, its label straight up.
+ */
+export function angleCorner(sk: Sketch, c: Constraint): { vtx: XY; bis: [number, number]; u1?: [number, number]; u2?: [number, number]; len1?: number; len2?: number } | null {
+  const l1 = c.l1 ? sk.lines[c.l1] : undefined, l2 = c.l2 ? sk.lines[c.l2] : undefined;
+  if (!l1 || !l2) return null;
+  const P = (id: string) => sk.points[id];
+  const sh = [l1.a, l1.b].find(p => p === l2.a || p === l2.b);
+  if (sh) {
+    const s = P(sh), o1 = P(l1.a === sh ? l1.b : l1.a), o2 = P(l2.a === sh ? l2.b : l2.a);
+    const u1 = norm2(o1.x - s.x, o1.y - s.y), u2 = norm2(o2.x - s.x, o2.y - s.y);
+    return { vtx: s, bis: norm2(u1[0] + u2[0], u1[1] + u2[1]), u1, u2, len1: hyp(o1.x - s.x, o1.y - s.y), len2: hyp(o2.x - s.x, o2.y - s.y) };
+  }
+  const a = P(l1.a), b = P(l1.b);
+  return { vtx: { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 }, bis: [0, 1] };
+}
+
+const wrapPi = (x: number) => { while (x > Math.PI) x -= 2 * Math.PI; while (x < -Math.PI) x += 2 * Math.PI; return x; };
+
+/** The short way round from `u1` to `u2`: where it starts and how far it turns, world radians (negative: clockwise). */
+export function angleSweep(u1: [number, number], u2: [number, number]): { t1: number; sweep: number } {
+  const t1 = Math.atan2(u1[1], u1[0]);
+  return { t1, sweep: wrapPi(Math.atan2(u2[1], u2[0]) - t1) };
+}
+
+/** Direction `a` (world radians) kept within a sweep: past either end of it, the nearer end. In (-π, π]. */
+export function inSweep(a: number, t1: number, sweep: number): number {
+  const rel = wrapPi(a - t1), lo = Math.min(0, sweep), hi = Math.max(0, sweep);
+  if (rel >= lo && rel <= hi) return wrapPi(t1 + rel);
+  return wrapPi(t1 + (Math.abs(wrapPi(rel - lo)) <= Math.abs(wrapPi(rel - hi)) ? lo : hi));
+}
+
+/**
+ * An angle dimension pulled off its corner (the user's call, 2026-10-24: angles pull like lengths): its arc's radius
+ * (`off`), and its label's direction (`ang`), kept between its two lines, in the angle it measures. Null for one that
+ * hasn't been moved: it's drawn as it always was, a little arc at the corner and the label out along the bisector.
+ */
+export function angleLabel(sk: Sketch, c: Constraint): { vtx: XY; r: number; ang: number } | null {
+  if (c.type !== 'angle' || c.off == null) return null;
+  const g = angleCorner(sk, c);
+  if (!g) return null;
+  const want = c.ang ?? Math.atan2(g.bis[1], g.bis[0]);
+  if (!g.u1 || !g.u2) return { vtx: g.vtx, r: c.off, ang: want };
+  const { t1, sweep } = angleSweep(g.u1, g.u2);
+  return { vtx: g.vtx, r: c.off, ang: inSweep(want, t1, sweep) };
+}
+
 /**
  * Where a diameter (or radius) dimension's arrows go: its curve's centre, and the radius it measures at — the
  * centreline's, or on a curved wall's face, that face's.

package/src/model/project.ts

@@ -1,15 +1,19 @@
 import { normalizeImages } from './images';
 import { newPage } from './demo';
+import { settleScale } from './scale';
 import type { Page, Project } from './types';
 
+/** A page as it's loaded: its images in today's form, and its scale settled (model/scale.ts). */
+const tidy = (pg: Page): Page => { const n = normalizeImages(pg); settleScale(n.sk); return n; };
+
 /**
  * Older saves group pages into spaces/levels (Project → Space → Page). Flatten them, in order; when the same page
  * name appears in more than one level, it's prefixed with the level's name ("Level 2 · Floor plan").
  */
 export function migrateProject(p: { name: string; pages?: Page[]; spaces?: { name: string; pages: Page[] }[] }): Project {
-  if (p.pages) return { name: p.name, pages: p.pages.map(normalizeImages) };
+  if (p.pages) return { name: p.name, pages: p.pages.map(tidy) };
   const spaces = p.spaces || [], count: Record<string, number> = {};
   for (const s of spaces) for (const pg of s.pages) count[pg.name] = (count[pg.name] || 0) + 1;
-  const pages = spaces.flatMap(s => s.pages.map(pg => normalizeImages(count[pg.name] > 1 ? { ...pg, name: s.name + ' · ' + pg.name } : pg)));
+  const pages = spaces.flatMap(s => s.pages.map(pg => tidy(count[pg.name] > 1 ? { ...pg, name: s.name + ' · ' + pg.name } : pg)));
   return { name: p.name, pages: pages.length ? pages : [newPage('Floor plan')] };
 }