@reekon-tools/boldr-cad 1.4.0 → 1.6.0

package/src/solver/equations.ts

@@ -20,10 +20,42 @@ type DFn = (id: string) => number[];
 type RVFn = (X: Vec, cid: string) => number;
 type RDFn = (cid: string) => number[];
 
+/**
+ * The side of its line a tangent keeps the curve's centre on (1: left of the line's a → b): the side it was made
+ * tangent from (`sign`: the fillet tool and the Tangent action set it), or, for one saved before tangents had a side,
+ * the side it's on now.
+ */
+export function tanSide(sk: Sketch, c: Constraint): 1 | -1 {
+  if (c.sign) return c.sign < 0 ? -1 : 1;
+  const l = c.l ? sk.lines[c.l] : undefined, ci = curveInfo(sk, c.c);
+  const A = l && sk.points[l.a], B = l && sk.points[l.b], o = ci && sk.points[ci.o.c];
+  if (!A || !B || !o) return 1;
+  return (B.x - A.x) * (o.y - A.y) - (B.y - A.y) * (o.x - A.x) < 0 ? -1 : 1;
+}
+
 /** Residual equations for one constraint, each with the variable indices it depends on. */
 export function consEqs(sk: Sketch, c: Constraint, P: PFn, D: DFn, RV: RVFn, RD: RDFn): [number[], EqFn][] {
   const L = (id: string | undefined) => (id ? sk.lines[id] : undefined);
   const out: [number[], EqFn][] = [];
+  /**
+   * Line `id`'s length, and what it depends on — for a wall's `face`, along that face corner to corner: the walls at its
+   * ends cut it short (an inside corner) or carry it on (an outside one), so they're part of it too.
+   */
+  const len = (id: string, face?: number): { deps: number[]; f: EqFn } => {
+    const l = sk.lines[id];
+    if (face && l.kind === 'wall') {
+      const ends = faceEnds(sk, id), side = face < 0 ? -1 : 1;
+      return {
+        deps: [...D(l.a), ...D(l.b), ...[...ends.a, ...ends.b].flatMap(e => D(e.far ?? e.arc!.c))],
+        f: X => {
+          const at = (p: string) => { const q = P(X, p); return { x: q[0], y: q[1] }; };
+          const fs = faceSpan(at, at(l.a), at(l.b), l.thick, side, ends);
+          return fs ? fs.s1 - fs.s0 : 0;
+        },
+      };
+    }
+    return { deps: [...D(l.a), ...D(l.b)], f: X => { const a = P(X, l.a), b = P(X, l.b); return hyp(b[0] - a[0], b[1] - a[1]); } };
+  };
   const unit = (a: [number, number], b: [number, number]): [number, number] => {
     const x = b[0] - a[0], y = b[1] - a[1], n = hyp(x, y) || 1e-12;
     return [x / n, y / n];
@@ -49,24 +81,27 @@ export function consEqs(sk: Sketch, c: Constraint, P: PFn, D: DFn, RV: RVFn, RD:
     }
     case 'tan': {
       // line tangent to a circle/arc: the centre's distance from the (infinite) line equals the radius,
-      // on the side the centre started on (sign), so it never flips across the line
+      // on the side the centre started on (tanSide), so it never flips across the line
       const l = L(c.l), r = rad(c.c);
       if (!l || !r) break;
+      const s = tanSide(sk, c);
       // an arc that ends on one of the line's ends (a fillet, a smooth join): tangent there is its radius to that end
-      // standing square to the line. (The distance form has no slope at that point, so the solver couldn't tell a
-      // second such tangent from one that's already true.)
+      // standing square to the line, from its own side. (The distance form has no slope at that point, so the solver
+      // couldn't tell a second such tangent from one that's already true.) Square alone is true of the arc's mirror
+      // image across the line too, which a fast drag could land on — and the arc, drawn counter-clockwise from its
+      // start to its end, then went the long way round. So it's the angle from the line's normal on the centre's side
+      // to the radius: a slope at the answer, as square had, and half a turn out on the wrong side, never zero.
       const ci = curveInfo(sk, c.c);
       const joint = ci && ci.kind === 'arc' ? [ci.o.a, ci.o.b].find(p => p === l.a || p === l.b) : undefined;
       if (ci && joint) {
         const o = ci.o.c;
         out.push([[...D(l.a), ...D(l.b), ...D(o), ...D(joint)], X => {
           const a = P(X, l.a), b = P(X, l.b), m = P(X, o), e = P(X, joint);
-          const ux = b[0] - a[0], uy = b[1] - a[1], vx = e[0] - m[0], vy = e[1] - m[1];
-          return (ux * vx + uy * vy) / ((hyp(ux, uy) || 1e-12) * (hyp(vx, vy) || 1e-12));
+          const ux = b[0] - a[0], uy = b[1] - a[1], wx = m[0] - e[0], wy = m[1] - e[1];
+          return Math.atan2(ux * wx + uy * wy, s * (ux * wy - uy * wx));
         }]);
         break;
       }
-      const s = c.sign || 1;
       out.push([[...D(l.a), ...D(l.b), ...D(r.c), ...r.deps], X => {
         const o = P(X, r.c), a = P(X, l.a), b = P(X, l.b), n = hyp(b[0] - a[0], b[1] - a[1]) || 1e-12;
         return (s * ((b[0] - a[0]) * (o[1] - a[1]) - (b[1] - a[1]) * (o[0] - a[0]))) / n - r.f(X);
@@ -86,12 +121,10 @@ export function consEqs(sk: Sketch, c: Constraint, P: PFn, D: DFn, RV: RVFn, RD:
       break;
     }
     case 'eq': {
-      const l1 = L(c.l1), l2 = L(c.l2);
-      if (!l1 || !l2) break;
-      out.push([[...D(l1.a), ...D(l1.b), ...D(l2.a), ...D(l2.b)], X => {
-        const a = P(X, l1.a), b = P(X, l1.b), p = P(X, l2.a), q = P(X, l2.b);
-        return hyp(b[0] - a[0], b[1] - a[1]) - hyp(q[0] - p[0], q[1] - p[1]);
-      }]);
+      if (!L(c.l1) || !L(c.l2)) break;
+      // (a wall's edge picked: that face's length — faces)
+      const a = len(c.l1!, c.faces?.[0]), b = len(c.l2!, c.faces?.[1]);
+      out.push([[...a.deps, ...b.deps], X => a.f(X) - b.f(X)]);
       break;
     }
     case 'eqr': {
@@ -111,9 +144,12 @@ export function consEqs(sk: Sketch, c: Constraint, P: PFn, D: DFn, RV: RVFn, RD:
     case 'online': {
       const l = L(c.l);
       if (!l) break;
+      // on one face of a wall: half its thickness to that side of the centreline — read when solved, so a wall made
+      // thicker carries what's on its face with it
+      const faceOff = () => (c.face && l.kind === 'wall' ? (c.face * l.thick) / 2 : 0);
       out.push([[...D(c.p!), ...D(l.a), ...D(l.b)], X => {
         const p = P(X, c.p!), a = P(X, l.a), b = P(X, l.b), dx = b[0] - a[0], dy = b[1] - a[1], n = hyp(dx, dy) || 1e-12;
-        return ((p[0] - a[0]) * dy - (p[1] - a[1]) * dx) / n;
+        return ((p[0] - a[0]) * dy - (p[1] - a[1]) * dx) / n + faceOff();
       }]);
       break;
     }
@@ -126,15 +162,9 @@ export function consEqs(sk: Sketch, c: Constraint, P: PFn, D: DFn, RV: RVFn, RD:
     case 'dist': {
       const fw = c.face && c.line && (!c.kind || c.kind === 'al') ? L(c.line) : undefined;
       if (fw && fw.kind === 'wall') {
-        // along one face of a wall, corner to corner: the walls at its ends cut it short (an inside corner) or carry it
-        // on (an outside one), so they're part of it too
-        const ends = faceEnds(sk, c.line!), side = c.face!;
-        const deps = [...D(fw.a), ...D(fw.b), ...[...ends.a, ...ends.b].flatMap(e => D(e.far ?? e.arc!.c))];
-        out.push([deps, X => {
-          const at = (id: string) => { const q = P(X, id); return { x: q[0], y: q[1] }; };
-          const f = faceSpan(at, at(fw.a), at(fw.b), fw.thick, side, ends);
-          return (f ? f.s1 - f.s0 : 0) - c.value!;
-        }]);
+        // along one face of a wall, corner to corner
+        const f = len(c.line!, c.face);
+        out.push([f.deps, X => f.f(X) - c.value!]);
         break;
       }
       const deps = [...D(c.a!), ...D(c.b!)], s = c.sign || 1;

package/src/solver/gauss-newton.ts

@@ -1,7 +1,7 @@
 import { isDim, measure, relatedCons } from '../model/constraints';
 import { addCons, restorePos, snapshotPos } from '../model/sketch';
 import type { Analysis, Constraint, Sketch, XY } from '../model/types';
-import { buildSys, getX, type System, type Vec } from './equations';
+import { buildSys, getX, tanSide, type System, type Vec } from './equations';
 import { blocks, compactRows, envAt, envelopeOf, jac, rref, rrefTol, solveDense, solveEnvelope, sq, type Envelope, type Row } from './linalg';
 import type { AddResult, SolveResult, Solver } from './types';
 
@@ -180,6 +180,9 @@ export class GaussNewtonSolver implements Solver {
   }
 
   drag(sk: Sketch, ids: string[], targets: XY[]): boolean {
+    // (a tangent saved before tangents kept a side keeps the one it's on now, read before the dragged points jump to
+    // the pointer: read after, a moved end of its line could put it on the wrong one)
+    for (const c of Object.values(sk.cons)) if (c.type === 'tan' && !c.sign) c.sign = tanSide(sk, c);
     const snap = snapshotPos(sk);
     ids.forEach((id, i) => { sk.points[id].x = targets[i].x; sk.points[id].y = targets[i].y; });
     const s = this.solve(sk, ids);

package/src/styles.css

@@ -96,7 +96,7 @@ input{font:inherit}
 
 /* bottom contextual bar */
 .bottom{position:absolute;left:50%;bottom:14px;transform:translateX(-50%);display:flex;align-items:center;gap:12px;z-index:24;max-width:calc(100% - 180px)}
-.ctx{display:flex;align-items:center;gap:2px;background:var(--g2);border-radius:33px;padding:6px;overflow-x:auto;scrollbar-width:none;box-shadow:0 6px 22px rgba(0,0,0,.26);max-width:100%}
+.ctx{display:flex;align-items:center;gap:2px;background:var(--g2);border-radius:30px;min-height:60px;padding:3px 6px;overflow-x:auto;scrollbar-width:none;box-shadow:0 6px 22px rgba(0,0,0,.26);max-width:100%}
 .ctx::-webkit-scrollbar{display:none}
 .cb{min-width:58px;height:54px;border-radius:27px;display:flex;flex-direction:column;align-items:center;justify-content:center;gap:3px;color:#fff;font-size:10.5px;font-weight:500;padding:0 8px;flex-shrink:0;white-space:nowrap;transition:background .12s}
 .cb:hover{background:rgba(255,255,255,.08)}
@@ -104,9 +104,10 @@ input{font:inherit}
 .cb[disabled]{opacity:.35;pointer-events:none}
 .cb.warn{color:#FFB4AE}
 .cb.locked{color:var(--red)}
+.cb.lead{min-width:48px;width:48px;height:48px;border-radius:50%;padding:0}
 .ctx .sep{width:1px;height:32px;background:var(--g3);margin:0 4px;flex-shrink:0}
 .ctx .lbl{font-size:12px;color:var(--lg1);padding:0 10px;white-space:nowrap;flex-shrink:0}
-.addbtn{width:48px;height:48px;border-radius:50%;background:var(--yellow);color:var(--dark);display:flex;align-items:center;justify-content:center;flex-shrink:0;margin-left:4px;margin-right:3px}
+.addbtn{width:48px;height:48px;border-radius:50%;background:var(--yellow);color:var(--dark);display:flex;align-items:center;justify-content:center;flex-shrink:0;margin-left:4px}
 /* the + stays pinned at the end of the bar while the other actions scroll under it (phone) */
 .ctx .addbtn{position:sticky;right:0;z-index:1;box-shadow:0 0 0 6px var(--g2),-16px 0 10px -2px var(--g2)}
 .ctx:has(.addbtn){padding-right:6px}

package/src/tools/annotate.ts

@@ -1,10 +1,9 @@
 import { targetImage } from '../editor/project';
 import { imageById } from '../model/images';
-import { strokeToLines } from './freehand';
 import { afterEdit } from '../app/edit';
 import { ed } from '../app/state';
 import { hyp } from '../model/geom';
-import { dropHistory, pushHistory } from '../model/history';
+import { pushHistory } from '../model/history';
 import { uid } from '../model/ids';
 import { page, SK } from '../model/store';
 import { dashFor, DEFAULT_NOTE_WIDTH, NOTE_TEXT_IN, noteLook, shapeOutline } from '../model/markup';
@@ -16,7 +15,6 @@ import { fitView, mainT, requestDraw, requestOverlayDraw, S, s2w, underlayH } fr
 import { tools, type PEv, type Tool } from './registry';
 import { hitAny } from '../render/hit';
 import { selectTool } from './select';
-import { setMode } from '../editor/mode';
 import { hideNoteInput, openKeypad, setCursor, showNoteInput, toast, updateHint } from '../editor/ports';
 import { selectionHint } from '../editor/selection';
 
@@ -194,21 +192,6 @@ export const calibTool = {
   hint() { return ['Tap the first end of something you know the length of.', 'Tap the other end.'][this.st.pts.length] || ''; },
 };
 
-/** Turn a pen stroke into straight lines, squaring near-horizontal/vertical segments. */
-export function convertNote(id: string): void {
-  const sk = SK();
-  const n = sk.notes.find(n => n.id === id);
-  if (!n || !n.pts) return;
-  pushHistory();
-  const r = strokeToLines(n.pts.map(p => ({ x: p[0], y: p[1] })));
-  if (!r) { dropHistory(); toast('That stroke is too small to turn into lines.', { warn: true }); return; }
-  sk.notes = sk.notes.filter(x => x.id !== id);
-  setMode('draft');
-  ed.sel = r.lines.map(id => ({ type: 'line' as const, id }));
-  afterEdit();
-  toast('Turned into ' + r.lines.length + ' line' + (r.lines.length > 1 ? 's' : '') + '. Select a line and tap + to add its length.');
-}
-
 /**
  * Lets a markup drawing tool (pen, arrow, cloud) reshape what was just drawn: a press on a handle of the selected
  * markup is handed to Select markup (reshape); anywhere else draws as usual.

package/src/tools/chamfer.ts

@@ -8,6 +8,7 @@ import { requestDraw } from '../render/view';
 import { solver } from '../solver';
 import { fmtLen } from '../units';
 import { closeKeypad, openKeypad, toast, updateCtx } from '../editor/ports';
+import { waitForScale } from '../editor/scaleGate';
 import { cornerAt, cutCorner } from './corner';
 
 /*
@@ -33,6 +34,8 @@ function showSide(lid: string | null): void { ed.sel = lid ? [{ type: 'line', id
 export function chamferPrompt(pid: string): void {
   const sk = SK(), k = cornerAt(sk, pid);
   if (!k) { toast('Select a corner where two lines meet to cut it off.', { warn: true }); return; }
+  // (a distance typed is real: nothing drawn says what it is in a sketch without its scale yet — editor/scaleGate.ts)
+  if (waitForScale()) return;
   const most = Math.min(k.len1, k.len2), start = Math.round(Math.min(6, most * 0.5) * 16) / 16;
   openKeypad({
     title: 'Chamfer', sub: 'Back from the corner along each side — up to ' + fmtLen(most), initial: fmtLen(start), value: start, selectAll: true, laser: true,

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();
         },