@reekon-tools/boldr-cad 0.1.0 → 1.0.0

package/src/export/pdf.ts

@@ -103,7 +103,7 @@ class Recorder implements Plan {
       else if (p.t === 'arc') for (const q of arcPoints(p.c, p.r, p.s, p.e, 16)) add(q.x, q.y);
       else if (p.t === 'text') add(p.p.x, p.p.y, p.h * Math.max(1, p.s.length * 0.3));
       else if (p.t === 'fill') for (const q of p.pts) add(q.x, q.y);
-      else if (p.shape.kind === 'line') { add(p.shape.a.x, p.shape.a.y, p.thick / 2); add(p.shape.b.x, p.shape.b.y, p.thick / 2); }
+      else if (p.shape.kind === 'polys') for (const q of p.shape.polys.flat()) add(q.x, q.y);
       else add(p.shape.c.x, p.shape.c.y, p.shape.r + p.thick / 2);
     }
     return x0 <= x1 ? { x0, y0, x1, y1 } : null;
@@ -145,8 +145,12 @@ const STYLE: Record<string, { w: number; rgb: [number, number, number]; dash?: s
   SPACES: { w: 0.4, rgb: [0.1, 0.1, 0.1] },
   DIMENSIONS: { w: 0.3, rgb: [0.2, 0.2, 0.2] },
   MARKUP: { w: 0.8, rgb: [0.85, 0.12, 0.1] },
+  // (the palette's blue, as a new link's leader is)
+  LINKS: { w: 0.6, rgb: [0.012, 0.392, 0.957] },
+  CABINETS: { w: 0.45, rgb: [0.35, 0.35, 0.35] },
+  CABINETS_UPPER: { w: 0.45, rgb: [0.35, 0.35, 0.35], dash: '[4 2.5] 0' },
 };
-const FILL: Record<string, [number, number, number]> = { SPACES: [0.94, 0.95, 0.97], KNOCKOUT: [1, 1, 1] };
+const FILL: Record<string, [number, number, number]> = { SPACES: [0.94, 0.95, 0.97], KNOCKOUT: [1, 1, 1], CABINETS: [0.88, 0.88, 0.88] };
 const WALL_RGB: [number, number, number] = [0.22, 0.22, 0.24];
 const rgb = (c: [number, number, number]) => c.map(f).join(' ');
 
@@ -189,11 +193,15 @@ export function sketchToPdf(sk: Sketch, opts: PdfOptions = {}): string {
       const q = p.pts.map(T);
       c.push(rgb(FILL[p.layer] || FILL.SPACES) + ' rg ' + q.map((v, i) => f(v.x) + ' ' + f(v.y) + (i ? ' l' : ' m')).join(' ') + ' h f');
     } else if (p.t === 'wall') {
-      // a solid band of the wall's thickness: a fat stroke with square ends (joints were extended already)
-      c.push('q 0 J ' + f(p.thick * s) + ' w ' + rgb(WALL_RGB) + ' RG []0 d');
+      // a straight wall: its outline, filled (cut to fit its joints); a curve: a fat stroke of the wall's thickness
       const sh = p.shape;
-      if (sh.kind === 'line') { const a = T(sh.a), b = T(sh.b); c.push(f(a.x) + ' ' + f(a.y) + ' m ' + f(b.x) + ' ' + f(b.y) + ' l S'); }
-      else if (sh.kind === 'arc') c.push(arcPath(T(sh.c), sh.r * s, sh.startDeg, sh.endDeg, true) + 'S');
+      if (sh.kind === 'polys') {
+        const path = sh.polys.filter(q => q.length >= 3).map(q => q.map(T).map((v, i) => f(v.x) + ' ' + f(v.y) + (i ? ' l' : ' m')).join(' ') + ' h').join(' ');
+        if (path) c.push(rgb(WALL_RGB) + ' rg ' + path + ' f');
+        continue;
+      }
+      c.push('q 0 J ' + f(p.thick * s) + ' w ' + rgb(WALL_RGB) + ' RG []0 d');
+      if (sh.kind === 'arc') c.push(arcPath(T(sh.c), sh.r * s, sh.startDeg, sh.endDeg, true) + 'S');
       else c.push(arcPath(T(sh.c), sh.r * s, 0, 360, true) + 'h S');
       c.push('Q');
       stroke = '';
@@ -210,7 +218,7 @@ export function sketchToPdf(sk: Sketch, opts: PdfOptions = {}): string {
     } else {
       const size = Math.min(14, Math.max(5, p.h * s));
       const room = p.layer === 'SPACES', bold = room && p.h >= 6;
-      text(T(p.p), size, p.s, { bold, rot: p.rot, rgb: p.layer === 'MARKUP' ? STYLE.MARKUP.rgb : p.layer === 'DIMENSIONS' ? [0.15, 0.15, 0.15] : undefined });
+      text(T(p.p), size, p.s, { bold, rot: p.rot, rgb: p.layer === 'MARKUP' || p.layer === 'LINKS' ? STYLE[p.layer].rgb : p.layer === 'DIMENSIONS' ? [0.15, 0.15, 0.15] : undefined });
     }
   }
   if (!bb) text({ x: ox, y: oy }, 12, 'Nothing drawn on this page yet', { rgb: [0.5, 0.5, 0.5] });

package/src/export/plan.ts

@@ -2,19 +2,28 @@ import { isDim, measure } from '../model/constraints';
 import { hyp, norm2, pointInPoly } from '../model/geom';
 import { edgeS, measureOpeningDim, openingSpan, refPoint, refS } from '../model/openings';
 import { roomGeom } from '../model/rooms';
-import { curveInfo, roomValid } from '../model/sketch';
-import type { Sketch, XY } from '../model/types';
+import { smoothPolyline } from '../model/smooth';
+import { roomValid } from '../model/sketch';
+import { dimEnds, dimRadius } from '../model/planGeom';
+import { wallPieces } from '../model/wallshape';
+import { cabinetFootprints } from '../model/facesolve';
+import { isSegment, noteLook, noteTextIn, shapeOutline } from '../model/markup';
+import type { LinkTarget, Note, Sketch, XY } from '../model/types';
+import { isLink, linkInfoOf, linkName, linkSide } from '../model/links';
 import { fmtAng, fmtArea, fmtLen } from '../units';
 
 /*
   What a page looks like on paper, independent of file format: the exporters (DXF, PDF) implement `Plan`
   and `emitDrawing` walks the sketch once, in drawing order (room shading, walls, openings, labels,
-  dimensions, markup). World units are inches, y up.
+  dimensions, markup — links' tiles on a LINKS layer of their own). World units are inches, y up.
 */
 
-/** A solid wall to draw: a straight run (already extended into its joints) or a curve. */
+/**
+ * A solid wall to draw: the straight walls' outlines (cut to fit their joints, see model/wallshape.ts — one shape, so
+ * no seams show where they meet), or a curve.
+ */
 export type WallShape =
-  | { kind: 'line'; a: XY; b: XY }
+  | { kind: 'polys'; polys: XY[][] }
   | { kind: 'arc'; c: XY; r: number; startDeg: number; endDeg: number }
   | { kind: 'circle'; c: XY; r: number };
 
@@ -34,8 +43,70 @@ export interface Plan {
 export interface DrawOptions {
   /** include dimensions (driving, reference, print, door/window) — default true */
   dims?: boolean;
-  /** include markup (pen, arrows, clouds, notes) — default true */
+  /** include markup (pen, lines, arrows, shapes, clouds, notes) — default true */
   markup?: boolean;
+  /** include cabinets' footprints (from the walls' views) — default true */
+  cabinets?: boolean;
+  /**
+   * What a link's tile says on paper: its name, and a measurement's value (default: what the host last said, or what
+   * it was when it was linked).
+   */
+  linkLabel?: (t: LinkTarget) => { name: string; value?: string };
+}
+
+/** What a link's tile says on paper, unless the exporter's told otherwise. */
+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' };
+
+/**
+ * A name on paper, where nothing can be measured (a DXF has no fonts): about `perLine` characters a line, broken at a
+ * space where it can be, on two lines at most — the second cut short if even that's too little.
+ */
+export function wrapName(text: string, perLine: number): string[] {
+  if (text.length <= perLine) return [text];
+  const sp = text.lastIndexOf(' ', perLine), cut = sp > 0 ? sp : perLine, next = sp > 0 ? sp + 1 : perLine;
+  const first = text.slice(0, cut).trimEnd();
+  let rest = text.slice(next).trim();
+  if (rest.length > perLine) rest = rest.slice(0, Math.max(1, perLine - 1)).trimEnd() + '…';
+  return rest ? [first, rest] : [first];
+}
+
+/** How many characters of a tile's name go across its box (84 of its 96, at text 11 high: about 0.55 of that a character). */
+const NAME_PER_LINE = Math.floor(84 / (0.55 * 11));
+
+/** A link's tile on the LINKS layer: its box, what it says, and its leader to what it points at (with its arrowheads). */
+function emitLink(d: Plan, n: Note & { link: LinkTarget }, label: NonNullable<DrawOptions['linkLabel']>): void {
+  const L = 'LINKS', x = n.x ?? 0, y = n.y ?? 0, side = linkSide(n), h = side / 2;
+  const c = [{ x: x - h, y: y - h }, { x: x + h, y: y - h }, { x: x + h, y: y + h }, { x: x - h, y: y + h }];
+  for (let i = 0; i < 4; i++) d.line(L, c[i], c[(i + 1) % 4]);
+  // laid out as the card is on the screen (96 across): a measurement's value in the middle and its name below; a
+  // file's kind where its picture is, and its name below
+  const u = side / 96, { name, value } = label(n.link);
+  if (n.link.kind === 'measurement') {
+    if (value) d.text(L, { x, y: y + h - 46 * u }, 18 * u, value);
+    d.text(L, { x, y: y + h - 75 * u }, 11 * u, wrapName(name, NAME_PER_LINE).length > 1 ? name.slice(0, NAME_PER_LINE - 1).trimEnd() + '…' : name);
+  } else {
+    const kind = KIND_WORD[linkInfoOf(n.link)?.fileType ?? n.link.fileType ?? ''] ?? 'File';
+    d.text(L, { x, y: y + h - 37 * u }, 11 * u, kind);
+    // its name across its box (on paper it can't zoom in to show more): two lines, centred in the strip under the picture
+    const lines = wrapName(name, NAME_PER_LINE);
+    if (lines.length === 1) d.text(L, { x, y: y + h - 81 * u }, 11 * u, lines[0]);
+    else lines.forEach((l, i) => d.text(L, { x, y: y + h - (82 + (i ? 1 : -1) * 6.875) * u }, 11 * u, l));
+  }
+  if (!n.leader) return;
+  const [tx, ty] = n.leader, dx = tx - x, dy = ty - y, m = Math.max(Math.abs(dx), Math.abs(dy));
+  if (m <= h) return;
+  const s = { x: x + (dx * h) / m, y: y + (dy * h) / m }, tip = { x: tx, y: ty }, look = noteLook(n);
+  d.line(L, s, tip);
+  const head = (from: XY, to: XY) => {
+    const a = Math.atan2(to.y - from.y, to.x - from.x), hl = 5;
+    for (const k of [-0.45, 0.45]) d.line(L, to, { x: to.x - hl * Math.cos(a + k), y: to.y - hl * Math.sin(a + k) });
+  };
+  if (look.endCap === 'arrow') head(s, tip);
+  if (look.startCap === 'arrow') head(tip, s);
 }
 
 /** Text height for dimension values and labels, inches. */
@@ -90,20 +161,20 @@ export function emitDrawing(sk: Sketch, d: Plan, opts: DrawOptions = {}): void {
   // room shading first, so walls and labels sit on top
   if (d.fill) for (const id in sk.rooms) { const r = sk.rooms[id]; if (roomValid(sk, r)) d.fill('SPACES', roomGeom(sk, r).inner); }
 
-  // walls: how many walls meet at each point (straight walls extend into their joints so corners close)
-  const deg2: Record<string, number> = {};
-  const bump = (p: string) => (deg2[p] = (deg2[p] || 0) + 1);
-  for (const id in sk.lines) { const l = sk.lines[id]; if (l.kind === 'wall' && !l.constr) { bump(l.a); bump(l.b); } }
-  for (const id in sk.arcs) { const a = sk.arcs[id]; if (a.kind === 'wall' && !a.constr) { bump(a.a); bump(a.b); } }
+  // cabinets' footprints, under the walls: base cabinets filled on CABINETS, wall (upper) cabinets on CABINETS_UPPER (dashed)
+  if (opts.cabinets !== false) for (const fp of cabinetFootprints(sk)) {
+    const layer = fp.upper ? 'CABINETS_UPPER' : 'CABINETS';
+    if (!fp.upper && d.fill) d.fill('CABINETS', fp.pts);
+    fp.pts.forEach((p, i) => d.line(layer, p, fp.pts[(i + 1) % fp.pts.length]));
+  }
 
-  // geometry
+  // geometry: straight walls as their outlines, cut to fit where they meet (as on screen)
+  const pieces = d.wall ? wallPieces(sk, w => !w.constr) : [];
+  if (pieces.length) d.wall!({ kind: 'polys', polys: pieces.map(p => p.pts) }, 0);
   for (const id in sk.lines) {
     const l = sk.lines[id], A = P(l.a), B = P(l.b);
-    if (l.kind === 'wall' && !l.constr && d.wall) {
-      const L = hyp(B.x - A.x, B.y - A.y) || 1e-9, ux = (B.x - A.x) / L, uy = (B.y - A.y) / L, e = l.thick / 2;
-      const ea = deg2[l.a] > 1 ? e : 0, eb = deg2[l.b] > 1 ? e : 0;
-      d.wall({ kind: 'line', a: { x: A.x - ux * ea, y: A.y - uy * ea }, b: { x: B.x + ux * eb, y: B.y + uy * eb } }, l.thick);
-    } else d.line(l.constr ? 'CONSTRUCTION' : l.kind === 'wall' ? 'WALLS' : 'LINES', A, B);
+    if (l.kind === 'wall' && !l.constr && d.wall) continue;
+    d.line(l.constr ? 'CONSTRUCTION' : l.kind === 'wall' ? 'WALLS' : 'LINES', A, B);
   }
   for (const id in sk.circles) {
     const c = sk.circles[id];
@@ -159,26 +230,31 @@ export function emitDrawing(sk: Sketch, d: Plan, opts: DrawOptions = {}): void {
       const v = c.driving === false ? measure(sk, c) : c.value!;
       const wrap = (s: string) => (ref ? '(' + s + ')' : s);
       if (c.type === 'dist') {
-        const a = P(c.a!), b = P(c.b!);
-        if (!a || !b || hyp(b.x - a.x, b.y - a.y) < 1e-6) continue;
+        // (on a wall's face: its corners)
+        const e = dimEnds(sk, c);
+        if (!e) continue;
+        const { a, b } = e;
+        if (hyp(b.x - a.x, b.y - a.y) < 1e-6) continue;
         const n = norm2(-(b.y - a.y), b.x - a.x);
         // a label sitting on its line in the app goes out to the side: overall wall lengths sit outside the
         // door/window string (architectural order: openings close to the wall, overall dimensions further out)
         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') {
-        const l = sk.lines[c.l!], p = P(c.p!), A = P(l.a), B = P(l.b);
-        const t = ((p.x - A.x) * (B.x - A.x) + (p.y - A.y) * (B.y - A.y)) / ((B.x - A.x) ** 2 + (B.y - A.y) ** 2 || 1);
-        const f = { x: A.x + (B.x - A.x) * t, y: A.y + (B.y - A.y) * t };
-        const n = norm2(-(f.y - p.y), f.x - p.x);
-        linearDim(d, p, f, n, 0, wrap(fmtLen(v)));
+        // (between walls' faces: face to face)
+        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)));
       } else if (c.type === 'diam') {
-        const ci = curveInfo(sk, c.c);
-        if (!ci) continue;
-        const o = P(ci.o.c), r = ci.kind === 'circle' ? ci.o.r : hyp(P(ci.o.a).x - o.x, P(ci.o.a).y - o.y);
+        // (across a curved wall's face: on that face)
+        const g = dimRadius(sk, c);
+        if (!g) continue;
+        const { o, r } = g;
         const a = c.ang ?? Math.PI / 3, u = [Math.cos(a), Math.sin(a)];
-        d.line('DIMENSIONS', { x: o.x - u[0] * r, y: o.y - u[1] * r }, { x: o.x + u[0] * (r + 12), y: o.y + u[1] * (r + 12) });
-        d.text('DIMENSIONS', { x: o.x + u[0] * (r + 12) + (u[0] >= 0 ? 14 : -14), y: o.y + u[1] * (r + 12) }, TEXT_H, 'Ø ' + wrap(fmtLen(v)));
+        // a radius (a fillet's) from the centre out through the arc; a diameter right across
+        d.line('DIMENSIONS', c.rad ? o : { x: o.x - u[0] * r, y: o.y - u[1] * r }, { x: o.x + u[0] * (r + 12), y: o.y + u[1] * (r + 12) });
+        d.text('DIMENSIONS', { x: o.x + u[0] * (r + 12) + (u[0] >= 0 ? 14 : -14), y: o.y + u[1] * (r + 12) }, TEXT_H, c.rad ? 'R ' + wrap(fmtLen(v / 2)) : 'Ø ' + wrap(fmtLen(v)));
       } else if (c.type === 'angle') {
         const l1 = sk.lines[c.l1!], l2 = sk.lines[c.l2!];
         const sh = [l1.a, l1.b].find(p => p === l2.a || p === l2.b);
@@ -208,19 +284,27 @@ export function emitDrawing(sk: Sketch, d: Plan, opts: DrawOptions = {}): void {
   if (opts.markup !== false) {
     for (const nt of sk.notes) {
       const L = 'MARKUP';
-      if ((nt.type === 'pen' || nt.type === 'arrow') && nt.pts) {
-        for (let i = 1; i < nt.pts.length; i++) d.line(L, { x: nt.pts[i - 1][0], y: nt.pts[i - 1][1] }, { x: nt.pts[i][0], y: nt.pts[i][1] });
-        if (nt.type === 'arrow' && nt.pts.length > 1) {
-          const [p, q] = [nt.pts[nt.pts.length - 2], nt.pts[nt.pts.length - 1]];
+      if (isLink(nt)) { emitLink(d, nt, opts.linkLabel ?? defaultLinkLabel); continue; }
+      const outline = shapeOutline(nt);
+      if (outline) {
+        for (let i = 0; i < outline.length; i++) { const a = outline[i], b = outline[(i + 1) % outline.length]; d.line(L, { x: a[0], y: a[1] }, { x: b[0], y: b[1] }); }
+      } else if ((nt.type === 'pen' || isSegment(nt)) && nt.pts) {
+        // (a pen stroke's curve, as drawn, in pieces within a hundredth of an inch of it)
+        const run = smoothPolyline(nt.pts, 0.01);
+        for (let i = 1; i < run.length; i++) d.line(L, { x: run[i - 1][0], y: run[i - 1][1] }, { x: run[i][0], y: run[i][1] });
+        const look = noteLook(nt), n = nt.pts.length;
+        const head = (p: [number, number], q: [number, number]) => {
           const a = Math.atan2(q[1] - p[1], q[0] - p[0]), h = 5;
           for (const s of [-0.45, 0.45]) d.line(L, { x: q[0], y: q[1] }, { x: q[0] - h * Math.cos(a + s), y: q[1] - h * Math.sin(a + s) });
-        }
+        };
+        if (n > 1 && look.endCap === 'arrow') head(nt.pts[n - 2], nt.pts[n - 1]);
+        if (n > 1 && look.startCap === 'arrow') head(nt.pts[1], nt.pts[0]);
       } else if (nt.type === 'cloud' && nt.pts) {
         const [[x0, y0], [x1, y1]] = nt.pts;
         const c = [{ x: x0, y: y0 }, { x: x1, y: y0 }, { x: x1, y: y1 }, { x: x0, y: y1 }];
         for (let i = 0; i < 4; i++) d.line(L, c[i], c[(i + 1) % 4]);
       } else if (nt.type === 'text' && nt.text) {
-        d.text(L, { x: nt.x!, y: nt.y! }, 5, nt.text);
+        d.text(L, { x: nt.x!, y: nt.y! }, noteTextIn(nt), nt.text);
       }
     }
   }

package/src/index.ts

@@ -10,4 +10,9 @@ export type { CadDataProvider, CadFileMeta, CadMeasurements, CadMeasurementValue
 export { memoryProvider } from './data/memory';
 export { setFileSaver } from './react/ports';
 export { laserReading, setLaserConnected } from './react/host';
+export type { HostKeypad, HostKeypadExtra, HostKeypadRequest, MeasurementList, MeasurementListPage } from './react/hostKeypad';
+export type { CadLinkPick, CadLinks, CadSaveMeasurement, MeasurementKind } from './editor/links';
+export type { LinkInfo, LinkTarget } from './model/types';
+export { linkKey } from './model/links';
+export { hasUnsavedChanges as cadHasUnsavedChanges, saveDrawing as saveCadDrawing, type CadSaveState } from './react/saving';
 export type { SkiaFonts } from './skia/SkiaDrawCtx';

package/src/input/keyboard.ts

@@ -1,8 +1,6 @@
-import { elevKeyDown, elevOpen } from '../editor/elevation';
-import { keypadOpen } from '../editor/keypad';
 import { keyDown, keyUp, type KeyIn } from '../editor/keys';
 
-/* DOM key events, handed to editor/keys.ts (or to the wall view's shortcuts while it's open). */
+/* DOM key events, handed to editor/keys.ts. */
 
 const keyIn = (e: KeyboardEvent): KeyIn => ({ key: e.key, shift: e.shiftKey, mod: e.metaKey || e.ctrlKey, alt: e.altKey });
 
@@ -11,7 +9,7 @@ export function initKeyboard(): void {
     const tag = (e.target && (e.target as HTMLElement).tagName) || '';
     if (tag === 'INPUT' || tag === 'TEXTAREA') return;
     const k = keyIn(e);
-    if (!keypadOpen() && elevOpen() ? elevKeyDown(k) : keyDown(k)) e.preventDefault();
+    if (keyDown(k)) e.preventDefault();
   });
   document.addEventListener('keyup', e => keyUp(keyIn(e)));
 }

package/src/model/constraints.ts

@@ -1,6 +1,7 @@
 import { fmtAng, fmtLen } from '../units';
 import { hyp } from './geom';
 import { curveInfo } from './sketch';
+import { faceLength } from './wallfaces';
 import type { Analysis, Constraint, ConsType, Line, Sketch } from './types';
 
 export const isDim = (c: Constraint): boolean => ['dist', 'pldist', 'diam', 'angle'].includes(c.type);
@@ -13,7 +14,7 @@ export const CONS_LABEL: Record<ConsType, string> = {
 
 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 'Diameter ' + 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!);
   return CONS_LABEL[c.type] || c.type;
 }
@@ -26,18 +27,26 @@ export function measure(sk: Sketch, c: Constraint): number {
       const a = P(c.a!), b = P(c.b!);
       if (c.kind === 'h') return Math.abs(b.x - a.x);
       if (c.kind === 'v') return Math.abs(b.y - a.y);
+      // along a wall's face, corner to corner
+      if (c.face && c.line && sk.lines[c.line]?.kind === 'wall') return faceLength(sk, c.line, c.face);
       return hyp(b.x - a.x, b.y - a.y);
     }
     case 'pldist': {
       const l = sk.lines[c.l!], p = P(c.p!), a = P(l.a), b = P(l.b);
-      return Math.abs(((b.x - a.x) * (p.y - a.y) - (b.y - a.y) * (p.x - a.x)) / (hyp(b.x - a.x, b.y - a.y) || 1e-12));
+      const d = Math.abs(((b.x - a.x) * (p.y - a.y) - (b.y - a.y) * (p.x - a.x)) / (hyp(b.x - a.x, b.y - a.y) || 1e-12));
+      if (!c.faces) return d;
+      // between faces: less half of each wall's thickness for a face toward the other, more for a far face
+      const th = (id?: string) => { const w = id ? sk.lines[id] : undefined; return w && w.kind === 'wall' ? w.thick : 0; };
+      return d - (c.faces[0] * th(c.l) + c.faces[1] * th(c.l2)) / 2;
     }
     case 'diam': {
       const ci = curveInfo(sk, c.c);
       if (!ci) return 0;
-      if (ci.kind === 'circle') return 2 * ci.o.r;
+      // (across a curved wall's face: its centreline's, plus its thickness for the outer face, less for the inner)
+      const off = c.face && ci.o.kind === 'wall' ? c.face * (ci.o.thick || 4.5) : 0;
+      if (ci.kind === 'circle') return 2 * ci.o.r + off;
       const o = P(ci.o.c), s = P(ci.o.a);
-      return 2 * hyp(s.x - o.x, s.y - o.y);
+      return 2 * hyp(s.x - o.x, s.y - o.y) + off;
     }
     case 'angle': {
       const l1 = sk.lines[c.l1!], l2 = sk.lines[c.l2!];

package/src/model/demo.ts

@@ -15,8 +15,8 @@ export function demoSketch(): Sketch {
   C({ type: 'h', a: p4, b: p5 }); C({ type: 'v', a: p5, b: p6 }); C({ type: 'h', a: p6, b: p1 });
   C({ type: 'dist', a: p1, b: p2, kind: 'al', value: 240, line: l1, driving: true, off: 0 });
   C({ type: 'dist', a: p6, b: p1, kind: 'al', value: 168, line: l6, driving: true, off: 0 });
-  sk.openings[uid('o')] = { line: l6, at: 42, w: 36, type: 'door', flip: true };
-  sk.openings[uid('o')] = { line: l1, at: 150, w: 48, type: 'window', flip: false };
+  sk.openings[uid('o')] = { line: l6, at: 42, w: 36, wSet: false, type: 'door', flip: true };
+  sk.openings[uid('o')] = { line: l1, at: 150, w: 48, wSet: true, type: 'window', flip: false };
   sk.rooms[uid('r')] = { loop: [p1, p6, p5, p4, p3, p2], name: 'Living room' };
   sk.seq.room = 2;
   sk.notes.push({ id: uid('n'), type: 'arrow', pts: [[214, 196], [128, 158]], color: '#F070EE' });
@@ -25,7 +25,7 @@ export function demoSketch(): Sketch {
 }
 
 export function newPage(name: string, sk?: Sketch): Page {
-  return { id: uid('pg'), name, sk: sk || emptySketch(), underlay: null, view: null };
+  return { id: uid('pg'), name, sk: sk || emptySketch(), underlays: [], view: null };
 }
 
 export function seedProject(): Project {

package/src/model/elevation.ts

@@ -3,7 +3,8 @@ import { edgeS, openingSpan } from './openings';
 import { roomGeom } from './rooms';
 import { settings } from './settings';
 import { roomValid } from './sketch';
-import type { ElevLine, Line, Opening, OpeningEdge, Sketch, XY } from './types';
+import { faceKey } from './faces';
+import type { Line, Opening, OpeningEdge, Sketch, XY } from './types';
 import { wallFace } from './wallfaces';
 
 /*
@@ -106,19 +107,8 @@ export function elevOpenings(sk: Sketch, f: ElevFrame): ElevOpening[] {
   return out.sort((p, q) => p.u0 - q.u0);
 }
 
-/** Key of a wall face's elevation drawing in `Sketch.elev`. */
-export const elevKey = (lid: string, side: number): string => lid + '|' + (side > 0 ? 1 : -1);
+/** Key of a wall face's drawing in `Sketch.faces`. */
+export const elevKey = faceKey;
 
-/** Lines drawn on the face this frame looks at (live array; empty if none). */
-export const elevLines = (sk: Sketch, f: ElevFrame): ElevLine[] => sk.elev?.[elevKey(f.lid, f.side)] ?? [];
-
-/** Add a line to the face this frame looks at; a and b in view coordinates [u, z]. Returns its id. */
-export function addElevLine(sk: Sketch, f: ElevFrame, a: [number, number], b: [number, number], guide: boolean, id: string): string {
-  const k = elevKey(f.lid, f.side);
-  sk.elev = sk.elev || {};
-  (sk.elev[k] = sk.elev[k] || []).push({ id, a: [toU(f, a[0]), a[1]], b: [toU(f, b[0]), b[1]], ...(guide ? { guide: true } : {}) });
-  return id;
-}
-
-/** A drawn line's ends in view coordinates [u, z]. */
-export const elevLineUZ = (f: ElevFrame, l: ElevLine): [[number, number], [number, number]] => [[toU(f, l.a[0]), l.a[1]], [toU(f, l.b[0]), l.b[1]]];
+/** A face point (x = s, y = z) in view coordinates [u, z]. */
+export const faceUZ = (f: ElevFrame, p: XY): [number, number] => [toU(f, p.x), p.y];

package/src/model/faces.ts

@@ -0,0 +1,153 @@
+import { onSessionReset } from './session';
+import type { Constraint, Sketch, WallFace } from './types';
+
+/*
+  What's drawn on wall faces (Sketch.faces): the parts that don't need the wall's geometry — keys, the plan's
+  anchors by name, and following a wall that's split. Keeping a face in step with the plan (its anchors, solving
+  it) is in model/facesolve.ts.
+*/
+
+/** Key of a wall face in `Sketch.faces`: the wall line and the side it's seen from (1: left of A → B, -1: right). */
+export const faceKey = (lid: string, side: number): string => lid + '|' + (side > 0 ? 1 : -1);
+export const faceKeyParts = (key: string): { lid: string; side: 1 | -1 } => {
+  const i = key.lastIndexOf('|');
+  return { lid: key.slice(0, i), side: key.slice(i + 1) === '-1' ? -1 : 1 };
+};
+
+/** The wall face being edited (its key), or null while the plan is: SK() then gives that face's sketch. */
+export const faceEdit = { key: null as string | null };
+onSessionReset(() => { faceEdit.key = null; });
+
+/** Whether a face has nothing on it but the plan's anchors (and isn't open): it isn't kept. */
+export const faceEmpty = (face: Sketch): boolean =>
+  Object.values(face.points).every(p => p.anchor) && Object.values(face.cons).every(c => c.anchor) && !Object.keys(face.circles).length;
+
+export const emptyFace = (): WallFace => ({ points: {}, lines: {}, circles: {}, arcs: {}, cons: {}, rooms: {}, openings: {}, notes: [], seq: { room: 1 }, cabs: {} });
+
+/** The face drawing for `key`; made (empty) when `create` and there's none yet. */
+export function faceOf(sk: Sketch, key: string, create: true): WallFace;
+export function faceOf(sk: Sketch, key: string, create?: boolean): WallFace | null;
+export function faceOf(sk: Sketch, key: string, create = false): WallFace | null {
+  const f = sk.faces?.[key];
+  if (f) return f;
+  if (!create) return null;
+  sk.faces = sk.faces || {};
+  return (sk.faces[key] = emptyFace());
+}
+
+/**
+ * The plan's anchors on a face, by name. Points: "@a0" / "@aH" the corner at the wall's start end (A), at the floor
+ * and at the ceiling, "@b0" / "@bH" the one at its far end; "@o:<opening>:<edge>:0" / ":1" a door's or window's
+ * corner (its s0 or s1 edge, at its sill or head). Edges: "@floor", "@ceil", "@ea" / "@eb" (the wall's ends),
+ * "@o:<opening>:sill" / ":head" / ":s0" / ":s1".
+ */
+export const cornerAnchor = (end: 'a' | 'b', top = false): string => '@' + end + (top ? 'H' : '0');
+export const openingAnchor = (op: string, edge: 's0' | 's1', top = false): string => '@o:' + op + ':' + edge + ':' + (top ? 1 : 0);
+export const FLOOR = '@floor', CEILING = '@ceil';
+export const endEdge = (end: 'a' | 'b'): string => '@e' + end;
+export const openingEdge = (op: string, side: 'sill' | 'head' | 's0' | 's1'): string => '@o:' + op + ':' + side;
+
+/** Whether a point or edge of the face is one of the plan's anchors. */
+export const isAnchorPt = (face: Sketch, id: string): boolean => !!face.points[id]?.anchor;
+export const isAnchorLine = (face: Sketch, id: string): boolean => !!face.lines[id]?.anchor;
+
+/** Every constraint in the sketch — the plan's and each wall face's — with its id. */
+export function allCons(sk: Sketch): [string, Constraint][] {
+  const out = Object.entries(sk.cons);
+  if (sk.faces) for (const key in sk.faces) out.push(...Object.entries(sk.faces[key].cons));
+  return out;
+}
+
+/** The wall face a constraint is on (null for the plan's own). */
+export function faceOfCons(sk: Sketch, cid: string): { key: string; face: WallFace } | null {
+  if (sk.faces) for (const key in sk.faces) if (sk.faces[key].cons[cid]) return { key, face: sk.faces[key] };
+  return null;
+}
+
+/** A cabinet's corners. */
+export const cabPoints = (cb: { bl: string; br: string; tr: string; tl: string }): string[] => [cb.bl, cb.br, cb.tr, cb.tl];
+
+/** The door or window whose corner (a wall face's anchor) `pid` is, if it is one. */
+export const openingOfPoint = (pid: string): string | null => /^@o:([^:]+):s[01]:[01]$/.exec(pid)?.[1] ?? null;
+
+/** The cabinet whose corner `pid` is, if it is one. */
+export const cabOfPoint = (sk: Sketch, pid: string): string | null => {
+  for (const [id, cb] of Object.entries((sk as WallFace).cabs ?? {})) if (cabPoints(cb).includes(pid)) return id;
+  return null;
+};
+
+/** Drop cabinets missing a corner, with their edges. */
+export function gcCabinets(face: WallFace): void {
+  if (!face.cabs) { face.cabs = {}; return; }
+  for (const id in face.cabs) {
+    const cb = face.cabs[id];
+    if (cabPoints(cb).some(p => !face.points[p])) {
+      delete face.cabs[id];
+      for (const l in face.lines) if (face.lines[l].cab === id) delete face.lines[l];
+      continue;
+    }
+    for (const k of ['w', 'h'] as const) if (cb[k] && !face.cons[cb[k]!]) delete cb[k];
+  }
+}
+
+/**
+ * Wall `lid` (L inches long) was split at its middle; the new wall `nid` runs from there to the old end. What's
+ * drawn past the middle moves to the new wall's faces (each group of joined things as a whole, by where its middle is).
+ * Constraints that would join the two walls' faces are dropped. Across a face, x runs from the wall's start (A) seen
+ * from side -1 and from its end (B) seen from side 1, so positions are recounted for the shorter walls.
+ */
+export function splitFaces(sk: Sketch, lid: string, nid: string, L: number): void {
+  if (!sk.faces) return;
+  const half = L / 2;
+  for (const side of [1, -1] as const) {
+    const key = faceKey(lid, side), face: WallFace | undefined = sk.faces[key];
+    if (!face) continue;
+    const mirror = side === 1, sOf = (u: number) => (mirror ? L - u : u);
+    delete face.wall; // its corners are recounted here: the next placing records them afresh
+    // groups of points joined by lines and curves
+    const group = new Map<string, number>(), links = new Map<string, string[]>();
+    const link = (a: string, b: string) => { (links.get(a) ?? links.set(a, []).get(a)!).push(b); (links.get(b) ?? links.set(b, []).get(b)!).push(a); };
+    for (const l of Object.values(face.lines)) if (!l.anchor) link(l.a, l.b);
+    for (const a of Object.values(face.arcs)) { link(a.c, a.a); link(a.c, a.b); }
+    let n = 0;
+    for (const id in face.points) {
+      if (group.has(id) || face.points[id].anchor) continue;
+      const stack = [id];
+      group.set(id, n);
+      while (stack.length) for (const q of links.get(stack.pop()!) ?? []) if (!group.has(q) && !face.points[q].anchor) { group.set(q, n); stack.push(q); }
+      n++;
+    }
+    const sum = new Array<number>(n).fill(0), cnt = new Array<number>(n).fill(0);
+    for (const [id, g] of group) { sum[g] += sOf(face.points[id].x); cnt[g]++; }
+    const moved = new Set([...group].filter(([, g]) => sum[g] / cnt[g] > half).map(([id]) => id));
+    const to = faceOf(sk, faceKey(nid, side), true);
+    for (const id in face.points) {
+      const p = face.points[id];
+      if (p.anchor) continue;
+      const s = sOf(p.x);
+      if (moved.has(id)) { to.points[id] = { ...p, x: mirror ? half - (s - half) : s - half }; delete face.points[id]; }
+      else if (mirror) p.x = half - s;
+    }
+    const usesMoved = (ids: (string | undefined)[]) => ids.some(v => !!v && moved.has(v));
+    for (const id in face.lines) { const l = face.lines[id]; if (!l.anchor && usesMoved([l.a, l.b])) { to.lines[id] = l; delete face.lines[id]; } }
+    for (const id in face.circles) if (moved.has(face.circles[id].c)) { to.circles[id] = face.circles[id]; delete face.circles[id]; }
+    for (const id in face.arcs) if (moved.has(face.arcs[id].c)) { to.arcs[id] = face.arcs[id]; delete face.arcs[id]; }
+    for (const id in face.cabs ?? {}) if (moved.has(face.cabs[id].bl)) { to.cabs[id] = face.cabs[id]; delete face.cabs[id]; }
+    // what moved still hanging on anchors takes a copy of them along (the new wall's own replace them, or let go)
+    for (const l of Object.values(to.lines)) for (const p of [l.a, l.b]) if (face.points[p]?.anchor && !to.points[p]) to.points[p] = { ...face.points[p] };
+    for (const id in face.cons) {
+      const c: Constraint = face.cons[id];
+      const pts = (['a', 'b', 'p'] as const).map(k => c[k]).filter((v): v is string => !!v && !face.points[v]?.anchor);
+      const ls = (['l', 'l1', 'l2', 'line'] as const).map(k => c[k]).filter((v): v is string => !!v && !face.lines[v]?.anchor);
+      const cs = (['c', 'c1', 'c2'] as const).map(k => c[k]).filter((v): v is string => !!v);
+      const inNew = (v: string) => moved.has(v) || !!to.lines[v] || !!to.circles[v] || !!to.arcs[v];
+      const refs = [...pts, ...ls, ...cs];
+      if (!refs.some(inNew)) continue;
+      if (refs.every(inNew)) {
+        to.cons[id] = c;
+        for (const k of ['a', 'b', 'p'] as const) { const v = c[k]; if (v && face.points[v]?.anchor && !to.points[v]) to.points[v] = { ...face.points[v] }; }
+      }
+      delete face.cons[id];
+    }
+  }
+}