@reekon-tools/boldr-cad 1.3.0 → 1.5.0

package/src/export/plan.ts

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

package/src/index.ts

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

package/src/model/demo.ts

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

package/src/model/elevation.ts

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

package/src/model/history.ts

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

package/src/model/links.ts

@@ -64,10 +64,16 @@ export function sketchLinks(sk: Sketch): LinkTarget[] {
   return out;
 }
 
-/** Everything a project links to, each once: its pages' tiles and the measurements its dimensions show. */
+/**
+ * Everything a project links to, each once: its pages' tiles, the photos expanded from tiles among their images, and
+ * the measurements its dimensions show.
+ */
 export function linkTargets(p: Project): LinkTarget[] {
   const out = new Map<string, LinkTarget>();
-  for (const pg of p.pages) for (const t of sketchLinks(pg.sk)) if (!out.has(linkKey(t))) out.set(linkKey(t), t);
+  for (const pg of p.pages) {
+    for (const t of sketchLinks(pg.sk)) if (!out.has(linkKey(t))) out.set(linkKey(t), t);
+    for (const u of pg.underlays ?? []) if (u.link && !out.has(linkKey(u.link))) out.set(linkKey(u.link), u.link);
+  }
   return [...out.values()];
 }
 

package/src/model/measurement.ts

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

package/src/model/openings.ts

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

package/src/model/planGeom.ts

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

package/src/model/project.ts

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