@reekon-tools/boldr-cad 0.1.0 → 1.0.0

package/src/model/types.ts

@@ -7,6 +7,8 @@ export interface Pt extends XY {
   fixed?: boolean;
   origin?: boolean;
   datum?: boolean;
+  /** on a wall face: a point the plan sets (a corner of the wall, of a door or window) — fixed, kept in step with the plan */
+  anchor?: boolean;
 }
 
 export type LineKind = 'line' | 'wall';
@@ -14,6 +16,10 @@ export interface Line {
   a: string; b: string; kind: LineKind; constr: boolean; thick: number;
   /** wall height, inches; unset = the default wall height in Settings */
   height?: number;
+  /** on a wall face: an edge the plan sets (the floor, the ceiling, the wall's ends, a door's or window's sides) */
+  anchor?: boolean;
+  /** on a wall face: an edge of this cabinet */
+  cab?: string;
 }
 /** Curves can be walls too (kind 'wall', with a thickness), like straight lines. */
 export interface Circle { c: string; r: number; constr?: boolean; kind?: LineKind; thick?: number }
@@ -36,6 +42,17 @@ export interface Constraint {
   line?: string | null;
   /** dist: aligned, horizontal or vertical */
   kind?: 'al' | 'h' | 'v';
+  /**
+   * dist, a wall's length: measured along this face of it — +1 the face to the left of its line's A → B, −1 the right
+   * — corner to corner, as a tape measure along it reads. diam, a curved wall's: across its outer face (+1) or its
+   * inner face (−1). Unset, its centreline.
+   */
+  face?: 1 | -1;
+  /**
+   * pldist between two walls (`l`, and `l2`, the wall `p` is on): which face of each it's measured from — +1 the face
+   * toward the other, −1 the far one, 0 the centreline; unset, both centrelines.
+   */
+  faces?: [number, number];
   value?: number;
   /** false = reference dimension (shown in parentheses, never drives geometry) */
   driving?: boolean;
@@ -43,10 +60,32 @@ export interface Constraint {
   off?: number;
   /** diameters: direction of the diameter line, radians (default 60°) */
   ang?: number;
+  /** diameters: shown, entered and measured as a radius (a fillet's) — `value` is still the diameter */
+  rad?: boolean;
   sign?: number;
   layer?: 'print';
-  /** the BOLDR measurement this driving dimension's value is kept in (set by the host's measurement link) */
+  /**
+   * the drawing's own BOLDR measurement this driving dimension's value is kept in — made automatically by drawings
+   * from before Save to group, and still kept in step for them; no new ones are made
+   */
   measurementId?: string;
+  /**
+   * a job measurement this driving dimension shows (picked to drive a line, or saved to the group): the job's, never the
+   * drawing's — its value comes from the job, and a new one is written back only once the person says so. Never set
+   * together with measurementId.
+   */
+  measurementRef?: LinkTarget;
+  /**
+   * the host's own record of the laser reading that set this dimension's value (opaque, kept as JSON), handed back when
+   * it's saved to the group so the measurement is recorded as the tool's; dropped when the value changes any other way
+   */
+  capture?: unknown;
+  /** a default nobody measured (a new cabinet's size): it drives the drawing but isn't kept as a measurement until it's entered */
+  auto?: boolean;
+  /** on a wall face: drawn by the wall view (a cabinet's shape and size, the dimensions along the floor and beside things), not as a plan dimension or badge */
+  elev?: boolean;
+  /** on a wall face: kept by the plan (a door's or window's shape there, and where the plan locks it), never edited */
+  anchor?: boolean;
 }
 
 /** A room: its corner points, and (for loops with curves) the line or arc id after each corner. */
@@ -81,6 +120,11 @@ export interface Opening {
   /** centre, inches along the line from its start point */
   at: number;
   w: number;
+  /**
+   * the width was entered (typed or lasered); until then it's the standard size, shown grey. Unset on drawings from
+   * before this was kept: a width other than the standard one was entered.
+   */
+  wSet?: boolean;
   type: 'door' | 'window';
   flip: boolean;
   dims?: OpeningDim[];
@@ -94,7 +138,63 @@ export interface Opening {
   sillLocked?: boolean;
 }
 
-export type NoteType = 'pen' | 'arrow' | 'cloud' | 'text';
+/**
+ * line … ellipse: markup shapes drawn by a drag, kept as two corners like a cloud (a line: its two ends, like an arrow).
+ * link: a tile for one of the job's files (see LinkTarget), at x, y, with an optional leader. (A measurement comes into a
+ *   drawing only as the dimension it drives; a measurement tile from before that rule still draws, its value live.)
+ */
+export type NoteType = 'pen' | 'arrow' | 'cloud' | 'text' | 'line' | 'rect' | 'triangle' | 'ellipse' | 'link';
+
+/**
+ * One of the job's files or measurements, as a drawing points at it. The host finds it by its group and id within the
+ * job it's open in — never by `path` — so a copied or moved job's drawings still find theirs.
+ */
+export interface LinkTarget {
+  kind: 'file' | 'measurement';
+  id: string;
+  /** the group it's in (any group of the job) */
+  groupId: string;
+  /** a form group's column (the host finds the measurement in it) */
+  columnId?: string;
+  /** the host's own reference, handed back as it was */
+  path?: string;
+  /**
+   * What it was when it was linked: shown until the host says what it is now, offline, in exports, and once it's been
+   * removed. Never refreshed by itself (a drawing opened would count as edited).
+   */
+  name?: string;
+  groupName?: string;
+  /** the host's tag for the kind of file (its icon) */
+  fileType?: string;
+  /** a measurement's kind: 'length', 'angle', or the host's own */
+  mkind?: string;
+  /** a measurement's value: µm for a length, degrees for an angle */
+  value?: number;
+  /** that value as the host writes it */
+  text?: string;
+}
+
+/**
+ * What a link is now, as the host says (LinkTarget has what it was when it was linked). A file's kind, for its icon:
+ * 'photo', 'pdf', 'document', 'note', 'calculator', 'label', 'drawing' or anything else (a plain page).
+ */
+export interface LinkInfo {
+  /** false once the host has looked and it's gone — never while it's still loading */
+  exists: boolean;
+  name?: string;
+  groupName?: string;
+  fileType?: string;
+  /** a small picture of it: a URL or a data URL */
+  thumbUrl?: string;
+  mkind?: string;
+  /** µm for a length, degrees for an angle */
+  value?: number;
+  /** the value as the host writes it */
+  text?: string;
+  /** whether it can be opened from the drawing, and its measurement changed from it (unset: yes) */
+  canOpen?: boolean;
+  canEdit?: boolean;
+}
 export interface Note {
   id: string;
   type: NoteType;
@@ -103,14 +203,66 @@ export interface Note {
   y?: number;
   text?: string;
   color: string;
+  /**
+   * text: how tall its letters are on the drawing, in inches (unset: 5") — fixed to the drawing, so it zooms with it as
+   * the lines do; the box, padding and corners grow with it. Set by the note's corner handles or the markup panel.
+   * link: the tile's side on the drawing, inches (set as it's placed: a tile's size on the screen at that zoom).
+   */
+  ts?: number;
+  /** text, from before `ts`: a size in screen pixels (14 px read as 5", as the PDF has always printed it) */
+  size?: number;
+  /** stroke width in screen pixels (unset: 3, a cloud 2.5); not for text */
+  width?: number;
+  /** dashed or dotted (unset: solid); a note's box takes it too */
+  style?: 'dash' | 'dot';
+  /** pen strokes and arrows: how each end finishes (unset: round, an arrow's end an arrowhead) */
+  startCap?: NoteCap;
+  cap?: NoteCap;
+  /** link: what it's a tile for (x, y is the tile's centre, `ts` its side on the drawing, inches) */
+  link?: LinkTarget;
+  /**
+   * link: where its leader points, plan inches — the leader runs from the tile's edge to here, so `cap` is the end at
+   * what it points to. Unset: no leader. Its look is the note's color, width, style and caps.
+   */
+  leader?: [number, number];
 }
+export type NoteCap = 'butt' | 'round' | 'arrow';
 
 /**
- * A line drawn on a wall elevation (layout marks, guides). a / b are [s, z]: s inches along the wall from its
- * start point A (so it survives flipping the view), z inches up from the floor.
+ * A line drawn on a wall elevation by earlier versions (layout marks, guides). a / b are [s, z]: s inches along the
+ * wall from its start point A, z inches up from the floor. Read only to move it into the wall's face (WallFace).
  */
 export interface ElevLine { id: string; a: [number, number]; b: [number, number]; guide?: boolean }
 
+/**
+ * A cabinet on a wall face: a rectangle of four face points — bottom-left, bottom-right, top-right and top-left as
+ * seen — kept square by constraints. w, h: its width and height constraints.
+ */
+export interface Cabinet {
+  bl: string; br: string; tr: string; tl: string;
+  w?: string; h?: string;
+  /** inches from the wall face out into the room */
+  depth: number;
+  /** the depth was entered (not the standard one) */
+  depthSet?: boolean;
+  label?: string;
+}
+
+/**
+ * What's drawn on one face of a wall (one side of it, as its elevation shows it): a sketch of its own, edited and
+ * solved like the plan. x runs across the wall as seen from that side, y up from the floor. The plan's corners,
+ * floor, ceiling and doors and windows are in it as anchors (fixed points and edges, ids starting "@"), kept in step
+ * with the plan, so what's drawn can be snapped, constrained and dimensioned to them.
+ */
+export interface WallFace extends Sketch {
+  cabs: Record<string, Cabinet>;
+  /**
+   * Where the face's corners were when what's drawn on it was last placed: across as seen, and each in the plan. When
+   * one end of the wall moves, what's drawn keeps its place from the end that moved less (it stays where it is).
+   */
+  wall?: { u: [number, number]; ends: [[number, number], [number, number]] };
+}
+
 export interface Sketch {
   points: Record<string, Pt>;
   lines: Record<string, Line>;
@@ -121,12 +273,16 @@ export interface Sketch {
   openings: Record<string, Opening>;
   notes: Note[];
   seq: { room: number };
-  /** lines drawn on wall elevations, per wall face: key "<wall line id>|<side>" (side 1: left of A → B, -1: right) */
+  /** what's drawn on wall elevations, per wall face: key "<wall line id>|<side>" (side 1: left of A → B, -1: right) */
+  faces?: Record<string, WallFace>;
+  /** earlier versions' lines on wall elevations (same keys): moved into `faces` when the drawing loads */
   elev?: Record<string, ElevLine[]>;
 }
 
 /** Photo or plan traced under the drawing. (x, y) is its top-left corner in world inches. */
 export interface Underlay {
+  /** which of the page's images (unique on its page) */
+  id: string;
   src: string;
   x: number;
   y: number;
@@ -134,11 +290,14 @@ export interface Underlay {
   /** height in inches; when missing, it follows the image's own aspect ratio */
   h?: number;
   opacity?: number;
-  /** locked images can't be moved or resized (they still show, and can be unlocked) */
+  /** turned about its middle, degrees clockwise as it's seen (unset: upright) — x, y, w, h are the box before it's turned */
+  rot?: number;
+  /** locked images can't be moved, resized or turned (they still show, and can be unlocked) */
   locked?: boolean;
 }
 export interface View { cx: number; cy: number; s: number }
-export interface Page { id: string; name: string; sk: Sketch; underlay: Underlay | null; view: View | null; _fit?: boolean }
+/** underlays: the page's photos and plans, drawn in order (the last on top) */
+export interface Page { id: string; name: string; sk: Sketch; underlays: Underlay[]; view: View | null; _fit?: boolean }
 export interface Project { name: string; pages: Page[] }
 
 /** Result of degree-of-freedom analysis. */
@@ -154,5 +313,8 @@ export interface Analysis {
 }
 
 /** 'odim': a door/window position dimension, id "<opening id>|<part>" (part 'a' / 'b' = distance to a wall end, 'd:<id>' = a placed one). */
-export type SelType = 'point' | 'line' | 'circle' | 'arc' | 'cons' | 'dim' | 'room' | 'opening' | 'odim' | 'note' | 'underlay';
+/** On a wall face, also 'cab' (a cabinet) and 'elev' (one of the wall view's dimension chips; id: what it measures, as JSON). */
+/** 'oanchor': one end of a door or window in the plan, id "<opening>|s0" or "<opening>|s1" */
+/** 'wface': one edge (face) of a wall, id '<line id>|1' (the face to the left of its A → B) or '<line id>|-1' (the right) */
+export type SelType = 'point' | 'line' | 'circle' | 'arc' | 'cons' | 'dim' | 'room' | 'opening' | 'odim' | 'oanchor' | 'note' | 'underlay' | 'cab' | 'elev' | 'wface';
 export interface SelItem { type: SelType; id: string }

package/src/model/wallfaces.ts

@@ -16,16 +16,81 @@ export interface WallFace {
   strips: [number, number][];
 }
 
-/** One face of straight wall `lid`: `side` +1 is the face to the left of A → B, −1 the right. Null if it isn't a usable line. */
-export function wallFace(sk: Sketch, lid: string, side: 1 | -1): WallFace | null {
-  const l = sk.lines[lid];
-  if (!l) return null;
-  const A = sk.points[l.a], B = sk.points[l.b];
-  if (!A || !B) return null;
+/**
+ * A wall meeting one end of another (not a guide), and its thickness: a straight one, by the point it runs out to
+ * (`far`); a curved one, by its centre and which way it leaves the corner (`ccw`: counter-clockwise, from its start).
+ */
+export interface FaceEnd { thick: number; far?: string; arc?: { c: string; ccw: boolean } }
+/** The walls meeting each end of a wall. */
+export interface FaceEnds { a: FaceEnd[]; b: FaceEnd[] }
+
+/** How close (inches) counts as the same place, for a wall's end on another wall. */
+const ON = 1e-3;
+
+/**
+ * The walls meeting each end of a wall: those it shares the point with, and those its end sits on partway along (a T —
+ * a wall run up to the middle of another). One partway along runs out both ways from the end, as if it were split
+ * there, so the faces either side of the end stop at its near face. (A curved wall's end on its centreline, as snapping
+ * puts it: its radius is taken from there.)
+ */
+export function faceEnds(sk: Sketch, lid: string): FaceEnds {
+  const l = sk.lines[lid], out: FaceEnds = { a: [], b: [] };
+  for (const end of ['a', 'b'] as const) {
+    const pid = l[end], P = sk.points[pid], list = out[end];
+    for (const id in sk.lines) {
+      const n = sk.lines[id];
+      if (id === lid || n.kind !== 'wall' || n.constr) continue;
+      if (n.a === pid || n.b === pid) list.push({ far: n.a === pid ? n.b : n.a, thick: n.thick });
+      else if (P && alongWall(sk, n, P)) list.push({ far: n.a, thick: n.thick }, { far: n.b, thick: n.thick });
+    }
+    // (an arc runs counter-clockwise from its start, a, to its end, b; one drawn as a wall without a thickness is 4½")
+    for (const id in sk.arcs) {
+      const n = sk.arcs[id], t = n.thick || 4.5;
+      if (n.kind !== 'wall' || n.constr) continue;
+      if (n.a === pid || n.b === pid) { list.push({ arc: { c: n.c, ccw: n.a === pid }, thick: t }); continue; }
+      const C = sk.points[n.c], S = sk.points[n.a];
+      if (P && C && S && alongCurve(sk, n.c, hyp(S.x - C.x, S.y - C.y), t, P, n)) list.push({ arc: { c: n.c, ccw: true }, thick: t }, { arc: { c: n.c, ccw: false }, thick: t });
+    }
+    for (const id in sk.circles) {
+      const n = sk.circles[id], t = n.thick || 4.5;
+      if (n.kind !== 'wall' || n.constr) continue;
+      if (P && alongCurve(sk, n.c, n.r, t, P)) list.push({ arc: { c: n.c, ccw: true }, thick: t }, { arc: { c: n.c, ccw: false }, thick: t });
+    }
+  }
+  return out;
+}
+
+/** Whether point P is on straight wall `n` partway along it (within its thickness, short of its ends). */
+function alongWall(sk: Sketch, n: { a: string; b: string; thick: number }, P: XY): boolean {
+  const A = sk.points[n.a], B = sk.points[n.b];
+  if (!A || !B) return false;
+  const L = hyp(B.x - A.x, B.y - A.y);
+  if (L < ON) return false;
+  const s = ((P.x - A.x) * (B.x - A.x) + (P.y - A.y) * (B.y - A.y)) / L, off = Math.abs((B.x - A.x) * (P.y - A.y) - (B.y - A.y) * (P.x - A.x)) / L;
+  return s > ON && s < L - ON && off <= n.thick / 2 + ON;
+}
+
+/** Whether point P is on a curved wall (centre `c`, radius `r`, `t` thick) partway along it — for an arc, short of its ends. */
+function alongCurve(sk: Sketch, c: string, r: number, t: number, P: XY, arc?: { a: string; b: string }): boolean {
+  const C = sk.points[c];
+  if (!C || r < ON || Math.abs(hyp(P.x - C.x, P.y - C.y) - r) > t / 2 + ON) return false;
+  if (!arc) return true;
+  const A = sk.points[arc.a], B = sk.points[arc.b];
+  if (!A || !B) return false;
+  const turn = (v: number) => ((v % (2 * Math.PI)) + 2 * Math.PI) % (2 * Math.PI);
+  const t0 = Math.atan2(A.y - C.y, A.x - C.x), sweep = turn(Math.atan2(B.y - C.y, B.x - C.x) - t0), at = turn(Math.atan2(P.y - C.y, P.x - C.x) - t0);
+  return at * r > ON && at < sweep && (sweep - at) * r > ON;
+}
+
+/**
+ * One face of a straight wall from A to B, `t` thick: `side` +1 the face to the left of A → B, −1 the right. The
+ * walls at its ends (`ends`) and every point are looked up by `pt` — the sketch's own, or a solve's trial positions
+ * (a face dimension is solved through this). Null if A and B are one point.
+ */
+export function faceSpan(pt: (id: string) => XY, A: XY, B: XY, t: number, side: 1 | -1, ends: FaceEnds): WallFace | null {
   const L = hyp(B.x - A.x, B.y - A.y);
   if (L < 1e-6) return null;
   const ux = (B.x - A.x) / L, uy = (B.y - A.y) / L, nx = -uy * side, ny = ux * side;
-  const t = l.kind === 'wall' ? l.thick : 0;
   const F = { x: A.x + nx * (t / 2), y: A.y + ny * (t / 2) };
 
   /** Where the face line (F + û s) crosses each face of a neighbouring wall leaving `P` in direction d. */
@@ -39,18 +104,47 @@ export function wallFace(sk: Sketch, lid: string, side: 1 | -1): WallFace | null
     const s1 = at(tn / 2), s2 = at(-tn / 2);
     return [Math.min(s1, s2), Math.max(s1, s2)];
   };
+  /**
+   * Where the face line crosses each face of a curved wall leaving `P` in direction d (its tangent there) around centre
+   * `C`: the circles half its thickness either side of it, each where it crosses nearest the corner (`sP`, s at P). A
+   * face the line misses is taken along the tangent, as a straight wall's would be.
+   */
+  const arcCrossings = (P: XY, C: XY, d: [number, number], tn: number, sP: number, ccw: boolean): [number, number] | null => {
+    const den = ux * d[1] - uy * d[0];
+    if (Math.abs(den) < 0.05) return null; // (it carries on in line with the face, as a fillet does: no corner)
+    const R = hyp(P.x - C.x, P.y - C.y), fx = F.x - C.x, fy = F.y - C.y, b = ux * fx + uy * fy;
+    /** Along the tangent: where the face line crosses the line k to its left (a straight wall's face). */
+    const along = (k: number) => { const Q = { x: P.x - d[1] * k, y: P.y + d[0] * k }; return ((Q.x - F.x) * d[1] - (Q.y - F.y) * d[0]) / den; };
+    /** Where the face line crosses the circle of radius rho (k: the same face along the tangent, if it misses it). */
+    const at = (rho: number, k: number) => {
+      const disc = b * b - (fx * fx + fy * fy - rho * rho);
+      if (rho <= 0 || disc < 0) return along(k);
+      const r1 = -b - Math.sqrt(disc), r2 = -b + Math.sqrt(disc);
+      return Math.abs(r1 - sP) <= Math.abs(r2 - sP) ? r1 : r2;
+    };
+    // (left of the tangent is toward the centre for an arc leaving counter-clockwise: its inner face)
+    const s1 = at(R + tn / 2, ccw ? -tn / 2 : tn / 2), s2 = at(R - tn / 2, ccw ? tn / 2 : -tn / 2);
+    return [Math.min(s1, s2), Math.max(s1, s2)];
+  };
   const strips: [number, number][] = [];
   /** One end of the face: s of the corner, collecting the neighbouring walls cut on this side. */
-  const end = (pid: string, atStart: boolean): number => {
+  const end = (P: XY, walls: FaceEnds['a'], atStart: boolean): number => {
     let toward: number | null = null, away: number | null = null;
-    const P = sk.points[pid];
-    for (const id in sk.lines) {
-      const n = sk.lines[id];
-      if (id === lid || n.kind !== 'wall' || n.constr || (n.a !== pid && n.b !== pid)) continue;
-      const Q = sk.points[n.a === pid ? n.b : n.a], Ln = hyp(Q.x - P.x, Q.y - P.y);
-      if (Ln < 1e-6) continue;
-      const d: [number, number] = [(Q.x - P.x) / Ln, (Q.y - P.y) / Ln];
-      const c = crossings(P, d, n.thick);
+    for (const n of walls) {
+      let d: [number, number], c: [number, number] | null;
+      if (n.arc) {
+        // a curved wall: it leaves the corner along its tangent there
+        const C = pt(n.arc.c), R = hyp(P.x - C.x, P.y - C.y);
+        if (R < 1e-6) continue;
+        const k = n.arc.ccw ? 1 : -1;
+        d = [(-(P.y - C.y) / R) * k, ((P.x - C.x) / R) * k];
+        c = arcCrossings(P, C, d, n.thick, atStart ? 0 : L, n.arc.ccw);
+      } else {
+        const Q = pt(n.far!), Ln = hyp(Q.x - P.x, Q.y - P.y);
+        if (Ln < 1e-6) continue;
+        d = [(Q.x - P.x) / Ln, (Q.y - P.y) / Ln];
+        c = crossings(P, d, n.thick);
+      }
       if (!c) continue;
       if (d[0] * nx + d[1] * ny > 0) {
         // the neighbour runs out on this side: the face stops at the neighbour's face (an inside corner)
@@ -65,7 +159,22 @@ export function wallFace(sk: Sketch, lid: string, side: 1 | -1): WallFace | null
     }
     return toward ?? away ?? (atStart ? 0 : L);
   };
-  return { s0: end(l.a, true), s1: end(l.b, false), strips };
+  return { s0: end(A, ends.a, true), s1: end(B, ends.b, false), strips };
+}
+
+/** One face of straight wall `lid`: `side` +1 is the face to the left of A → B, −1 the right. Null if it isn't a usable line. */
+export function wallFace(sk: Sketch, lid: string, side: 1 | -1): WallFace | null {
+  const l = sk.lines[lid];
+  if (!l) return null;
+  const A = sk.points[l.a], B = sk.points[l.b];
+  if (!A || !B) return null;
+  return faceSpan(id => sk.points[id], A, B, l.kind === 'wall' ? l.thick : 0, side, faceEnds(sk, lid));
+}
+
+/** How long one face of a wall is, corner to corner (what a tape measure along it reads); its centreline if it's not a wall. */
+export function faceLength(sk: Sketch, lid: string, side: 1 | -1): number {
+  const f = wallFace(sk, lid, side);
+  return f ? f.s1 - f.s0 : 0;
 }
 
 /** A face corner as a point: on the face (half the wall's thickness off the centerline) at the corner. */

package/src/model/wallshape.ts

@@ -0,0 +1,97 @@
+import { hyp } from './geom';
+import type { Sketch, XY } from './types';
+
+/*
+  The outline of each straight wall, with its ends cut to fit where walls meet: two walls meet in a mitre (the cut
+  runs from the inside corner to the outside corner), three or more share the point where they meet (each wall's
+  end runs to it), a free end is square. Where walls meet at a sharp angle the mitre would run far out, so the outside
+  corner is cut off flat instead (a bevel, its own piece). Where a curved wall joins, the straight wall runs on half
+  its thickness past the joint, as before, so the two overlap.
+*/
+
+/** A piece of wall to fill: a straight wall (`id`), or a bevel at a sharp joint (`of`: a wall it belongs to). */
+export interface WallPiece { id: string | null; of: string; pts: XY[] }
+
+const left = (u: XY): XY => ({ x: -u.y, y: u.x });
+const right = (u: XY): XY => ({ x: u.y, y: -u.x });
+const at = (p: XY, n: XY, k: number): XY => ({ x: p.x + n.x * k, y: p.y + n.y * k });
+
+/** Where two lines (a point and a direction each) cross; for parallel ones, the middle of the two points if they're the same line, else null. */
+function cross(p1: XY, d1: XY, p2: XY, d2: XY): XY | null {
+  const c = d1.x * d2.y - d1.y * d2.x;
+  if (Math.abs(c) < 1e-9) {
+    const off = Math.abs((p2.x - p1.x) * d1.y - (p2.y - p1.y) * d1.x);
+    return off < 1e-6 ? { x: (p1.x + p2.x) / 2, y: (p1.y + p2.y) / 2 } : null;
+  }
+  const l = ((p2.x - p1.x) * d2.y - (p2.y - p1.y) * d2.x) / c;
+  return { x: p1.x + d1.x * l, y: p1.y + d1.y * l };
+}
+
+interface End { id: string; u: XY; t: number }
+
+/**
+ * The pieces to fill for the sketch's straight walls (`show`: which to include, e.g. not hidden construction walls).
+ * Each wall's outline runs: its start's right corner, its end's right corner, (its end point, at a joint), its end's
+ * left corner, its start's left corner, (its start point, at a joint) — right and left as seen going from start to end.
+ */
+export function wallPieces(sk: Sketch, show: (w: { constr?: boolean }) => boolean = () => true): WallPiece[] {
+  const walls = Object.entries(sk.lines).filter(([, l]) => l.kind === 'wall' && show(l));
+  // what meets at each point: straight walls (their direction away from it) and whether a curved wall does
+  /** at each point a curved wall ends: the centres of those curves */
+  const ends = new Map<string, End[]>(), curved = new Map<string, XY[]>();
+  for (const [id, l] of walls) {
+    const A = sk.points[l.a], B = sk.points[l.b], L = hyp(B.x - A.x, B.y - A.y);
+    if (L < 1e-9) continue;
+    const u = { x: (B.x - A.x) / L, y: (B.y - A.y) / L };
+    (ends.get(l.a) ?? ends.set(l.a, []).get(l.a)!).push({ id, u, t: l.thick });
+    (ends.get(l.b) ?? ends.set(l.b, []).get(l.b)!).push({ id, u: { x: -u.x, y: -u.y }, t: l.thick });
+  }
+  for (const a of Object.values(sk.arcs)) {
+    if (a.kind !== 'wall' || !show(a)) continue;
+    for (const p of [a.a, a.b]) (curved.get(p) ?? curved.set(p, []).get(p)!).push(sk.points[a.c]);
+  }
+  /** whether a straight wall leaving P along u runs on into a curve there (tangent to it: a fillet) */
+  const tangent = (pid: string, u: XY) => {
+    const P = sk.points[pid];
+    return (curved.get(pid) ?? []).every(o => Math.abs(u.x * (P.x - o.x) + u.y * (P.y - o.y)) < 0.02 * (hyp(P.x - o.x, P.y - o.y) || 1));
+  };
+
+  /** each wall end's two corners: [left, right] as seen going away from the point; joint: whether the point itself is part of its outline */
+  const corners = new Map<string, { l: XY; r: XY; joint: boolean }>();
+  const bevels: WallPiece[] = [];
+  for (const [pid, list] of ends) {
+    const P = sk.points[pid];
+    if (list.length === 1 || curved.has(pid)) {
+      // a free end is square, and so is one running on into a curve (a fillet: the curve's end is square to it too);
+      // next to a curve at an angle, run on half the thickness so the two overlap
+      for (const e of list) {
+        const Q = curved.has(pid) && !tangent(pid, e.u) ? at(P, e.u, -e.t / 2) : P;
+        corners.set(e.id + '|' + pid, { l: at(Q, left(e.u), e.t / 2), r: at(Q, right(e.u), e.t / 2), joint: false });
+      }
+      continue;
+    }
+    // walls around the point, counter-clockwise; between each and the next, the corner where their sides cross
+    const sorted = [...list].sort((p, q) => Math.atan2(p.u.y, p.u.x) - Math.atan2(q.u.y, q.u.x));
+    const ccw = new Map<number, XY>(), cw = new Map<number, XY>();
+    for (let i = 0; i < sorted.length; i++) {
+      const a = sorted[i], b = sorted[(i + 1) % sorted.length];
+      const ea = at(P, left(a.u), a.t / 2), eb = at(P, right(b.u), b.t / 2);
+      const c = cross(ea, a.u, eb, b.u), limit = 2 * Math.max(a.t, b.t);
+      if (c && hyp(c.x - P.x, c.y - P.y) <= limit) { ccw.set(i, c); cw.set((i + 1) % sorted.length, c); continue; }
+      // too sharp (or parallel sides that don't meet): each side stops square, and a bevel closes the corner
+      ccw.set(i, ea); cw.set((i + 1) % sorted.length, eb);
+      if (hyp(ea.x - eb.x, ea.y - eb.y) > 1e-6) bevels.push({ id: null, of: a.id, pts: [P, ea, eb] });
+    }
+    sorted.forEach((e, i) => corners.set(e.id + '|' + pid, { l: ccw.get(i)!, r: cw.get(i)!, joint: true }));
+  }
+
+  const out: WallPiece[] = [];
+  for (const [id, l] of walls) {
+    const a = corners.get(id + '|' + l.a), b = corners.get(id + '|' + l.b);
+    if (!a || !b) continue;
+    // at the start, away from it is along the wall; at the end, back along it — so its left is the wall's right
+    const pts = [a.r, b.l, ...(b.joint ? [sk.points[l.b]] : []), b.r, a.l, ...(a.joint ? [sk.points[l.a]] : [])];
+    out.push({ id, of: id, pts: pts.map(p => ({ x: p.x, y: p.y })) });
+  }
+  return [...out, ...bevels];
+}