@reekon-tools/boldr-cad 1.4.0 → 1.6.0

package/src/model/rooms.ts

@@ -1,25 +1,58 @@
 import { hyp, normAng, pointInPoly, polyArea } from './geom';
 import { uid } from './ids';
-import { linesBetween } from './sketch';
+import { circleEdge, linesBetween, onCircle } from './sketch';
 import type { Room, Sketch, XY } from './types';
 
 /*
-  Rooms are faces of the drawing: closed loops of walls and lines, straight or curved.
-  A loop is a list of corner points plus (for loops that include curves) the edge — line or arc id —
-  between each corner and the next. Curves are measured as densely sampled polylines.
+  Rooms are faces of the drawing: closed loops of walls and lines, straight or curved — and circles (the user's call,
+  2026-10-29: "a space can be created by all closed shapes").
+  A loop is a list of corner points plus (for loops that include curves) the edge between each corner and the next:
+  a line's or arc's id — or, along a circle, the circle's id and which way round the loop runs on it: '<id>+'
+  counter-clockwise, '<id>-' clockwise (circleEdge). A circle that is a room's whole outline has no corners: loop [],
+  edges ['<id>+']. Where a line or an arc ends on a circle, the circle is divided there, as lines are at a corner.
+  Curves are measured as densely sampled polylines; a round room's area and perimeter exactly.
 */
 
 /** Arcs are sampled every 5° for room outlines (≥ 8 pieces). */
 const ARC_STEP = Math.PI / 36;
 
-/** An edge of the drawing that can bound a room: a non-construction line or arc. */
-interface Edge { id: string; a: string; b: string }
+/**
+ * An edge of the drawing that can bound a room: a non-construction line or arc, or a piece of a non-construction
+ * circle between two points on it (`circle`: counter-clockwise from a to b).
+ */
+interface Edge { id: string; a: string; b: string; circle?: string }
 
-function edgesOf(sk: Sketch): Edge[] {
-  const out: Edge[] = [];
-  for (const id in sk.lines) { const l = sk.lines[id]; if (!l.constr) out.push({ id, a: l.a, b: l.b }); }
-  for (const id in sk.arcs) { const a = sk.arcs[id]; if (!a.constr) out.push({ id, a: a.a, b: a.b }); }
-  return out;
+/**
+ * The drawing as edges between points, for walking its faces. A circle is in pieces between the points on it where a
+ * line or an arc ends; one with fewer than two gets the walk's own points (opposite each other, or the one there), so
+ * it's a loop like any other. They're not the drawing's, and never left in a room (stored).
+ */
+function graph(sk: Sketch): { edges: Edge[]; pos: (p: string) => XY } {
+  const edges: Edge[] = [], ends = new Set<string>();
+  for (const id in sk.lines) { const l = sk.lines[id]; if (!l.constr) { edges.push({ id, a: l.a, b: l.b }); ends.add(l.a); ends.add(l.b); } }
+  for (const id in sk.arcs) { const a = sk.arcs[id]; if (!a.constr) { edges.push({ id, a: a.a, b: a.b }); ends.add(a.a); ends.add(a.b); } }
+  const own = new Map<string, XY>();
+  for (const cid in sk.circles) {
+    const ci = sk.circles[cid], o = sk.points[ci.c];
+    if (ci.constr || !o || !(ci.r > 0)) continue;
+    const on = [...ends].filter(p => onCircle(sk, cid, p)).map(p => ({ p, t: normAng(Math.atan2(sk.points[p].y - o.y, sk.points[p].x - o.x)) }));
+    const add = (t: number) => { const id = '~' + cid + '~' + on.length; own.set(id, { x: o.x + ci.r * Math.cos(t), y: o.y + ci.r * Math.sin(t) }); on.push({ p: id, t: normAng(t) }); };
+    if (!on.length) add(0);
+    if (on.length === 1) add(on[0].t + Math.PI);
+    on.sort((u, v) => u.t - v.t);
+    on.forEach((u, i) => edges.push({ id: cid + '#' + i, a: u.p, b: on[(i + 1) % on.length].p, circle: cid }));
+  }
+  return { edges, pos: p => sk.points[p] ?? own.get(p)! };
+}
+
+/** Round a circle (centre o, radius r) from A to B, counter-clockwise (dir 1) or clockwise (−1), sampled; all the way round when they're the same point. */
+function roundCircle(o: XY, r: number, A: XY, B: XY, dir: 1 | -1): XY[] {
+  const t0 = Math.atan2(A.y - o.y, A.x - o.x), t1 = Math.atan2(B.y - o.y, B.x - o.x);
+  const sweep = normAng(dir * (t1 - t0)) || 2 * Math.PI, n = Math.max(8, Math.ceil(sweep / ARC_STEP));
+  const pts: XY[] = [];
+  for (let i = 0; i <= n; i++) { const t = t0 + (dir * sweep * i) / n; pts.push({ x: o.x + r * Math.cos(t), y: o.y + r * Math.sin(t) }); }
+  pts[0] = A; pts[n] = B;
+  return pts;
 }
 
 /** Ids of the lines and arcs joining two points. */
@@ -29,10 +62,18 @@ export function edgesBetween(sk: Sketch, a: string, b: string): string[] {
   return out;
 }
 
-/** An edge as a polyline starting at point `from` (lines: 2 points; arcs: sampled along the curve). */
-export function edgePolyline(sk: Sketch, id: string, from: string): XY[] {
+/**
+ * A room edge as a polyline starting at point `from` (lines: 2 points; arcs: sampled along the curve). Along a
+ * circle ('<id>±'), round it to point `to` — or, with no corners (a whole circle), from its rightmost point back to it.
+ */
+export function edgePolyline(sk: Sketch, id: string, from?: string, to?: string): XY[] {
+  const ce = circleEdge(id);
+  if (ce) {
+    const ci = sk.circles[ce.cid], o = sk.points[ci.c], A = from ? sk.points[from] : { x: o.x + ci.r, y: o.y };
+    return roundCircle(o, ci.r, A, to ? sk.points[to] : A, ce.dir);
+  }
   const l = sk.lines[id];
-  if (l) { const other = l.a === from ? l.b : l.a; return [sk.points[from], sk.points[other]]; }
+  if (l) { const other = l.a === from ? l.b : l.a; return [sk.points[from!], sk.points[other]]; }
   const ar = sk.arcs[id], o = sk.points[ar.c], s = sk.points[ar.a], e = sk.points[ar.b];
   const r = hyp(s.x - o.x, s.y - o.y), t0 = Math.atan2(s.y - o.y, s.x - o.x);
   const sweep = normAng(Math.atan2(e.y - o.y, e.x - o.x) - t0) || 2 * Math.PI; // arcs run counter-clockwise a → b
@@ -44,15 +85,14 @@ export function edgePolyline(sk: Sketch, id: string, from: string): XY[] {
 }
 
 const edgeThick = (sk: Sketch, id: string): number => {
-  const l = sk.lines[id];
-  if (l) return l.kind === 'wall' ? l.thick : 0;
-  const a = sk.arcs[id];
-  return a && a.kind === 'wall' ? a.thick || 4.5 : 0;
+  const ce = circleEdge(id);
+  const o = ce ? sk.circles[ce.cid] : sk.lines[id] ?? sk.arcs[id];
+  return o && o.kind === 'wall' ? (o as { thick?: number }).thick || 4.5 : 0;
 };
 
 /** The edges of a room loop: stored ones, or (older rooms of straight lines) the line joining each pair. */
 export function roomEdges(sk: Sketch, r: Room): string[] | null {
-  if (r.edges && r.edges.length === r.loop.length) return r.edges;
+  if (r.edges && (r.edges.length === r.loop.length || (!r.loop.length && r.edges.length === 1))) return r.edges;
   const out: string[] = [];
   for (let i = 0; i < r.loop.length; i++) {
     const e = edgesBetween(sk, r.loop[i], r.loop[(i + 1) % r.loop.length])[0];
@@ -66,59 +106,90 @@ export function roomEdges(sk: Sketch, r: Room): string[] | null {
 function outline(sk: Sketch, loop: string[], edges: string[]): { pts: XY[]; half: number[] } {
   const pts: XY[] = [], half: number[] = [];
   edges.forEach((id, i) => {
-    const pl = edgePolyline(sk, id, loop[i]), t = edgeThick(sk, id) / 2;
+    const pl = edgePolyline(sk, id, loop[i], loop[(i + 1) % loop.length]), t = edgeThick(sk, id) / 2;
     for (let k = 0; k < pl.length - 1; k++) { pts.push(pl[k]); half.push(t); }
   });
   return { pts, half };
 }
 
-/** Find the smallest closed face of lines and arcs around (wx, wy): its corner points and the edge after each. */
+/**
+ * A face as it's walked, as it's kept: a circle's pieces as the circle the way round it's walked ('<id>±'), and no
+ * corner between two stretches of one circle the same way round — not the walk's own points, nor where something
+ * meets the circle from outside (the room would go with it). All the way round one circle: no corners at all.
+ */
+function kept(loop: string[], edges: Edge[]): { loop: string[]; edges: string[] } {
+  const L = loop.slice(), E = edges.map((e, i) => (e.circle ? e.circle + (L[i] === e.a ? '+' : '-') : e.id));
+  for (let again = true; again && L.length > 1;) {
+    again = false;
+    for (let i = 0; i < L.length; i++) {
+      if (E[(i - 1 + L.length) % L.length] === E[i] && circleEdge(E[i])) { L.splice(i, 1); E.splice(i, 1); again = true; break; }
+    }
+  }
+  return L.length === 1 && circleEdge(E[0]) ? { loop: [], edges: E } : { loop: L, edges: E };
+}
+
+/**
+ * Find the smallest closed face of lines, arcs and circles around (wx, wy): its corner points and the edge after
+ * each. A ray to +x crosses the face's outline; the nearest crossing is on it unless it's an island inside the face
+ * (a column), whose own outline doesn't hold the point — then the next.
+ */
 export function findFace(sk: Sketch, wx: number, wy: number): { loop: string[]; edges: string[] } | null {
-  const edges = edgesOf(sk), byId = new Map(edges.map(e => [e.id, e]));
+  const g = graph(sk), byId = new Map(g.edges.map(e => [e.id, e]));
   const adj = new Map<string, Edge[]>();
-  for (const e of edges) for (const p of [e.a, e.b]) { if (!adj.has(p)) adj.set(p, []); adj.get(p)!.push(e); }
-  // cast a ray to +x; the nearest crossing edge is on the face boundary
-  let best: { x: number; e: Edge; forward: boolean } | null = null;
-  for (const e of edges) {
-    const pl = edgePolyline(sk, e.id, e.a);
+  for (const e of g.edges) for (const p of [e.a, e.b]) { if (!adj.has(p)) adj.set(p, []); adj.get(p)!.push(e); }
+  /** An edge as a polyline from one of its ends. */
+  const along = (e: Edge, from: string): XY[] => {
+    if (!e.circle) return edgePolyline(sk, e.id, from);
+    const ci = sk.circles[e.circle], pts = roundCircle(sk.points[ci.c], ci.r, g.pos(e.a), g.pos(e.b), 1);
+    return from === e.a ? pts : pts.reverse();
+  };
+  // every crossing of the ray, nearest first: walking the edge the way that has the point on its left
+  const hits: { x: number; e: Edge; forward: boolean }[] = [];
+  for (const e of g.edges) {
+    const pl = along(e, e.a);
     for (let k = 0; k < pl.length - 1; k++) {
       const A = pl[k], B = pl[k + 1];
       if ((A.y > wy) === (B.y > wy)) continue;
       const x = A.x + ((wy - A.y) * (B.x - A.x)) / (B.y - A.y);
-      if (x <= wx || (best && x >= best.x)) continue;
-      // walk the edge in the direction that has the tap point on its left
-      const cr = (B.x - A.x) * (wy - A.y) - (B.y - A.y) * (wx - A.x);
-      best = { x, e, forward: cr >= 0 };
+      if (x <= wx) continue;
+      hits.push({ x, e, forward: (B.x - A.x) * (wy - A.y) - (B.y - A.y) * (wx - A.x) >= 0 });
     }
   }
-  if (!best) return null;
-  const start = best.forward ? best.e.a : best.e.b;
-  const dirFrom = (id: string, p: string) => { const pl = edgePolyline(sk, id, p); return Math.atan2(pl[1].y - pl[0].y, pl[1].x - pl[0].x); };
-  const loop = [start], loopEdges = [best.e.id];
-  let inEdge = best.e, cur = best.forward ? best.e.b : best.e.a, guard = 0;
-  // walk the face, always taking the tightest turn (direction of travel measured along the curve at the corner)
-  while (cur !== start && guard++ < 400) {
-    loop.push(cur);
-    const nb = adj.get(cur) || [];
-    const a0 = dirFrom(inEdge.id, cur);
-    let next: Edge | null = null, bd = Infinity;
-    for (const e of nb) {
-      if (e.id === inEdge.id && nb.length > 1) continue;
-      let d = a0 - dirFrom(e.id, cur);
-      while (d <= 1e-9) d += 2 * Math.PI;
-      while (d > 2 * Math.PI + 1e-9) d -= 2 * Math.PI;
-      if (d < bd) { bd = d; next = e; }
+  hits.sort((p, q) => p.x - q.x);
+  const dirFrom = (e: Edge, p: string) => { const pl = along(e, p); return Math.atan2(pl[1].y - pl[0].y, pl[1].x - pl[0].x); };
+  const tried = new Set<string>();
+  for (const h of hits) {
+    const key = h.e.id + (h.forward ? '>' : '<');
+    if (tried.has(key)) continue;
+    tried.add(key);
+    const start = h.forward ? h.e.a : h.e.b;
+    const loop = [start], loopEdges = [h.e];
+    let inEdge = h.e, cur = h.forward ? h.e.b : h.e.a, guard = 0;
+    // walk the face, always taking the tightest turn (direction of travel measured along the curve at the corner)
+    while (cur !== start && guard++ < 400) {
+      loop.push(cur);
+      const nb = adj.get(cur) || [];
+      const a0 = dirFrom(inEdge, cur);
+      let next: Edge | null = null, bd = Infinity;
+      for (const e of nb) {
+        if (e.id === inEdge.id && nb.length > 1) continue;
+        let d = a0 - dirFrom(e, cur);
+        while (d <= 1e-9) d += 2 * Math.PI;
+        while (d > 2 * Math.PI + 1e-9) d -= 2 * Math.PI;
+        if (d < bd) { bd = d; next = e; }
+      }
+      if (!next) break;
+      loopEdges.push(next);
+      cur = next.a === cur ? next.b : next.a;
+      inEdge = byId.get(next.id)!;
     }
-    if (!next) return null;
-    loopEdges.push(next.id);
-    cur = next.a === cur ? next.b : next.a;
-    inEdge = byId.get(next.id)!;
+    if (cur !== start) continue;
+    const face = kept(loop, loopEdges);
+    if (face.loop.some(p => !sk.points[p])) continue;
+    const poly = outline(sk, face.loop, face.edges).pts;
+    if (polyArea(poly) > 0 && pointInPoly({ x: wx, y: wy }, poly)) return face;
   }
-  if (cur !== start) return null;
-  const poly = outline(sk, loop, loopEdges).pts;
-  if (polyArea(poly) <= 0) return null;
-  if (!pointInPoly({ x: wx, y: wy }, poly)) return null;
-  return { loop, edges: loopEdges };
+  return null;
 }
 
 export interface RoomGeom {
@@ -153,9 +224,12 @@ export function roomGeom(sk: Sketch, r: Room): RoomGeom {
     const t = ((e2.p.x - e1.p.x) * e2.d.y - (e2.p.y - e1.p.y) * e2.d.x) / den;
     inner.push({ x: e1.p.x + e1.d.x * t, y: e1.p.y + e1.d.y * t });
   }
-  const area = Math.abs(polyArea(inner));
+  let area = Math.abs(polyArea(inner));
   let per = 0;
   for (let i = 0; i < inner.length; i++) { const a = inner[i], b = inner[(i + 1) % inner.length]; per += hyp(b.x - a.x, b.y - a.y); }
+  // a round room: its area and perimeter exactly, to the inside face of its wall (not the sampled outline's)
+  const whole = !r.loop.length && edges?.length === 1 ? circleEdge(edges[0]) : null, ci = whole && sk.circles[whole.cid];
+  if (ci) { const ri = Math.max(0, ci.r - edgeThick(sk, edges![0]) / 2); area = Math.PI * ri * ri; per = 2 * Math.PI * ri; }
   let cx = 0, cy = 0, A = 0;
   for (let i = 0; i < n; i++) {
     const a = poly[i], b = poly[(i + 1) % n];
@@ -167,16 +241,30 @@ export function roomGeom(sk: Sketch, r: Room): RoomGeom {
 }
 
 /**
- * Add a room for a closed loop (or return the existing one). `edges` names the line/arc after each corner;
- * leave it out for loops of straight lines. Null if it's under 1 sq ft.
+ * A room's outline for telling what's inside it: its corners (cheap, and what it's always been) — or, for one that
+ * runs round a circle (it has too few corners to say), its outline as drawn.
+ */
+export function roomOutline(sk: Sketch, r: Room): XY[] {
+  return r.loop.length >= 3 && !(r.edges ?? []).some(e => circleEdge(e)) ? r.loop.map(p => sk.points[p]) : roomGeom(sk, r).poly;
+}
+
+/**
+ * Add a room for a closed loop (or return the existing one). `edges` names the line/arc (or way round a circle) after
+ * each corner; leave it out for loops of straight lines. A whole circle has no corners: loop [] and its one edge. Null
+ * if it's under 1 sq ft.
  */
 export function maybeRoom(sk: Sketch, loop: string[], edges?: string[]): string | null {
-  if (loop.length < 2 || 'cabs' in sk) return null; // spaces are the plan's: not on a wall face
+  if ('cabs' in sk) return null; // spaces are the plan's: not on a wall face
+  const round = !loop.length && edges?.length === 1 && !!circleEdge(edges[0]);
+  if (loop.length < 2 && !round) return null;
   const es = edges || roomEdges(sk, { loop, name: '' });
   if (!es) return null;
   if (Math.abs(polyArea(outline(sk, loop, es).pts)) < 144) return null;
-  const key = [...es].sort().join('|');
-  for (const id in sk.rooms) { const r = sk.rooms[id], re = roomEdges(sk, r); if (re && [...re].sort().join('|') === key) return id; }
+  // (the same room: the same edges — round a circle, from the same corner: a circle cut by a line bounds two rooms
+  // of the same edges, the two ways round)
+  const keyOf = (l: string[], e: string[]) => e.map((id, i) => (circleEdge(id) ? id + '@' + (l[i] ?? '') : id)).sort().join('|');
+  const key = keyOf(loop, es);
+  for (const id in sk.rooms) { const r = sk.rooms[id], re = roomEdges(sk, r); if (re && keyOf(r.loop, re) === key) return id; }
   const id = uid('r');
   sk.rooms[id] = { loop: loop.slice(), name: 'Space ' + sk.seq.room++, ...(edges ? { edges: edges.slice() } : {}) };
   return id;

package/src/model/scale.ts

@@ -0,0 +1,107 @@
+import { measure } from './constraints';
+import { deep } from './ids';
+import type { Constraint, Page, Sketch, View } from './types';
+
+/*
+  A new page has no scale until its first length (the user's call, 2026-10-29: "first needing to set a dimension
+  before going into 3d, objects, or walls"). People sketch in proportion, not to size, so the inches a stroke gets are
+  only how far the finger went at that zoom. The first length entered (typed, lasered or linked) tells the editor what
+  they are: the whole sketch is scaled so that line is that long, and the view zoomed by the inverse at the same
+  moment, so nothing moves on the screen — only the numbers become real. Later lengths move geometry as before.
+
+  What's scaled is where things are: points, radii, notes, pen marks, link tiles, images, where dimensions sit. What
+  isn't is what has a real size of its own: a wall's thickness and height, a door's or window's size, a cabinet's.
+*/
+
+/** The page's drawing has no scale yet. */
+export const isUnscaled = (sk: Sketch): boolean => !!sk.unscaled;
+
+/** A length a person enters (a line's, a distance, a diameter): what can give the drawing its scale. */
+export const isEnteredLength = (c: Constraint): boolean =>
+  (c.type === 'dist' || c.type === 'pldist' || c.type === 'diam') && c.driving !== false && !c.auto && !c.elev && !c.anchor && (c.value ?? 0) > 0;
+
+/**
+ * A drawing that comes in marked without its scale but with lengths entered all the same — edited by a version from
+ * before this, which kept a mark it didn't know — has its scale: the mark goes, so no length is taken for its first
+ * (that would scale a drawing that's already to size). Run on every drawing loaded or arriving.
+ */
+export function settleScale(sk: Sketch): Sketch {
+  if (sk?.unscaled && Object.values(sk.cons ?? {}).some(isEnteredLength)) delete sk.unscaled;
+  return sk;
+}
+
+/** Scale everything drawn on a sketch by k about the origin: where it is, not what has a size of its own. */
+export function scaleSketch(sk: Sketch, k: number): void {
+  for (const p of Object.values(sk.points)) { p.x *= k; p.y *= k; }
+  for (const c of Object.values(sk.circles)) c.r *= k;
+  for (const o of Object.values(sk.openings)) {
+    o.at *= k;
+    if (o.wOff != null) o.wOff *= k;
+    for (const d of o.dims ?? []) { d.value *= k; if (d.off != null) d.off *= k; }
+  }
+  for (const n of sk.notes) {
+    if (n.pts) n.pts = n.pts.map(([x, y]) => [x * k, y * k]);
+    if (n.x != null) n.x *= k;
+    if (n.y != null) n.y *= k;
+    if (n.leader) n.leader = [n.leader[0] * k, n.leader[1] * k];
+    // (a note's letters and a tile's side are inches on the drawing: they zoom with it, so they scale with it)
+    if (n.ts != null) n.ts *= k;
+  }
+  // (and what the tiles' 100% is, so their percent holds)
+  if (sk.tileRef != null) sk.tileRef *= k;
+  for (const c of Object.values(sk.cons)) {
+    if (c.off != null) c.off *= k;
+    // (none should be here before the first length; one that is keeps measuring what it measures, met as it was)
+    if (c.type === 'dist' || c.type === 'pldist' || c.type === 'diam') c.value = measure(sk, c);
+  }
+}
+
+/** Zoom a view by the inverse of a scale of the drawing about the origin: everything stays where it was on the screen. */
+export function zoomViewBy(v: View, k: number): void {
+  v.s /= k;
+  v.cx *= k;
+  v.cy *= k;
+}
+
+/** Scale a page — its drawing, its images and its view — by k, so nothing moves on the screen. */
+export function scalePage(pg: Page, k: number): void {
+  scaleSketch(pg.sk, k);
+  for (const u of pg.underlays) {
+    u.x *= k; u.y *= k; u.w *= k;
+    if (u.h != null) u.h *= k;
+  }
+  if (pg.view) zoomViewBy(pg.view, k);
+}
+
+/**
+ * The factor that makes what `c` measures `v`: `v` over what it measures now — or, for a wall's face (which is its
+ * centreline's length or distance, less or more a thickness that doesn't scale), what makes that face `v`. What a
+ * dimension measures is linear in the scale (a + b·k), so two measures find it. Null when there's nothing to measure.
+ */
+export function factorFor(sk: Sketch, c: Constraint, v: number): number | null {
+  const now = measure(sk, c);
+  if (!(now > 1e-9) || !(v > 0)) return null;
+  const k1 = v / now;
+  if (Math.abs(k1 - 1) < 1e-12) return 1;
+  const trial = deep(sk);
+  scaleSketch(trial, k1);
+  const at1 = measure(trial, c), b = (at1 - now) / (k1 - 1), a = now - b, k = (v - a) / b;
+  return b > 1e-9 && k > 0 && Number.isFinite(k) ? k : k1;
+}
+
+/** Give an unscaled page its scale: scaled by k (1: as it is), its view zoomed to match. */
+export function setScale(pg: Page, k: number): void {
+  if (Math.abs(k - 1) > 1e-12) scalePage(pg, k);
+  delete pg.sk.unscaled;
+  pg.sk.scaledBy = k;
+}
+
+/**
+ * A drawing replaced by one from either side of the step that gave it its scale (undo, redo, or the scaled one
+ * arriving from elsewhere): the view zooms back, or again, so the drawing stays where it was on the screen.
+ */
+export function rezoomAcrossScale(pg: Page, was: Sketch, now: Sketch): void {
+  if (!pg.view || !!was.unscaled === !!now.unscaled) return;
+  const k = now.unscaled ? 1 / (was.scaledBy || 1) : now.scaledBy || 1;
+  if (Math.abs(k - 1) > 1e-12) zoomViewBy(pg.view, k);
+}

package/src/model/settings.ts

@@ -5,7 +5,6 @@ export interface Layers {
   underlay: boolean;
   construction: boolean;
   dims: boolean;
-  print: boolean;
   rooms: boolean;
   annot: boolean;
   /** cabinets, doors and windows snap to corners and each other as they're placed and dragged */
@@ -27,7 +26,7 @@ export interface Settings extends UnitPrefs {
   wallH: number;
 }
 
-export const defaultLayers = (): Layers => ({ underlay: true, construction: true, dims: true, print: true, rooms: true, annot: true, cabinets: true, objSnap: true });
+export const defaultLayers = (): Layers => ({ underlay: true, construction: true, dims: true, rooms: true, annot: true, cabinets: true, objSnap: true });
 
 export const settings = sessionState((): Settings => ({
   unit: 'ftin', denom: 16, snapGrid: false, autoCons: true, toolTips: true, showCons: true, theme: 'system', welcomed: false,

package/src/model/sketch.ts

@@ -57,6 +57,21 @@ export function refExists(sk: Sketch, id: string): boolean {
 export const pinnedPoints = new Set<string>();
 onSessionReset(() => pinnedPoints.clear());
 
+/**
+ * An arc whose ends are one point — dragged all the way round onto its start (the user's call, 2026-10-29: "if u fully
+ * rotate it to reach around - it should create a circle") — becomes that circle. It keeps the arc's id, so what refers
+ * to it (its radius, a tangent, Equal radius, Concentric) refers to the circle, and its look (a wall, its thickness, a
+ * guide). The point its ends were stays on it, for whatever else it's an end of (a line): gc lets it go if nothing is.
+ */
+export function closeArc(sk: Sketch, id: string): void {
+  const a = sk.arcs[id], o = sk.points[a.c], p = sk.points[a.a];
+  if (!o || !p) return;
+  const { c, constr, kind, thick } = a;
+  sk.circles[id] = { c, r: hyp(p.x - o.x, p.y - o.y), ...(constr ? { constr } : {}), ...(kind ? { kind } : {}), ...(thick ? { thick } : {}) };
+  delete sk.arcs[id];
+  addCons(sk, { type: 'oncircle', p: a.a, c: id });
+}
+
 /** Remove dangling entities, constraints and points, repeating until stable. */
 export function gc(sk: Sketch): void {
   let changed = true, guard = 0;
@@ -70,6 +85,8 @@ export function gc(sk: Sketch): void {
     for (const id in sk.arcs) {
       const a = sk.arcs[id];
       if (!sk.points[a.c] || !sk.points[a.a] || !sk.points[a.b]) { delete sk.arcs[id]; changed = true; }
+      // its ends one point (dragged all the way round and joined): all the way round, a circle
+      else if (a.a === a.b) { closeArc(sk, id); changed = true; }
     }
     for (const id in sk.cons) {
       const c = sk.cons[id];
@@ -167,12 +184,33 @@ export function linesBetween(sk: Sketch, a: string, b: string): string[] {
   return out;
 }
 
+/**
+ * A room's edge round a circle (model/rooms.ts): '<circle id>+' runs counter-clockwise from the corner to the next,
+ * '<circle id>-' clockwise. Null for a line's or an arc's id.
+ */
+export function circleEdge(id: string): { cid: string; dir: 1 | -1 } | null {
+  const k = id[id.length - 1];
+  return k === '+' || k === '-' ? { cid: id.slice(0, -1), dir: k === '+' ? 1 : -1 } : null;
+}
+
+/** A point is on a circle (not its centre): where a line or an arc ends on it, or what's held to it. */
+export function onCircle(sk: Sketch, cid: string, pid: string): boolean {
+  const ci = sk.circles[cid], o = ci && sk.points[ci.c], p = sk.points[pid];
+  return !!o && !!p && pid !== ci.c && Math.abs(hyp(p.x - o.x, p.y - o.y) - ci.r) <= 1e-3;
+}
+
 export function roomValid(sk: Sketch, r: Room): boolean {
-  if (!r.loop || r.loop.length < 2 || (!r.edges && r.loop.length < 3)) return false;
+  if (!r.loop) return false;
+  // a whole circle: no corners — the circle still there
+  if (!r.loop.length) { const ce = r.edges?.length === 1 ? circleEdge(r.edges[0]) : null; return !!ce && !!sk.circles[ce.cid] && !!sk.points[sk.circles[ce.cid].c]; }
+  if (r.loop.length < 2 || (!r.edges && r.loop.length < 3)) return false;
   for (let i = 0; i < r.loop.length; i++) {
     const a = r.loop[i], b = r.loop[(i + 1) % r.loop.length];
     if (!sk.points[a]) return false;
     if (r.edges) {
+      // round a circle: both corners still on it
+      const ce = circleEdge(r.edges[i]);
+      if (ce) { if (!onCircle(sk, ce.cid, a) || !onCircle(sk, ce.cid, b)) return false; continue; }
       // each stored edge (line or arc) must still join these two corners
       const id = r.edges[i], l = sk.lines[id], ar = sk.arcs[id];
       const ends = l ? [l.a, l.b] : ar ? [ar.a, ar.b] : null;
@@ -254,13 +292,19 @@ export function lineLen(sk: Sketch, l: Line): number {
   return hyp(b.x - a.x, b.y - a.y);
 }
 
-/** The driving/reference length dimension attached to a line (print dims excluded). */
+/**
+ * The length dimension attached to a line: its driving one, or else a reference one. (A drawing from before print
+ * dimensions were dropped can have both on a line: its print one now reads as a reference.)
+ */
 export function lengthDimOf(sk: Sketch, lid: string): string | null {
+  let ref: string | null = null;
   for (const id in sk.cons) {
     const c = sk.cons[id];
-    if (c.type === 'dist' && c.line === lid && c.layer !== 'print') return id;
+    if (c.type !== 'dist' || c.line !== lid) continue;
+    if (c.driving !== false) return id;
+    ref ??= id;
   }
-  return null;
+  return ref;
 }
 
 export interface PosSnapshot { p: Record<string, [number, number]>; r: Record<string, number> }
@@ -277,23 +321,30 @@ export function restorePos(sk: Sketch, s: PosSnapshot): void {
   for (const id in s.r) if (sk.circles[id]) sk.circles[id].r = s.r[id];
 }
 
-/** Every line and arc joined end to end with the given ones (through shared points), including them. */
+/**
+ * Every line and arc joined end to end with the given ones (through shared points), including them. Guides join only
+ * guides, and walls and lines only walls and lines: a guide drawn off a shape's corner isn't part of the shape, nor the
+ * shape part of the guides (the user's call, 2026-11-02).
+ */
 export function connectedGeometry(sk: Sketch, lineIds: string[], arcIds: string[] = []): { lines: string[]; arcs: string[] } {
+  // the points reached by walls and lines [0], and by guides [1]
+  const pts = [new Set<string>(), new Set<string>()], lines = new Set(lineIds), arcs = new Set(arcIds);
+  type End = { a: string; b: string; constr?: boolean };
   // on a wall face, the plan's corners and edges aren't part of a shape: nothing joins through them
-  const pts = new Set<string>(), lines = new Set(lineIds), arcs = new Set(arcIds);
-  const join = (p: string) => { if (!sk.points[p]?.anchor) pts.add(p); };
-  lineIds.forEach(id => { const l = sk.lines[id]; if (l) { join(l.a); join(l.b); } });
-  arcIds.forEach(id => { const a = sk.arcs[id]; if (a) { join(a.a); join(a.b); } });
+  const join = (o: End) => { for (const p of [o.a, o.b]) if (!sk.points[p]?.anchor) pts[+!!o.constr].add(p); };
+  const meets = (o: End) => pts[+!!o.constr].has(o.a) || pts[+!!o.constr].has(o.b);
+  lineIds.forEach(id => { const l = sk.lines[id]; if (l) join(l); });
+  arcIds.forEach(id => { const a = sk.arcs[id]; if (a) join(a); });
   let grow = true;
   while (grow) {
     grow = false;
     for (const id in sk.lines) {
       const l = sk.lines[id];
-      if (!lines.has(id) && !l.anchor && !l.cab && (pts.has(l.a) || pts.has(l.b))) { lines.add(id); join(l.a); join(l.b); grow = true; }
+      if (!lines.has(id) && !l.anchor && !l.cab && meets(l)) { lines.add(id); join(l); grow = true; }
     }
     for (const id in sk.arcs) {
       const a = sk.arcs[id];
-      if (!arcs.has(id) && (pts.has(a.a) || pts.has(a.b))) { arcs.add(id); join(a.a); join(a.b); grow = true; }
+      if (!arcs.has(id) && meets(a)) { arcs.add(id); join(a); grow = true; }
     }
   }
   return { lines: [...lines], arcs: [...arcs] };

package/src/model/stroke.ts

@@ -2,8 +2,8 @@ import { hyp, rdp } from './geom';
 import type { XY } from './types';
 
 /*
-  Stroke cleanup for Draw to shape and the markup pen's To lines: simplify a freehand stroke into the corners it
-  most likely meant, then square it up to level, plumb and 45° diagonals. Pure geometry (no sketch, no view).
+  Stroke cleanup for Draw to shape: simplify a freehand stroke into the corners it most likely meant, then square it
+  up to level, plumb and 45° diagonals. Pure geometry (no sketch, no view).
 */
 
 /** Screen-pixel tolerances (the result doesn't depend on zoom). Generous, for wobbly lines drawn on site. */