@ahrowe/ui 0.34.0 → 0.35.0

package/dist/esm/common/floorPlan/floorPlan.graph.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"floorPlan.graph.mjs","names":[],"sources":["../../../../package/common/floorPlan/floorPlan.graph.ts"],"sourcesContent":["/**\n * Graph maintenance: the operations that keep the wall graph a valid planar embedding\n * while the user draws.\n *\n * The invariant every function here protects: no two walls may cross without a node at\n * the intersection, and no node may lie on a wall's interior without that wall being\n * split there. Break either and the face walk silently merges two rooms into one\n * figure-eight face, with no error anywhere.\n *\n * Every operation is pure and returns a new floor, for direct use as React state.\n */\n\nimport {\n  EPS_ANGLE,\n  EPS_COINCIDENT,\n  MIN_OPENING_WIDTH,\n  MIN_WALL_LENGTH,\n  cross,\n  dist,\n  pointToSegment,\n  projectOnSegment,\n  segmentIntersection,\n} from './floorPlan.geometry';\nimport { PlanIssueKind, WallType } from './floorPlan.types';\nimport type { PlanEdit, PlanFloor, PlanIssue, PlanNode, PlanOpening, PlanPoint, PlanWall } from './floorPlan.types';\n\n// ─── Ids ───────────────────────────────────────────────────────────────────────\n\nlet idSeq = 0;\n\n/**\n * Ids are deliberately non-numeric strings, so `Record` iteration keeps insertion\n * order (JavaScript reorders integer-like keys), which is what makes derivation\n * reproducible.\n */\nexport function newId(prefix: string): string {\n  idSeq += 1;\n  const rand =\n    typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function'\n      ? crypto.randomUUID().slice(0, 8)\n      : Math.random().toString(36).slice(2, 10);\n  return `${prefix}_${rand}${idSeq.toString(36)}`;\n}\n\n/** Test-only: makes generated ids reproducible within a single test. */\nexport function __resetIdSeq(): void {\n  idSeq = 0;\n}\n\n// ─── Internals ─────────────────────────────────────────────────────────────────\n\nfunction cloneFloor(floor: PlanFloor): PlanFloor {\n  return {\n    ...floor,\n    nodes: { ...floor.nodes },\n    walls: { ...floor.walls },\n    openings: { ...floor.openings },\n    rooms: { ...floor.rooms },\n  };\n}\n\nfunction issue(kind: PlanIssueKind, message: string, extra: Partial<PlanIssue> = {}): PlanIssue {\n  return { kind, message, ...extra };\n}\n\nfunction wallLength(floor: PlanFloor, wall: PlanWall): number {\n  const a = floor.nodes[wall.a];\n  const b = floor.nodes[wall.b];\n  if (!a || !b) return 0;\n  return dist(a, b);\n}\n\nfunction wallsAtNode(floor: PlanFloor, nodeId: string): PlanWall[] {\n  return Object.values(floor.walls).filter((w) => w.a === nodeId || w.b === nodeId);\n}\n\nfunction findWallBetween(floor: PlanFloor, a: string, b: string): PlanWall | null {\n  for (const w of Object.values(floor.walls)) {\n    if ((w.a === a && w.b === b) || (w.a === b && w.b === a)) return w;\n  }\n  return null;\n}\n\n// ─── Node spatial hash ─────────────────────────────────────────────────────────\n\n/**\n * Bucket size for the node hash, in millimetres. Any lookup checks the 3x3\n * neighbourhood, so this only has to exceed the largest snap tolerance in world units.\n */\nconst HASH_CELL = 250;\n\nfunction hashKey(x: number, y: number): string {\n  return `${Math.round(x / HASH_CELL)}|${Math.round(y / HASH_CELL)}`;\n}\n\nfunction buildNodeHash(floor: PlanFloor): Map<string, PlanNode[]> {\n  const map = new Map<string, PlanNode[]>();\n  for (const node of Object.values(floor.nodes)) {\n    const key = hashKey(node.x, node.y);\n    const list = map.get(key);\n    if (list) list.push(node);\n    else map.set(key, [node]);\n  }\n  return map;\n}\n\n/** Nearest existing node within `tol`, using the spatial hash. */\nexport function findNodeNear(floor: PlanFloor, p: PlanPoint, tol: number): PlanNode | null {\n  const hash = buildNodeHash(floor);\n  const cx = Math.round(p.x / HASH_CELL);\n  const cy = Math.round(p.y / HASH_CELL);\n  let best: PlanNode | null = null;\n  let bestDist = tol;\n  const span = Math.max(1, Math.ceil(tol / HASH_CELL));\n  for (let dx = -span; dx <= span; dx++) {\n    for (let dy = -span; dy <= span; dy++) {\n      for (const node of hash.get(`${cx + dx}|${cy + dy}`) ?? []) {\n        const d = dist(p, node);\n        if (d <= bestDist) {\n          best = node;\n          bestDist = d;\n        }\n      }\n    }\n  }\n  return best;\n}\n\n/** Nearest wall whose centreline passes within `tol` of `p`. */\nexport function findWallNear(\n  floor: PlanFloor,\n  p: PlanPoint,\n  tol: number,\n  exclude?: ReadonlySet<string>,\n): { wall: PlanWall; t: number; point: PlanPoint; dist: number } | null {\n  let best: { wall: PlanWall; t: number; point: PlanPoint; dist: number } | null = null;\n  for (const wall of Object.values(floor.walls)) {\n    if (exclude?.has(wall.id)) continue;\n    const a = floor.nodes[wall.a];\n    const b = floor.nodes[wall.b];\n    if (!a || !b) continue;\n    const r = pointToSegment(p, a, b);\n    if (r.dist <= tol && (!best || r.dist < best.dist)) {\n      best = { wall, t: r.t, point: r.point, dist: r.dist };\n    }\n  }\n  return best;\n}\n\n// ─── splitWall ─────────────────────────────────────────────────────────────────\n\nexport interface SplitWallResult {\n  nodeId: string;\n  wallIds: [string, string] | null;\n  droppedOpeningIds: string[];\n}\n\n/**\n * Splits a wall at a point or parameter, returning the node at the cut.\n *\n * Refuses to cut within `MIN_WALL_LENGTH` of either end, returning that endpoint's\n * existing node instead. That single rule is what keeps zero-length walls out of the\n * graph entirely, which in turn is what stops the angular sort from being fed a\n * direction-less dart.\n */\nexport function splitWall(floor: PlanFloor, wallId: string, at: PlanPoint | number): PlanEdit<SplitWallResult> {\n  const wall = floor.walls[wallId];\n  if (!wall) {\n    return { floor, result: { nodeId: '', wallIds: null, droppedOpeningIds: [] }, issues: [] };\n  }\n  const a = floor.nodes[wall.a];\n  const b = floor.nodes[wall.b];\n  if (!a || !b) {\n    return { floor, result: { nodeId: '', wallIds: null, droppedOpeningIds: [] }, issues: [] };\n  }\n\n  const len = dist(a, b);\n  const point = typeof at === 'number' ? { x: a.x + (b.x - a.x) * at, y: a.y + (b.y - a.y) * at } : at;\n  // Project exactly, so the two children stay perfectly collinear and dissolveNode can\n  // undo the split cleanly later.\n  const exact = projectOnSegment(point, a, b);\n  const fromA = dist(a, exact);\n\n  if (fromA < MIN_WALL_LENGTH) {\n    return { floor, result: { nodeId: wall.a, wallIds: null, droppedOpeningIds: [] }, issues: [] };\n  }\n  if (len - fromA < MIN_WALL_LENGTH) {\n    return { floor, result: { nodeId: wall.b, wallIds: null, droppedOpeningIds: [] }, issues: [] };\n  }\n\n  const next = cloneFloor(floor);\n  const nodeId = newId('n');\n  next.nodes[nodeId] = { id: nodeId, x: exact.x, y: exact.y };\n\n  const firstId = newId('w');\n  const secondId = newId('w');\n  const base = { thickness: wall.thickness, type: wall.type, height: wall.height, baseHeight: wall.baseHeight };\n  next.walls[firstId] = { ...base, id: firstId, a: wall.a, b: nodeId };\n  next.walls[secondId] = { ...base, id: secondId, a: nodeId, b: wall.b };\n  delete next.walls[wallId];\n\n  // Reassign openings by the side their CENTRE falls on. An opening straddling the cut\n  // is a genuine conflict: move it wholly into that child and clamp it, or drop it and\n  // say so. Silently deleting a window is not acceptable.\n  const droppedOpeningIds: string[] = [];\n  const issues: PlanIssue[] = [];\n  for (const opening of Object.values(floor.openings)) {\n    if (opening.wallId !== wallId) continue;\n    const intoFirst = opening.offset <= fromA;\n    const childId = intoFirst ? firstId : secondId;\n    const childLen = intoFirst ? fromA : len - fromA;\n    const offset = intoFirst ? opening.offset : opening.offset - fromA;\n\n    const maxWidth = Math.min(opening.width, childLen - 2, offset * 2, (childLen - offset) * 2);\n    if (maxWidth < MIN_OPENING_WIDTH) {\n      delete next.openings[opening.id];\n      droppedOpeningIds.push(opening.id);\n      issues.push(\n        issue(PlanIssueKind.OpeningDropped, 'An opening was removed: the wall it sat on became too short for it.', {\n          openingIds: [opening.id],\n          wallIds: [wallId],\n        }),\n      );\n      continue;\n    }\n    next.openings[opening.id] = { ...opening, wallId: childId, offset, width: maxWidth };\n  }\n\n  return { floor: next, result: { nodeId, wallIds: [firstId, secondId], droppedOpeningIds }, issues };\n}\n\n// ─── resolveNodeAt ─────────────────────────────────────────────────────────────\n\nexport interface ResolveNodeResult {\n  nodeId: string;\n  createdNode: boolean;\n  splitWallId: string | null;\n}\n\n/**\n * Returns the node to use at `p`: an existing one within `tol`, a new one created by\n * splitting a wall that passes under `p`, or a brand new free-standing node.\n */\nexport function resolveNodeAt(floor: PlanFloor, p: PlanPoint, tol: number): PlanEdit<ResolveNodeResult> {\n  const existing = findNodeNear(floor, p, tol);\n  if (existing) {\n    return { floor, result: { nodeId: existing.id, createdNode: false, splitWallId: null }, issues: [] };\n  }\n\n  const onWall = findWallNear(floor, p, tol);\n  if (onWall) {\n    const split = splitWall(floor, onWall.wall.id, onWall.point);\n    if (split.result.nodeId) {\n      return {\n        floor: split.floor,\n        result: {\n          nodeId: split.result.nodeId,\n          createdNode: split.result.wallIds !== null,\n          splitWallId: split.result.wallIds ? onWall.wall.id : null,\n        },\n        issues: split.issues,\n      };\n    }\n  }\n\n  const next = cloneFloor(floor);\n  const nodeId = newId('n');\n  next.nodes[nodeId] = { id: nodeId, x: p.x, y: p.y };\n  return { floor: next, result: { nodeId, createdNode: true, splitWallId: null }, issues: [] };\n}\n\n// ─── addWall ───────────────────────────────────────────────────────────────────\n\nexport type WallAttrs = Pick<PlanWall, 'thickness' | 'type'> & Partial<Pick<PlanWall, 'height' | 'baseHeight'>>;\n\nexport const DEFAULT_WALL_ATTRS: WallAttrs = { thickness: 200, type: WallType.Interior };\n\ninterface Cut {\n  t: number;\n  nodeId: string | null;\n  /** Set while the node does not exist yet because its wall has not been split. */\n  pending?: { wallId: string; s: number };\n}\n\n/**\n * Adds a wall from `a` to `b`, splitting anything it crosses so the graph stays planar.\n *\n * Collect-then-apply, in two phases: the naive version splits walls while iterating\n * over walls, which both invalidates the iteration and reparameterises the very\n * segments it is about to test.\n */\nexport function addWall(\n  floor: PlanFloor,\n  a: PlanPoint,\n  b: PlanPoint,\n  attrs: WallAttrs = DEFAULT_WALL_ATTRS,\n  tol: number = EPS_COINCIDENT,\n): PlanEdit<{ wallIds: string[]; nodeIds: string[] }> {\n  const issues: PlanIssue[] = [];\n  if (dist(a, b) < MIN_WALL_LENGTH) {\n    return { floor, result: { wallIds: [], nodeIds: [] }, issues };\n  }\n\n  // 1. Endpoints. Each may reuse a node, split a wall, or create a node.\n  const startEdit = resolveNodeAt(floor, a, tol);\n  let work = startEdit.floor;\n  issues.push(...startEdit.issues);\n  const endEdit = resolveNodeAt(work, b, tol);\n  work = endEdit.floor;\n  issues.push(...endEdit.issues);\n\n  const na = startEdit.result.nodeId;\n  const nb = endEdit.result.nodeId;\n  if (na === nb) return { floor, result: { wallIds: [], nodeIds: [] }, issues };\n\n  const A = work.nodes[na];\n  const B = work.nodes[nb];\n  const len = dist(A, B);\n  if (len < MIN_WALL_LENGTH) return { floor, result: { wallIds: [], nodeIds: [] }, issues };\n\n  // 2. COLLECT. Nothing is mutated in this phase.\n  const cuts: Cut[] = [\n    { t: 0, nodeId: na },\n    { t: 1, nodeId: nb },\n  ];\n  const splits = new Map<string, number[]>();\n  const overlaps: Array<[number, number]> = [];\n\n  const paramAlong = (p: PlanPoint): number => pointToSegment(p, A, B).t;\n\n  for (const wall of Object.values(work.walls)) {\n    const wa = work.nodes[wall.a];\n    const wb = work.nodes[wall.b];\n    if (!wa || !wb) continue;\n\n    const hit = segmentIntersection(A, B, wa, wb, tol);\n\n    if (hit.kind === 'collinearOverlap') {\n      const t0 = paramAlong(wa);\n      const t1 = paramAlong(wb);\n      overlaps.push([Math.min(t0, t1), Math.max(t0, t1)]);\n      // Endpoints of the overlapping wall that fall strictly inside AB still need cuts,\n      // or the new wall would run straight past them.\n      for (const [node, t] of [\n        [wa, t0],\n        [wb, t1],\n      ] as const) {\n        if (t * len > MIN_WALL_LENGTH && (1 - t) * len > MIN_WALL_LENGTH) {\n          cuts.push({ t, nodeId: node.id });\n        }\n      }\n      continue;\n    }\n\n    if (hit.kind === 'proper' && hit.t !== undefined && hit.s !== undefined) {\n      const list = splits.get(wall.id);\n      if (list) list.push(hit.s);\n      else splits.set(wall.id, [hit.s]);\n      cuts.push({ t: hit.t, nodeId: null, pending: { wallId: wall.id, s: hit.s } });\n      continue;\n    }\n\n    if (hit.kind === 'touch' && hit.t !== undefined && hit.s !== undefined) {\n      // A T junction where one of the wall's own endpoints sits on AB: reuse it.\n      const atWallStart = hit.s <= 0.5;\n      const endpoint = atWallStart ? wa : wb;\n      const tOnAb = paramAlong(endpoint);\n      if (\n        pointToSegment(endpoint, A, B).dist <= tol &&\n        tOnAb * len > MIN_WALL_LENGTH &&\n        (1 - tOnAb) * len > MIN_WALL_LENGTH\n      ) {\n        cuts.push({ t: tOnAb, nodeId: endpoint.id });\n      }\n    }\n  }\n\n  // 3. Nodes lying on AB that no crossing test found. NOT redundant with step 2: a node\n  // whose incident walls all run away from AB is invisible to every crossing test, yet\n  // failing to cut AB there leaves a node on a wall interior, which silently merges the\n  // two rooms either side of it.\n  for (const node of Object.values(work.nodes)) {\n    if (node.id === na || node.id === nb) continue;\n    const r = pointToSegment(node, A, B);\n    if (r.dist > tol) continue;\n    if (r.t * len <= MIN_WALL_LENGTH || (1 - r.t) * len <= MIN_WALL_LENGTH) continue;\n    cuts.push({ t: r.t, nodeId: node.id });\n  }\n\n  // 4. APPLY splits, per wall, in DESCENDING parameter order so that earlier\n  // parameters stay valid as later ones are consumed.\n  for (const [wallId, params] of splits) {\n    const sorted = [...params].sort((x, y) => y - x);\n    let currentWallId = wallId;\n    const remaining = new Set(sorted);\n    for (const s of sorted) {\n      const target = work.walls[currentWallId];\n      if (!target) break;\n      const wa = work.nodes[target.a];\n      const wb = work.nodes[target.b];\n      if (!wa || !wb) break;\n      // Re-project onto the wall as it stands now, rather than reusing the original\n      // parameter, which the previous split may have reparameterised.\n      const original = floor.walls[wallId];\n      const oa = work.nodes[original?.a ?? target.a] ?? wa;\n      const ob = work.nodes[original?.b ?? target.b] ?? wb;\n      const worldPoint = { x: oa.x + (ob.x - oa.x) * s, y: oa.y + (ob.y - oa.y) * s };\n      const edit = splitWall(work, currentWallId, worldPoint);\n      work = edit.floor;\n      issues.push(...edit.issues);\n      remaining.delete(s);\n      for (const cut of cuts) {\n        if (cut.pending && cut.pending.wallId === wallId && cut.pending.s === s) {\n          cut.nodeId = edit.result.nodeId;\n          cut.pending = undefined;\n        }\n      }\n      // Continue splitting whichever child still holds the remaining parameters.\n      if (edit.result.wallIds) {\n        const [first, second] = edit.result.wallIds;\n        const nextS = Math.max(...[...remaining], -1);\n        currentWallId = nextS >= 0 && nextS > s ? second : first;\n      }\n    }\n  }\n\n  // 5. Chain the cuts into walls.\n  const resolved = cuts.filter((c): c is Cut & { nodeId: string } => Boolean(c.nodeId));\n  resolved.sort((x, y) => x.t - y.t);\n\n  const chain: Array<Cut & { nodeId: string }> = [];\n  for (const cut of resolved) {\n    const last = chain[chain.length - 1];\n    if (!last) {\n      chain.push(cut);\n      continue;\n    }\n    if (last.nodeId === cut.nodeId) continue;\n    if ((cut.t - last.t) * len < MIN_WALL_LENGTH) {\n      // Too close to be a separate wall. Prefer whichever end is an endpoint of AB.\n      if (cut.t >= 1 - 1e-9) chain[chain.length - 1] = cut;\n      continue;\n    }\n    chain.push(cut);\n  }\n\n  const createdWallIds: string[] = [];\n  for (let i = 0; i + 1 < chain.length; i++) {\n    const from = chain[i];\n    const to = chain[i + 1];\n    const midT = (from.t + to.t) / 2;\n    if (overlaps.some(([lo, hi]) => midT > lo + 1e-9 && midT < hi - 1e-9)) {\n      // Already walled. Do not create a duplicate, and do not rewrite the existing\n      // wall's attributes from a stroke that was aimed elsewhere.\n      continue;\n    }\n    if (findWallBetween(work, from.nodeId, to.nodeId)) continue;\n    const wa = work.nodes[from.nodeId];\n    const wb = work.nodes[to.nodeId];\n    if (!wa || !wb || dist(wa, wb) < MIN_WALL_LENGTH) continue;\n\n    const id = newId('w');\n    work = { ...work, walls: { ...work.walls, [id]: { ...attrs, id, a: from.nodeId, b: to.nodeId } } };\n    createdWallIds.push(id);\n  }\n\n  if (createdWallIds.length === 0 && overlaps.length > 0) {\n    issues.push(issue(PlanIssueKind.DuplicateWall, 'A wall already covers that span, so nothing was added.'));\n  }\n\n  return {\n    floor: work,\n    result: { wallIds: createdWallIds, nodeIds: chain.map((c) => c.nodeId) },\n    issues,\n  };\n}\n\n/** Draws the four walls of an axis-aligned rectangle, welding onto anything already there. */\nexport function addRect(\n  floor: PlanFloor,\n  corner: PlanPoint,\n  opposite: PlanPoint,\n  attrs: WallAttrs = DEFAULT_WALL_ATTRS,\n  tol: number = EPS_COINCIDENT,\n): PlanEdit<{ wallIds: string[] }> {\n  const x0 = Math.min(corner.x, opposite.x);\n  const x1 = Math.max(corner.x, opposite.x);\n  const y0 = Math.min(corner.y, opposite.y);\n  const y1 = Math.max(corner.y, opposite.y);\n  if (x1 - x0 < MIN_WALL_LENGTH || y1 - y0 < MIN_WALL_LENGTH) {\n    return { floor, result: { wallIds: [] }, issues: [] };\n  }\n\n  const corners: PlanPoint[] = [\n    { x: x0, y: y0 },\n    { x: x1, y: y0 },\n    { x: x1, y: y1 },\n    { x: x0, y: y1 },\n  ];\n\n  let work = floor;\n  const wallIds: string[] = [];\n  const issues: PlanIssue[] = [];\n  for (let i = 0; i < 4; i++) {\n    const edit = addWall(work, corners[i], corners[(i + 1) % 4], attrs, tol);\n    work = edit.floor;\n    wallIds.push(...edit.result.wallIds);\n    issues.push(...edit.issues);\n  }\n  return { floor: work, result: { wallIds }, issues };\n}\n\n// ─── mergeNodes ────────────────────────────────────────────────────────────────\n\n/**\n * Merges `removeId` into `keepId`, as when a node is dragged onto another.\n *\n * Order matters, and step 3 is mandatory rather than cosmetic: a duplicate wall between\n * the same pair of nodes is exactly the identical-angle degeneracy that corrupts the\n * face walk's angular sort.\n */\nexport function mergeNodes(floor: PlanFloor, keepId: string, removeId: string): PlanEdit<{ removedWallIds: string[] }> {\n  if (keepId === removeId || !floor.nodes[keepId] || !floor.nodes[removeId]) {\n    return { floor, result: { removedWallIds: [] }, issues: [] };\n  }\n\n  const next = cloneFloor(floor);\n  const removedWallIds: string[] = [];\n  const issues: PlanIssue[] = [];\n\n  // 1. Rewire.\n  for (const wall of Object.values(next.walls)) {\n    if (wall.a === removeId) next.walls[wall.id] = { ...next.walls[wall.id], a: keepId };\n    if (wall.b === removeId) next.walls[wall.id] = { ...next.walls[wall.id], b: keepId };\n  }\n\n  // 2. Drop self-loops, and their openings with them.\n  for (const wall of Object.values(next.walls)) {\n    if (wall.a !== wall.b) continue;\n    delete next.walls[wall.id];\n    removedWallIds.push(wall.id);\n    for (const opening of Object.values(next.openings)) {\n      if (opening.wallId === wall.id) delete next.openings[opening.id];\n    }\n  }\n\n  // 3. Deduplicate walls that now share the same unordered node pair.\n  const seen = new Map<string, PlanWall>();\n  for (const wall of Object.values(next.walls)) {\n    const key = wall.a < wall.b ? `${wall.a}|${wall.b}` : `${wall.b}|${wall.a}`;\n    const prior = seen.get(key);\n    if (!prior) {\n      seen.set(key, wall);\n      continue;\n    }\n    // Keep the thicker wall, and carry both walls' openings onto it.\n    const keep = wall.thickness >= prior.thickness ? wall : prior;\n    const drop = keep === wall ? prior : wall;\n    for (const opening of Object.values(next.openings)) {\n      if (opening.wallId === drop.id) {\n        next.openings[opening.id] = { ...opening, wallId: keep.id };\n      }\n    }\n    delete next.walls[drop.id];\n    removedWallIds.push(drop.id);\n    seen.set(key, keep);\n    issues.push(\n      issue(PlanIssueKind.DuplicateWall, 'Two walls became the same wall and were merged.', {\n        wallIds: [keep.id, drop.id],\n      }),\n    );\n  }\n\n  // 4. Drop the now-unreferenced node.\n  delete next.nodes[removeId];\n\n  return { floor: next, result: { removedWallIds }, issues };\n}\n\n// ─── dissolveNode ──────────────────────────────────────────────────────────────\n\nexport interface DissolveNodeOptions {\n  /**\n   * Rejoin the two walls even when the corner is bent or the walls differ in\n   * construction, taking the thicker wall's attributes and rescaling openings onto the\n   * shorter merged wall.\n   *\n   * This is \"delete this corner\" as a user means it. The default, unforced behaviour is\n   * the stricter one used by cleanup and by `removeWall`, where dissolving must not\n   * change the drawing's geometry at all.\n   */\n  force?: boolean;\n}\n\n/**\n * Merges the two walls meeting at a degree-2 node back into one, the natural inverse of\n * `splitWall`.\n *\n * Returns `null` unless the node is genuinely a seam: degree exactly 2, both walls\n * identical in construction, and the turn within `EPS_ANGLE` of straight. Pass\n * `{ force: true }` to rejoin a bent corner as well. Never call it mid-drag: it destroys\n * node ids the user may be holding.\n */\nexport function dissolveNode(\n  floor: PlanFloor,\n  nodeId: string,\n  options: DissolveNodeOptions = {},\n): PlanEdit<{ wallId: string } | null> {\n  const { force = false } = options;\n  const node = floor.nodes[nodeId];\n  if (!node) return { floor, result: null, issues: [] };\n\n  const incident = wallsAtNode(floor, nodeId);\n  if (incident.length !== 2) return { floor, result: null, issues: [] };\n\n  const [w1, w2] = incident;\n  const sameConstruction =\n    w1.thickness === w2.thickness && w1.type === w2.type && w1.height === w2.height && w1.baseHeight === w2.baseHeight;\n  if (!sameConstruction && !force) return { floor, result: null, issues: [] };\n\n  const far1 = w1.a === nodeId ? w1.b : w1.a;\n  const far2 = w2.a === nodeId ? w2.b : w2.a;\n  if (far1 === far2) return { floor, result: null, issues: [] };\n\n  const p1 = floor.nodes[far1];\n  const p2 = floor.nodes[far2];\n  if (!p1 || !p2) return { floor, result: null, issues: [] };\n\n  const span = dist(p1, p2);\n  if (span < MIN_WALL_LENGTH) return { floor, result: null, issues: [] };\n\n  if (!force) {\n    // Straightness by perpendicular offset rather than raw angle, so the tolerance stays\n    // meaningful at any wall length.\n    const offset = Math.abs(cross(p1, p2, node)) / span;\n    if (offset > Math.max(EPS_COINCIDENT, span * EPS_ANGLE)) {\n      return { floor, result: null, issues: [] };\n    }\n  }\n\n  // Forced over a bent corner, the survivor is the thicker of the two, since that is the\n  // one whose construction the rest of the plan is more likely to depend on.\n  const keep = !sameConstruction && w1.thickness < w2.thickness ? w2 : w1;\n\n  const next = cloneFloor(floor);\n  const id = newId('w');\n  next.walls[id] = {\n    id,\n    a: far1,\n    b: far2,\n    thickness: keep.thickness,\n    type: keep.type,\n    height: keep.height,\n    baseHeight: keep.baseHeight,\n  };\n\n  // Re-express every opening's offset against the merged wall's direction (far1 -> far2).\n  const len1 = dist(p1, node);\n  const len2 = dist(node, p2);\n  // Cutting a bent corner shortens the run, so positions are scaled along it rather than\n  // carried over, which would push an opening off the end of its own wall.\n  const scale = len1 + len2 > 0 ? span / (len1 + len2) : 1;\n  const issues: PlanIssue[] = [];\n\n  for (const opening of Object.values(floor.openings)) {\n    if (opening.wallId !== w1.id && opening.wallId !== w2.id) continue;\n    const onFirst = opening.wallId === w1.id;\n    const wall = onFirst ? w1 : w2;\n    const startsAtNode = wall.a === nodeId;\n    const lenOfWall = wallLength(floor, wall);\n    // Distance from the seam, then from the merged wall's own start.\n    const fromSeam = startsAtNode ? opening.offset : lenOfWall - opening.offset;\n    const alongOriginal = onFirst ? len1 - fromSeam : len1 + fromSeam;\n    const offsetOnMerged = alongOriginal * scale;\n\n    const width = Math.min(opening.width * scale, span - 2);\n    if (width < MIN_OPENING_WIDTH) {\n      issues.push(\n        issue(PlanIssueKind.OpeningDropped, 'An opening was removed: the wall it sat on became too short for it.', {\n          openingIds: [opening.id],\n          wallIds: [wall.id],\n        }),\n      );\n      delete next.openings[opening.id];\n      continue;\n    }\n\n    next.openings[opening.id] = {\n      ...opening,\n      wallId: id,\n      width,\n      offset: Math.min(Math.max(offsetOnMerged, width / 2), span - width / 2),\n    };\n  }\n\n  delete next.walls[w1.id];\n  delete next.walls[w2.id];\n  delete next.nodes[nodeId];\n\n  return { floor: next, result: { wallId: id }, issues };\n}\n\n// ─── detachWall ────────────────────────────────────────────────────────────────\n\nexport interface DetachWallResult {\n  /** The wall's end nodes after the detach, in `[a, b]` order. */\n  nodeIds: [string, string];\n  /** Connecting walls minted where an end was shared with a neighbour. */\n  connectorIds: string[];\n  /** Ends that became a straight seam once the wall left, and were dissolved away. */\n  dissolvedNodeIds: string[];\n}\n\n/**\n * Pulls a wall off the nodes it shares with its neighbours and moves it by `delta`,\n * leaving a connecting wall behind at each end that was shared.\n *\n * This is the extrude half of dragging a wall. A plain drag moves the shared end nodes,\n * so everything meeting the wall follows it; here the neighbours keep their ends and\n * only the new connectors grow, which is what you want when a partition joins the wall\n * halfway along and should stay put.\n *\n * A free end is only moved: there is nothing there to detach from, and a connector would\n * be zero length. For the same reason `delta` must be at least `MIN_WALL_LENGTH` long —\n * below that the caller should `moveNode` both ends instead.\n *\n * The connector continues whatever was already at the corner (its thickness, type and\n * heights) when exactly one wall was, so pulling a wall off a plain corner redraws\n * exactly as a plain drag would: the seam that leaves behind is straight and is\n * dissolved before returning. At a junction there is no single wall to continue, so the\n * connector takes the dragged wall's own construction.\n */\nexport function detachWall(floor: PlanFloor, wallId: string, delta: PlanPoint): PlanEdit<DetachWallResult | null> {\n  const wall = floor.walls[wallId];\n  if (!wall || wall.a === wall.b) return { floor, result: null, issues: [] };\n  if (Math.hypot(delta.x, delta.y) < MIN_WALL_LENGTH) return { floor, result: null, issues: [] };\n\n  const ends: [string, string] = [wall.a, wall.b];\n  const nodeIds: [string, string] = [wall.a, wall.b];\n  const sources: (PlanWall | null)[] = [null, null];\n  const connectorIds: string[] = [];\n  const issues: PlanIssue[] = [];\n  let out = floor;\n\n  // 1. Give the wall its own ends. `resolveNodeAt` rather than a bare node, because the\n  //    new end often lands in the middle of another wall — the usual case is pushing the\n  //    shared wall of two rooms sideways, where each end slides along the wall above and\n  //    below it — and only a split keeps a node off a wall's interior.\n  ends.forEach((nodeId, index) => {\n    const origin = floor.nodes[nodeId];\n    if (!origin) return;\n    const to = { x: origin.x + delta.x, y: origin.y + delta.y };\n    const others = wallsAtNode(floor, nodeId).filter((w) => w.id !== wallId);\n\n    if (others.length === 0) {\n      // A free end has nothing to detach from, and a connector there would be a wall\n      // between a node and itself.\n      const next = cloneFloor(out);\n      next.nodes[nodeId] = { ...next.nodes[nodeId], x: to.x, y: to.y };\n      out = next;\n      return;\n    }\n\n    const edit = resolveNodeAt(out, to, EPS_COINCIDENT);\n    out = edit.floor;\n    nodeIds[index] = edit.result.nodeId;\n    // The connector continues whatever was already at this corner, so pulling a wall off\n    // a plain corner redraws exactly as a plain drag would. At a junction there is no\n    // single wall to continue, so it takes the dragged wall's own construction.\n    sources[index] = others.length === 1 ? others[0] : wall;\n  });\n\n  // 2. Move the wall onto them. Its openings ride along untouched: a detach is a pure\n  //    translation, so the wall keeps its id, its direction and its length.\n  const moved = cloneFloor(out);\n  moved.walls[wallId] = { ...moved.walls[wallId], a: nodeIds[0], b: nodeIds[1] };\n  out = moved;\n\n  // 3. Bridge each end back to where it came from, unless a wall already runs there.\n  ends.forEach((nodeId, index) => {\n    const source = sources[index];\n    const from = out.nodes[nodeId];\n    const to = out.nodes[nodeIds[index]];\n    if (!source || !from || !to) return;\n    const edit = addWall(out, from, to, {\n      thickness: source.thickness,\n      type: source.type,\n      height: source.height,\n      baseHeight: source.baseHeight,\n    });\n    out = edit.floor;\n    connectorIds.push(...edit.result.wallIds);\n    issues.push(...edit.issues);\n  });\n\n  // 4. An end that was a plain corner is now a straight seam. Dissolving it is what\n  //    makes detaching a wall with nothing attached to it a no-op on the drawing.\n  const dissolvedNodeIds: string[] = [];\n  ends.forEach((nodeId, index) => {\n    if (nodeIds[index] === nodeId) return;\n    const edit = dissolveNode(out, nodeId);\n    if (!edit.result) return;\n    out = edit.floor;\n    dissolvedNodeIds.push(nodeId);\n    issues.push(...edit.issues);\n  });\n\n  return { floor: out, result: { nodeIds, connectorIds, dissolvedNodeIds }, issues };\n}\n\n// ─── weldShortWalls ────────────────────────────────────────────────────────────\n\n/**\n * Collapses every wall shorter than `minLength` by merging its two ends together.\n *\n * Squashing a wall to nothing is the one thing a drag can do that the model forbids, and\n * it is easy to do by accident: pushing a wall back onto the line it was detached from,\n * or dragging a corner past the one next to it. Deleting the short wall is the wrong\n * repair — it leaves two nodes sitting on the same point with the plan split between\n * them, which reads as two corners stacked on top of each other and derives as two\n * rooms. Merging is lossless, since the two ends are within `minLength` of each other by\n * definition.\n *\n * The end with more walls on it survives, so the corner that was already there keeps its\n * position and the one that arrived is the one that gives way.\n */\nexport function weldShortWalls(\n  floor: PlanFloor,\n  minLength: number = MIN_WALL_LENGTH,\n): PlanEdit<{ weldedWallIds: string[] }> {\n  let out = floor;\n  const weldedWallIds: string[] = [];\n  const issues: PlanIssue[] = [];\n\n  // Re-scan rather than iterate: one weld moves nodes, so it can shorten another wall to\n  // nothing in turn. Bounded by the wall count, since every pass removes at least one.\n  for (let guard = Object.keys(floor.walls).length; guard > 0; guard--) {\n    const short = Object.values(out.walls).find((w) => {\n      if (w.a === w.b) return false;\n      const a = out.nodes[w.a];\n      const b = out.nodes[w.b];\n      return a && b && dist(a, b) < minLength;\n    });\n    if (!short) break;\n\n    const keep = wallsAtNode(out, short.b).length > wallsAtNode(out, short.a).length ? short.b : short.a;\n    const edit = mergeNodes(out, keep, keep === short.a ? short.b : short.a);\n    if (edit.floor === out) break;\n    out = edit.floor;\n    weldedWallIds.push(short.id);\n    issues.push(...edit.issues);\n  }\n\n  return { floor: out, result: { weldedWallIds }, issues };\n}\n\n// ─── removeWall / moveNode ─────────────────────────────────────────────────────\n\nexport function removeWall(\n  floor: PlanFloor,\n  wallId: string,\n  opts: { pruneOrphanNodes?: boolean; dissolveCollinear?: boolean } = {},\n): PlanEdit<{ removedNodeIds: string[]; dissolvedWallIds: string[] }> {\n  const { pruneOrphanNodes = true, dissolveCollinear = true } = opts;\n  const wall = floor.walls[wallId];\n  if (!wall) return { floor, result: { removedNodeIds: [], dissolvedWallIds: [] }, issues: [] };\n\n  let next = cloneFloor(floor);\n  delete next.walls[wallId];\n  for (const opening of Object.values(next.openings)) {\n    if (opening.wallId === wallId) delete next.openings[opening.id];\n  }\n\n  const removedNodeIds: string[] = [];\n  const dissolvedWallIds: string[] = [];\n  const issues: PlanIssue[] = [];\n\n  for (const endpoint of [wall.a, wall.b]) {\n    const degree = wallsAtNode(next, endpoint).length;\n    if (degree === 0 && pruneOrphanNodes) {\n      delete next.nodes[endpoint];\n      removedNodeIds.push(endpoint);\n    } else if (degree === 2 && dissolveCollinear) {\n      // The natural inverse of the split that created this seam.\n      const edit = dissolveNode(next, endpoint);\n      if (edit.result) {\n        next = edit.floor;\n        dissolvedWallIds.push(edit.result.wallId);\n        removedNodeIds.push(endpoint);\n        issues.push(...edit.issues);\n      }\n    }\n  }\n\n  return { floor: next, result: { removedNodeIds, dissolvedWallIds }, issues };\n}\n\nexport function moveNode(floor: PlanFloor, nodeId: string, to: PlanPoint): PlanEdit {\n  const node = floor.nodes[nodeId];\n  if (!node) return { floor, result: undefined, issues: [] };\n  const next = cloneFloor(floor);\n  next.nodes[nodeId] = { ...node, x: to.x, y: to.y };\n  return { floor: next, result: undefined, issues: [] };\n}\n\n/**\n * Translates every node, and every room anchor with it.\n *\n * Room matching does not depend on this (it is primarily wall-id based), but a plan\n * that is dragged and then saved without a derive should still have sane anchors.\n */\nexport function transformPlan(floor: PlanFloor, dx: number, dy: number): PlanFloor {\n  const next = cloneFloor(floor);\n  for (const node of Object.values(floor.nodes)) {\n    next.nodes[node.id] = { ...node, x: node.x + dx, y: node.y + dy };\n  }\n  for (const room of Object.values(floor.rooms)) {\n    next.rooms[room.id] = { ...room, anchor: { x: room.anchor.x + dx, y: room.anchor.y + dy } };\n  }\n  return next;\n}\n\n/**\n * Multiplies every coordinate and dimension by `factor`.\n *\n * The one place a scale factor belongs: converting a unitless legacy plan into the\n * module's millimetre invariant, once, at the import boundary. The caller picks the\n * factor, because nothing in the old data says what it should be.\n */\nexport function scalePlan(floor: PlanFloor, factor: number): PlanFloor {\n  const next = cloneFloor(floor);\n  for (const node of Object.values(floor.nodes)) {\n    next.nodes[node.id] = { ...node, x: node.x * factor, y: node.y * factor };\n  }\n  for (const wall of Object.values(floor.walls)) {\n    next.walls[wall.id] = {\n      ...wall,\n      thickness: wall.thickness * factor,\n      height: wall.height === undefined ? undefined : wall.height * factor,\n      baseHeight: wall.baseHeight === undefined ? undefined : wall.baseHeight * factor,\n    };\n  }\n  for (const opening of Object.values(floor.openings)) {\n    next.openings[opening.id] = {\n      ...opening,\n      offset: opening.offset * factor,\n      width: opening.width * factor,\n      sill: opening.sill * factor,\n      head: opening.head * factor,\n    };\n  }\n  for (const room of Object.values(floor.rooms)) {\n    next.rooms[room.id] = {\n      ...room,\n      anchor: { x: room.anchor.x * factor, y: room.anchor.y * factor },\n      area: room.area * factor * factor,\n    };\n  }\n  return next;\n}\n\n// ─── Openings ──────────────────────────────────────────────────────────────────\n\nexport function addOpening(floor: PlanFloor, opening: Omit<PlanOpening, 'id'>): PlanEdit<{ openingId: string | null }> {\n  const wall = floor.walls[opening.wallId];\n  if (!wall) return { floor, result: { openingId: null }, issues: [] };\n\n  const len = wallLength(floor, wall);\n  const width = Math.min(opening.width, len - 2);\n  if (width < MIN_OPENING_WIDTH) {\n    return {\n      floor,\n      result: { openingId: null },\n      issues: [\n        issue(PlanIssueKind.OpeningDropped, 'That wall is too short for an opening.', {\n          wallIds: [wall.id],\n        }),\n      ],\n    };\n  }\n\n  const offset = Math.min(Math.max(opening.offset, width / 2), len - width / 2);\n  const next = cloneFloor(floor);\n  const id = newId('o');\n  next.openings[id] = { ...opening, id, offset, width };\n  return { floor: next, result: { openingId: id }, issues: [] };\n}\n\nexport function updateOpening(\n  floor: PlanFloor,\n  openingId: string,\n  patch: Partial<Omit<PlanOpening, 'id' | 'wallId'>>,\n): PlanEdit {\n  const opening = floor.openings[openingId];\n  if (!opening) return { floor, result: undefined, issues: [] };\n  const wall = floor.walls[opening.wallId];\n  if (!wall) return { floor, result: undefined, issues: [] };\n\n  const len = wallLength(floor, wall);\n  const merged = { ...opening, ...patch };\n  const width = Math.min(Math.max(merged.width, MIN_OPENING_WIDTH), Math.max(len - 2, MIN_OPENING_WIDTH));\n  const offset = Math.min(Math.max(merged.offset, width / 2), Math.max(len - width / 2, width / 2));\n\n  const next = cloneFloor(floor);\n  next.openings[openingId] = { ...merged, width, offset };\n  return { floor: next, result: undefined, issues: [] };\n}\n\nexport function removeOpening(floor: PlanFloor, openingId: string): PlanEdit {\n  if (!floor.openings[openingId]) return { floor, result: undefined, issues: [] };\n  const next = cloneFloor(floor);\n  delete next.openings[openingId];\n  return { floor: next, result: undefined, issues: [] };\n}\n\n// ─── Validation and cleanup ────────────────────────────────────────────────────\n\n/**\n * Reports every way the graph currently violates the planar invariant.\n *\n * O(W²), so run it in tests and in development, not on every keystroke.\n */\nexport function validatePlan(floor: PlanFloor): PlanIssue[] {\n  const issues: PlanIssue[] = [];\n  const walls = Object.values(floor.walls);\n\n  for (const wall of walls) {\n    const a = floor.nodes[wall.a];\n    const b = floor.nodes[wall.b];\n    if (wall.a === wall.b) {\n      issues.push(\n        issue(PlanIssueKind.SelfLoopWall, 'A wall starts and ends at the same node.', { wallIds: [wall.id] }),\n      );\n      continue;\n    }\n    if (!a || !b) {\n      issues.push(issue(PlanIssueKind.ZeroLengthWall, 'A wall references a missing node.', { wallIds: [wall.id] }));\n      continue;\n    }\n    if (dist(a, b) < MIN_WALL_LENGTH) {\n      issues.push(\n        issue(PlanIssueKind.ZeroLengthWall, 'A wall is shorter than the minimum length.', { wallIds: [wall.id] }),\n      );\n    }\n  }\n\n  const pairSeen = new Map<string, string>();\n  for (const wall of walls) {\n    const key = wall.a < wall.b ? `${wall.a}|${wall.b}` : `${wall.b}|${wall.a}`;\n    const prior = pairSeen.get(key);\n    if (prior) {\n      issues.push(\n        issue(PlanIssueKind.DuplicateWall, 'Two walls connect the same pair of nodes.', {\n          wallIds: [prior, wall.id],\n        }),\n      );\n    } else {\n      pairSeen.set(key, wall.id);\n    }\n  }\n\n  const nodes = Object.values(floor.nodes);\n  for (let i = 0; i < nodes.length; i++) {\n    for (let j = i + 1; j < nodes.length; j++) {\n      if (dist(nodes[i], nodes[j]) < EPS_COINCIDENT) {\n        issues.push(\n          issue(PlanIssueKind.CoincidentNodes, 'Two nodes occupy the same position.', {\n            nodeIds: [nodes[i].id, nodes[j].id],\n          }),\n        );\n      }\n    }\n  }\n\n  for (let i = 0; i < walls.length; i++) {\n    for (let j = i + 1; j < walls.length; j++) {\n      const w1 = walls[i];\n      const w2 = walls[j];\n      const a = floor.nodes[w1.a];\n      const b = floor.nodes[w1.b];\n      const c = floor.nodes[w2.a];\n      const d = floor.nodes[w2.b];\n      if (!a || !b || !c || !d) continue;\n      const hit = segmentIntersection(a, b, c, d);\n      if (hit.kind === 'proper') {\n        issues.push(\n          issue(PlanIssueKind.UnsplitCrossing, 'Two walls cross with no node at the intersection.', {\n            wallIds: [w1.id, w2.id],\n          }),\n        );\n      } else if (hit.kind === 'collinearOverlap') {\n        issues.push(\n          issue(PlanIssueKind.OverlappingWalls, 'Two walls overlap along the same line.', {\n            wallIds: [w1.id, w2.id],\n          }),\n        );\n      }\n    }\n  }\n\n  for (const wall of walls) {\n    const a = floor.nodes[wall.a];\n    const b = floor.nodes[wall.b];\n    if (!a || !b) continue;\n    for (const node of nodes) {\n      if (node.id === wall.a || node.id === wall.b) continue;\n      const r = pointToSegment(node, a, b);\n      if (r.dist < EPS_COINCIDENT && r.t > 0 && r.t < 1) {\n        issues.push(\n          issue(PlanIssueKind.UnsplitNodeOnWall, 'A node sits on a wall that was never split there.', {\n            wallIds: [wall.id],\n            nodeIds: [node.id],\n          }),\n        );\n      }\n    }\n  }\n\n  for (const opening of Object.values(floor.openings)) {\n    if (!floor.walls[opening.wallId]) {\n      issues.push(\n        issue(PlanIssueKind.DanglingOpening, 'An opening references a wall that no longer exists.', {\n          openingIds: [opening.id],\n        }),\n      );\n    }\n  }\n\n  const referenced = new Set<string>();\n  for (const wall of walls) {\n    referenced.add(wall.a);\n    referenced.add(wall.b);\n  }\n  for (const node of nodes) {\n    if (!referenced.has(node.id)) {\n      issues.push(issue(PlanIssueKind.OrphanNode, 'A node has no walls.', { nodeIds: [node.id] }));\n    }\n  }\n\n  return issues;\n}\n\n/**\n * Removes what validation can safely remove: degenerate walls, orphan nodes, dangling\n * openings, and duplicate walls. Idempotent.\n *\n * Deliberately does not touch unsplit crossings: fixing one changes the room structure,\n * which is the user's call, not a cleanup pass's.\n */\nexport function cleanupPlan(floor: PlanFloor): PlanEdit<PlanIssue[]> {\n  const fixed: PlanIssue[] = [];\n\n  // Welding comes first, and is why the sweep below only ever sees walls that are\n  // degenerate for some other reason: a wall squashed to nothing has two perfectly good\n  // ends, and deleting it would leave them stacked on the same point.\n  const welded = weldShortWalls(floor);\n  const next = cloneFloor(welded.floor);\n  for (const wallId of welded.result.weldedWallIds) {\n    fixed.push(\n      issue(PlanIssueKind.ZeroLengthWall, 'Welded the two ends of a wall with no length.', {\n        wallIds: [wallId],\n      }),\n    );\n  }\n\n  for (const wall of Object.values(next.walls)) {\n    const a = next.nodes[wall.a];\n    const b = next.nodes[wall.b];\n    if (wall.a === wall.b || !a || !b || dist(a, b) < MIN_WALL_LENGTH) {\n      delete next.walls[wall.id];\n      fixed.push(issue(PlanIssueKind.ZeroLengthWall, 'Removed a degenerate wall.', { wallIds: [wall.id] }));\n    }\n  }\n\n  const pairSeen = new Map<string, PlanWall>();\n  for (const wall of Object.values(next.walls)) {\n    const key = wall.a < wall.b ? `${wall.a}|${wall.b}` : `${wall.b}|${wall.a}`;\n    const prior = pairSeen.get(key);\n    if (!prior) {\n      pairSeen.set(key, wall);\n      continue;\n    }\n    const keep = wall.thickness >= prior.thickness ? wall : prior;\n    const drop = keep === wall ? prior : wall;\n    for (const opening of Object.values(next.openings)) {\n      if (opening.wallId === drop.id) next.openings[opening.id] = { ...opening, wallId: keep.id };\n    }\n    delete next.walls[drop.id];\n    pairSeen.set(key, keep);\n    fixed.push(issue(PlanIssueKind.DuplicateWall, 'Removed a duplicate wall.', { wallIds: [drop.id] }));\n  }\n\n  for (const opening of Object.values(next.openings)) {\n    if (!next.walls[opening.wallId]) {\n      delete next.openings[opening.id];\n      fixed.push(\n        issue(PlanIssueKind.DanglingOpening, 'Removed an opening with no wall.', {\n          openingIds: [opening.id],\n        }),\n      );\n    }\n  }\n\n  // One pass to count degrees, rather than scanning every wall per node: the naive form\n  // is O(nodes x walls), which is the dominant cost on a large plan.\n  const referenced = new Set<string>();\n  for (const wall of Object.values(next.walls)) {\n    referenced.add(wall.a);\n    referenced.add(wall.b);\n  }\n  for (const node of Object.values(next.nodes)) {\n    if (!referenced.has(node.id)) {\n      delete next.nodes[node.id];\n      fixed.push(issue(PlanIssueKind.OrphanNode, 'Removed a node with no walls.', { nodeIds: [node.id] }));\n    }\n  }\n\n  return { floor: next, result: fixed, issues: fixed };\n}\n\nexport { wallLength, wallsAtNode, findWallBetween };\n"],"mappings":"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"}
+{"version":3,"file":"floorPlan.graph.mjs","names":[],"sources":["../../../../package/common/floorPlan/floorPlan.graph.ts"],"sourcesContent":["/**\n * Graph maintenance: the operations that keep the wall graph a valid planar embedding\n * while the user draws.\n *\n * The invariant every function here protects: no two walls may cross without a node at\n * the intersection, and no node may lie on a wall's interior without that wall being\n * split there. Break either and the face walk silently merges two rooms into one\n * figure-eight face, with no error anywhere.\n *\n * Every operation is pure and returns a new floor, for direct use as React state.\n */\n\nimport {\n  EPS_ANGLE,\n  EPS_COINCIDENT,\n  MIN_OPENING_WIDTH,\n  MIN_WALL_LENGTH,\n  cross,\n  dist,\n  pointToSegment,\n  projectOnSegment,\n  segmentIntersection,\n} from './floorPlan.geometry';\nimport { PlanIssueKind, WallType } from './floorPlan.types';\nimport type { PlanEdit, PlanFloor, PlanIssue, PlanNode, PlanOpening, PlanPoint, PlanWall } from './floorPlan.types';\n\n// ─── Ids ───────────────────────────────────────────────────────────────────────\n\nlet idSeq = 0;\n\n/**\n * Ids are deliberately non-numeric strings, so `Record` iteration keeps insertion\n * order (JavaScript reorders integer-like keys), which is what makes derivation\n * reproducible.\n */\nexport function newId(prefix: string): string {\n  idSeq += 1;\n  const rand =\n    typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function'\n      ? crypto.randomUUID().slice(0, 8)\n      : Math.random().toString(36).slice(2, 10);\n  return `${prefix}_${rand}${idSeq.toString(36)}`;\n}\n\n/** Test-only: makes generated ids reproducible within a single test. */\nexport function __resetIdSeq(): void {\n  idSeq = 0;\n}\n\n// ─── Internals ─────────────────────────────────────────────────────────────────\n\nfunction cloneFloor(floor: PlanFloor): PlanFloor {\n  return {\n    ...floor,\n    nodes: { ...floor.nodes },\n    walls: { ...floor.walls },\n    openings: { ...floor.openings },\n    rooms: { ...floor.rooms },\n  };\n}\n\nfunction issue(kind: PlanIssueKind, message: string, extra: Partial<PlanIssue> = {}): PlanIssue {\n  return { kind, message, ...extra };\n}\n\nfunction wallLength(floor: PlanFloor, wall: PlanWall): number {\n  const a = floor.nodes[wall.a];\n  const b = floor.nodes[wall.b];\n  if (!a || !b) return 0;\n  return dist(a, b);\n}\n\nfunction wallsAtNode(floor: PlanFloor, nodeId: string): PlanWall[] {\n  return Object.values(floor.walls).filter((w) => w.a === nodeId || w.b === nodeId);\n}\n\nfunction findWallBetween(floor: PlanFloor, a: string, b: string): PlanWall | null {\n  for (const w of Object.values(floor.walls)) {\n    if ((w.a === a && w.b === b) || (w.a === b && w.b === a)) return w;\n  }\n  return null;\n}\n\n// ─── Node spatial hash ─────────────────────────────────────────────────────────\n\n/**\n * Bucket size for the node hash, in millimetres. Any lookup checks the 3x3\n * neighbourhood, so this only has to exceed the largest snap tolerance in world units.\n */\nconst HASH_CELL = 250;\n\nfunction hashKey(x: number, y: number): string {\n  return `${Math.round(x / HASH_CELL)}|${Math.round(y / HASH_CELL)}`;\n}\n\nfunction buildNodeHash(floor: PlanFloor): Map<string, PlanNode[]> {\n  const map = new Map<string, PlanNode[]>();\n  for (const node of Object.values(floor.nodes)) {\n    const key = hashKey(node.x, node.y);\n    const list = map.get(key);\n    if (list) list.push(node);\n    else map.set(key, [node]);\n  }\n  return map;\n}\n\n/** Nearest existing node within `tol`, using the spatial hash. */\nexport function findNodeNear(floor: PlanFloor, p: PlanPoint, tol: number): PlanNode | null {\n  const hash = buildNodeHash(floor);\n  const cx = Math.round(p.x / HASH_CELL);\n  const cy = Math.round(p.y / HASH_CELL);\n  let best: PlanNode | null = null;\n  let bestDist = tol;\n  const span = Math.max(1, Math.ceil(tol / HASH_CELL));\n  for (let dx = -span; dx <= span; dx++) {\n    for (let dy = -span; dy <= span; dy++) {\n      for (const node of hash.get(`${cx + dx}|${cy + dy}`) ?? []) {\n        const d = dist(p, node);\n        if (d <= bestDist) {\n          best = node;\n          bestDist = d;\n        }\n      }\n    }\n  }\n  return best;\n}\n\n/** Nearest wall whose centreline passes within `tol` of `p`. */\nexport function findWallNear(\n  floor: PlanFloor,\n  p: PlanPoint,\n  tol: number,\n  exclude?: ReadonlySet<string>,\n): { wall: PlanWall; t: number; point: PlanPoint; dist: number } | null {\n  let best: { wall: PlanWall; t: number; point: PlanPoint; dist: number } | null = null;\n  for (const wall of Object.values(floor.walls)) {\n    if (exclude?.has(wall.id)) continue;\n    const a = floor.nodes[wall.a];\n    const b = floor.nodes[wall.b];\n    if (!a || !b) continue;\n    const r = pointToSegment(p, a, b);\n    if (r.dist <= tol && (!best || r.dist < best.dist)) {\n      best = { wall, t: r.t, point: r.point, dist: r.dist };\n    }\n  }\n  return best;\n}\n\n// ─── splitWall ─────────────────────────────────────────────────────────────────\n\nexport interface SplitWallResult {\n  nodeId: string;\n  wallIds: [string, string] | null;\n  droppedOpeningIds: string[];\n}\n\n/**\n * Splits a wall at a point or parameter, returning the node at the cut.\n *\n * Refuses to cut within `MIN_WALL_LENGTH` of either end, returning that endpoint's\n * existing node instead. That single rule is what keeps zero-length walls out of the\n * graph entirely, which in turn is what stops the angular sort from being fed a\n * direction-less dart.\n */\nexport function splitWall(floor: PlanFloor, wallId: string, at: PlanPoint | number): PlanEdit<SplitWallResult> {\n  const wall = floor.walls[wallId];\n  if (!wall) {\n    return { floor, result: { nodeId: '', wallIds: null, droppedOpeningIds: [] }, issues: [] };\n  }\n  const a = floor.nodes[wall.a];\n  const b = floor.nodes[wall.b];\n  if (!a || !b) {\n    return { floor, result: { nodeId: '', wallIds: null, droppedOpeningIds: [] }, issues: [] };\n  }\n\n  const len = dist(a, b);\n  const point = typeof at === 'number' ? { x: a.x + (b.x - a.x) * at, y: a.y + (b.y - a.y) * at } : at;\n  // Project exactly, so the two children stay perfectly collinear and dissolveNode can\n  // undo the split cleanly later.\n  const exact = projectOnSegment(point, a, b);\n  const fromA = dist(a, exact);\n\n  if (fromA < MIN_WALL_LENGTH) {\n    return { floor, result: { nodeId: wall.a, wallIds: null, droppedOpeningIds: [] }, issues: [] };\n  }\n  if (len - fromA < MIN_WALL_LENGTH) {\n    return { floor, result: { nodeId: wall.b, wallIds: null, droppedOpeningIds: [] }, issues: [] };\n  }\n\n  const next = cloneFloor(floor);\n  const nodeId = newId('n');\n  next.nodes[nodeId] = { id: nodeId, x: exact.x, y: exact.y };\n\n  const firstId = newId('w');\n  const secondId = newId('w');\n  const base = { thickness: wall.thickness, type: wall.type, height: wall.height, baseHeight: wall.baseHeight };\n  next.walls[firstId] = { ...base, id: firstId, a: wall.a, b: nodeId };\n  next.walls[secondId] = { ...base, id: secondId, a: nodeId, b: wall.b };\n  delete next.walls[wallId];\n\n  // Reassign openings by the side their CENTRE falls on. An opening straddling the cut\n  // is a genuine conflict: move it wholly into that child and clamp it, or drop it and\n  // say so. Silently deleting a window is not acceptable.\n  const droppedOpeningIds: string[] = [];\n  const issues: PlanIssue[] = [];\n  for (const opening of Object.values(floor.openings)) {\n    if (opening.wallId !== wallId) continue;\n    const intoFirst = opening.offset <= fromA;\n    const childId = intoFirst ? firstId : secondId;\n    const childLen = intoFirst ? fromA : len - fromA;\n    const offset = intoFirst ? opening.offset : opening.offset - fromA;\n\n    const maxWidth = Math.min(opening.width, childLen - 2, offset * 2, (childLen - offset) * 2);\n    if (maxWidth < MIN_OPENING_WIDTH) {\n      delete next.openings[opening.id];\n      droppedOpeningIds.push(opening.id);\n      issues.push(\n        issue(PlanIssueKind.OpeningDropped, 'An opening was removed: the wall it sat on became too short for it.', {\n          openingIds: [opening.id],\n          wallIds: [wallId],\n        }),\n      );\n      continue;\n    }\n    next.openings[opening.id] = { ...opening, wallId: childId, offset, width: maxWidth };\n  }\n\n  return { floor: next, result: { nodeId, wallIds: [firstId, secondId], droppedOpeningIds }, issues };\n}\n\n// ─── resolveNodeAt ─────────────────────────────────────────────────────────────\n\nexport interface ResolveNodeResult {\n  nodeId: string;\n  createdNode: boolean;\n  splitWallId: string | null;\n}\n\n/**\n * Returns the node to use at `p`: an existing one within `tol`, a new one created by\n * splitting a wall that passes under `p`, or a brand new free-standing node.\n */\nexport function resolveNodeAt(floor: PlanFloor, p: PlanPoint, tol: number): PlanEdit<ResolveNodeResult> {\n  const existing = findNodeNear(floor, p, tol);\n  if (existing) {\n    return { floor, result: { nodeId: existing.id, createdNode: false, splitWallId: null }, issues: [] };\n  }\n\n  const onWall = findWallNear(floor, p, tol);\n  if (onWall) {\n    const split = splitWall(floor, onWall.wall.id, onWall.point);\n    if (split.result.nodeId) {\n      return {\n        floor: split.floor,\n        result: {\n          nodeId: split.result.nodeId,\n          createdNode: split.result.wallIds !== null,\n          splitWallId: split.result.wallIds ? onWall.wall.id : null,\n        },\n        issues: split.issues,\n      };\n    }\n  }\n\n  const next = cloneFloor(floor);\n  const nodeId = newId('n');\n  next.nodes[nodeId] = { id: nodeId, x: p.x, y: p.y };\n  return { floor: next, result: { nodeId, createdNode: true, splitWallId: null }, issues: [] };\n}\n\n// ─── addWall ───────────────────────────────────────────────────────────────────\n\nexport type WallAttrs = Pick<PlanWall, 'thickness' | 'type'> & Partial<Pick<PlanWall, 'height' | 'baseHeight'>>;\n\nexport const DEFAULT_WALL_ATTRS: WallAttrs = { thickness: 200, type: WallType.Interior };\n\ninterface Cut {\n  t: number;\n  nodeId: string | null;\n  /** Set while the node does not exist yet because its wall has not been split. */\n  pending?: { wallId: string; s: number };\n}\n\n/**\n * Adds a wall from `a` to `b`, splitting anything it crosses so the graph stays planar.\n *\n * Collect-then-apply, in two phases: the naive version splits walls while iterating\n * over walls, which both invalidates the iteration and reparameterises the very\n * segments it is about to test.\n */\nexport function addWall(\n  floor: PlanFloor,\n  a: PlanPoint,\n  b: PlanPoint,\n  attrs: WallAttrs = DEFAULT_WALL_ATTRS,\n  tol: number = EPS_COINCIDENT,\n): PlanEdit<{ wallIds: string[]; nodeIds: string[] }> {\n  const issues: PlanIssue[] = [];\n  if (dist(a, b) < MIN_WALL_LENGTH) {\n    return { floor, result: { wallIds: [], nodeIds: [] }, issues };\n  }\n\n  // 1. Endpoints. Each may reuse a node, split a wall, or create a node.\n  const startEdit = resolveNodeAt(floor, a, tol);\n  let work = startEdit.floor;\n  issues.push(...startEdit.issues);\n  const endEdit = resolveNodeAt(work, b, tol);\n  work = endEdit.floor;\n  issues.push(...endEdit.issues);\n\n  const na = startEdit.result.nodeId;\n  const nb = endEdit.result.nodeId;\n  if (na === nb) return { floor, result: { wallIds: [], nodeIds: [] }, issues };\n\n  const A = work.nodes[na];\n  const B = work.nodes[nb];\n  const len = dist(A, B);\n  if (len < MIN_WALL_LENGTH) return { floor, result: { wallIds: [], nodeIds: [] }, issues };\n\n  // 2. COLLECT. Nothing is mutated in this phase.\n  const cuts: Cut[] = [\n    { t: 0, nodeId: na },\n    { t: 1, nodeId: nb },\n  ];\n  const splits = new Map<string, number[]>();\n  const overlaps: Array<[number, number]> = [];\n\n  const paramAlong = (p: PlanPoint): number => pointToSegment(p, A, B).t;\n\n  for (const wall of Object.values(work.walls)) {\n    const wa = work.nodes[wall.a];\n    const wb = work.nodes[wall.b];\n    if (!wa || !wb) continue;\n\n    const hit = segmentIntersection(A, B, wa, wb, tol);\n\n    if (hit.kind === 'collinearOverlap') {\n      const t0 = paramAlong(wa);\n      const t1 = paramAlong(wb);\n      overlaps.push([Math.min(t0, t1), Math.max(t0, t1)]);\n      // Endpoints of the overlapping wall that fall strictly inside AB still need cuts,\n      // or the new wall would run straight past them.\n      for (const [node, t] of [\n        [wa, t0],\n        [wb, t1],\n      ] as const) {\n        if (t * len > MIN_WALL_LENGTH && (1 - t) * len > MIN_WALL_LENGTH) {\n          cuts.push({ t, nodeId: node.id });\n        }\n      }\n      continue;\n    }\n\n    if (hit.kind === 'proper' && hit.t !== undefined && hit.s !== undefined) {\n      const list = splits.get(wall.id);\n      if (list) list.push(hit.s);\n      else splits.set(wall.id, [hit.s]);\n      cuts.push({ t: hit.t, nodeId: null, pending: { wallId: wall.id, s: hit.s } });\n      continue;\n    }\n\n    if (hit.kind === 'touch' && hit.t !== undefined && hit.s !== undefined) {\n      // A T junction where one of the wall's own endpoints sits on AB: reuse it.\n      const atWallStart = hit.s <= 0.5;\n      const endpoint = atWallStart ? wa : wb;\n      const tOnAb = paramAlong(endpoint);\n      if (\n        pointToSegment(endpoint, A, B).dist <= tol &&\n        tOnAb * len > MIN_WALL_LENGTH &&\n        (1 - tOnAb) * len > MIN_WALL_LENGTH\n      ) {\n        cuts.push({ t: tOnAb, nodeId: endpoint.id });\n      }\n    }\n  }\n\n  // 3. Nodes lying on AB that no crossing test found. NOT redundant with step 2: a node\n  // whose incident walls all run away from AB is invisible to every crossing test, yet\n  // failing to cut AB there leaves a node on a wall interior, which silently merges the\n  // two rooms either side of it.\n  for (const node of Object.values(work.nodes)) {\n    if (node.id === na || node.id === nb) continue;\n    const r = pointToSegment(node, A, B);\n    if (r.dist > tol) continue;\n    if (r.t * len <= MIN_WALL_LENGTH || (1 - r.t) * len <= MIN_WALL_LENGTH) continue;\n    cuts.push({ t: r.t, nodeId: node.id });\n  }\n\n  // 4. APPLY splits, per wall, in DESCENDING parameter order so that earlier\n  // parameters stay valid as later ones are consumed.\n  for (const [wallId, params] of splits) {\n    const sorted = [...params].sort((x, y) => y - x);\n    let currentWallId = wallId;\n    const remaining = new Set(sorted);\n    for (const s of sorted) {\n      const target = work.walls[currentWallId];\n      if (!target) break;\n      const wa = work.nodes[target.a];\n      const wb = work.nodes[target.b];\n      if (!wa || !wb) break;\n      // Re-project onto the wall as it stands now, rather than reusing the original\n      // parameter, which the previous split may have reparameterised.\n      const original = floor.walls[wallId];\n      const oa = work.nodes[original?.a ?? target.a] ?? wa;\n      const ob = work.nodes[original?.b ?? target.b] ?? wb;\n      const worldPoint = { x: oa.x + (ob.x - oa.x) * s, y: oa.y + (ob.y - oa.y) * s };\n      const edit = splitWall(work, currentWallId, worldPoint);\n      work = edit.floor;\n      issues.push(...edit.issues);\n      remaining.delete(s);\n      for (const cut of cuts) {\n        if (cut.pending && cut.pending.wallId === wallId && cut.pending.s === s) {\n          cut.nodeId = edit.result.nodeId;\n          cut.pending = undefined;\n        }\n      }\n      // Continue splitting whichever child still holds the remaining parameters.\n      if (edit.result.wallIds) {\n        const [first, second] = edit.result.wallIds;\n        const nextS = Math.max(...[...remaining], -1);\n        currentWallId = nextS >= 0 && nextS > s ? second : first;\n      }\n    }\n  }\n\n  // 5. Chain the cuts into walls.\n  const resolved = cuts.filter((c): c is Cut & { nodeId: string } => Boolean(c.nodeId));\n  resolved.sort((x, y) => x.t - y.t);\n\n  const chain: Array<Cut & { nodeId: string }> = [];\n  for (const cut of resolved) {\n    const last = chain[chain.length - 1];\n    if (!last) {\n      chain.push(cut);\n      continue;\n    }\n    if (last.nodeId === cut.nodeId) continue;\n    if ((cut.t - last.t) * len < MIN_WALL_LENGTH) {\n      // Too close to be a separate wall. Prefer whichever end is an endpoint of AB.\n      if (cut.t >= 1 - 1e-9) chain[chain.length - 1] = cut;\n      continue;\n    }\n    chain.push(cut);\n  }\n\n  const createdWallIds: string[] = [];\n  for (let i = 0; i + 1 < chain.length; i++) {\n    const from = chain[i];\n    const to = chain[i + 1];\n    const midT = (from.t + to.t) / 2;\n    if (overlaps.some(([lo, hi]) => midT > lo + 1e-9 && midT < hi - 1e-9)) {\n      // Already walled. Do not create a duplicate, and do not rewrite the existing\n      // wall's attributes from a stroke that was aimed elsewhere.\n      continue;\n    }\n    if (findWallBetween(work, from.nodeId, to.nodeId)) continue;\n    const wa = work.nodes[from.nodeId];\n    const wb = work.nodes[to.nodeId];\n    if (!wa || !wb || dist(wa, wb) < MIN_WALL_LENGTH) continue;\n\n    const id = newId('w');\n    work = { ...work, walls: { ...work.walls, [id]: { ...attrs, id, a: from.nodeId, b: to.nodeId } } };\n    createdWallIds.push(id);\n  }\n\n  if (createdWallIds.length === 0 && overlaps.length > 0) {\n    issues.push(issue(PlanIssueKind.DuplicateWall, 'A wall already covers that span, so nothing was added.'));\n  }\n\n  return {\n    floor: work,\n    result: { wallIds: createdWallIds, nodeIds: chain.map((c) => c.nodeId) },\n    issues,\n  };\n}\n\n/** Draws the four walls of an axis-aligned rectangle, welding onto anything already there. */\nexport function addRect(\n  floor: PlanFloor,\n  corner: PlanPoint,\n  opposite: PlanPoint,\n  attrs: WallAttrs = DEFAULT_WALL_ATTRS,\n  tol: number = EPS_COINCIDENT,\n): PlanEdit<{ wallIds: string[] }> {\n  const x0 = Math.min(corner.x, opposite.x);\n  const x1 = Math.max(corner.x, opposite.x);\n  const y0 = Math.min(corner.y, opposite.y);\n  const y1 = Math.max(corner.y, opposite.y);\n  if (x1 - x0 < MIN_WALL_LENGTH || y1 - y0 < MIN_WALL_LENGTH) {\n    return { floor, result: { wallIds: [] }, issues: [] };\n  }\n\n  const corners: PlanPoint[] = [\n    { x: x0, y: y0 },\n    { x: x1, y: y0 },\n    { x: x1, y: y1 },\n    { x: x0, y: y1 },\n  ];\n\n  let work = floor;\n  const wallIds: string[] = [];\n  const issues: PlanIssue[] = [];\n  for (let i = 0; i < 4; i++) {\n    const edit = addWall(work, corners[i], corners[(i + 1) % 4], attrs, tol);\n    work = edit.floor;\n    wallIds.push(...edit.result.wallIds);\n    issues.push(...edit.issues);\n  }\n  return { floor: work, result: { wallIds }, issues };\n}\n\n// ─── mergeNodes ────────────────────────────────────────────────────────────────\n\n/**\n * Merges `removeId` into `keepId`, as when a node is dragged onto another.\n *\n * Order matters, and step 3 is mandatory rather than cosmetic: a duplicate wall between\n * the same pair of nodes is exactly the identical-angle degeneracy that corrupts the\n * face walk's angular sort.\n */\nexport function mergeNodes(floor: PlanFloor, keepId: string, removeId: string): PlanEdit<{ removedWallIds: string[] }> {\n  if (keepId === removeId || !floor.nodes[keepId] || !floor.nodes[removeId]) {\n    return { floor, result: { removedWallIds: [] }, issues: [] };\n  }\n\n  const next = cloneFloor(floor);\n  const removedWallIds: string[] = [];\n  const issues: PlanIssue[] = [];\n\n  // 1. Rewire.\n  for (const wall of Object.values(next.walls)) {\n    if (wall.a === removeId) next.walls[wall.id] = { ...next.walls[wall.id], a: keepId };\n    if (wall.b === removeId) next.walls[wall.id] = { ...next.walls[wall.id], b: keepId };\n  }\n\n  // 2. Drop self-loops, and their openings with them.\n  for (const wall of Object.values(next.walls)) {\n    if (wall.a !== wall.b) continue;\n    delete next.walls[wall.id];\n    removedWallIds.push(wall.id);\n    for (const opening of Object.values(next.openings)) {\n      if (opening.wallId === wall.id) delete next.openings[opening.id];\n    }\n  }\n\n  // 3. Deduplicate walls that now share the same unordered node pair.\n  const seen = new Map<string, PlanWall>();\n  for (const wall of Object.values(next.walls)) {\n    const key = wall.a < wall.b ? `${wall.a}|${wall.b}` : `${wall.b}|${wall.a}`;\n    const prior = seen.get(key);\n    if (!prior) {\n      seen.set(key, wall);\n      continue;\n    }\n    // Keep the thicker wall, and carry both walls' openings onto it.\n    const keep = wall.thickness >= prior.thickness ? wall : prior;\n    const drop = keep === wall ? prior : wall;\n    for (const opening of Object.values(next.openings)) {\n      if (opening.wallId === drop.id) {\n        next.openings[opening.id] = { ...opening, wallId: keep.id };\n      }\n    }\n    delete next.walls[drop.id];\n    removedWallIds.push(drop.id);\n    seen.set(key, keep);\n    issues.push(\n      issue(PlanIssueKind.DuplicateWall, 'Two walls became the same wall and were merged.', {\n        wallIds: [keep.id, drop.id],\n      }),\n    );\n  }\n\n  // 4. Drop the now-unreferenced node.\n  delete next.nodes[removeId];\n\n  return { floor: next, result: { removedWallIds }, issues };\n}\n\n// ─── dissolveNode ──────────────────────────────────────────────────────────────\n\nexport interface DissolveNodeOptions {\n  /**\n   * Rejoin the two walls even when the corner is bent or the walls differ in\n   * construction, taking the thicker wall's attributes and rescaling openings onto the\n   * shorter merged wall.\n   *\n   * This is \"delete this corner\" as a user means it. The default, unforced behaviour is\n   * the stricter one used by cleanup and by `removeWall`, where dissolving must not\n   * change the drawing's geometry at all.\n   */\n  force?: boolean;\n}\n\n/**\n * Merges the two walls meeting at a degree-2 node back into one, the natural inverse of\n * `splitWall`.\n *\n * Returns `null` unless the node is genuinely a seam: degree exactly 2, both walls\n * identical in construction, and the turn within `EPS_ANGLE` of straight. Pass\n * `{ force: true }` to rejoin a bent corner as well. Never call it mid-drag: it destroys\n * node ids the user may be holding.\n */\nexport function dissolveNode(\n  floor: PlanFloor,\n  nodeId: string,\n  options: DissolveNodeOptions = {},\n): PlanEdit<{ wallId: string } | null> {\n  const { force = false } = options;\n  const node = floor.nodes[nodeId];\n  if (!node) return { floor, result: null, issues: [] };\n\n  const incident = wallsAtNode(floor, nodeId);\n  if (incident.length !== 2) return { floor, result: null, issues: [] };\n\n  const [w1, w2] = incident;\n  const sameConstruction =\n    w1.thickness === w2.thickness && w1.type === w2.type && w1.height === w2.height && w1.baseHeight === w2.baseHeight;\n  if (!sameConstruction && !force) return { floor, result: null, issues: [] };\n\n  const far1 = w1.a === nodeId ? w1.b : w1.a;\n  const far2 = w2.a === nodeId ? w2.b : w2.a;\n  if (far1 === far2) return { floor, result: null, issues: [] };\n\n  const p1 = floor.nodes[far1];\n  const p2 = floor.nodes[far2];\n  if (!p1 || !p2) return { floor, result: null, issues: [] };\n\n  const span = dist(p1, p2);\n  if (span < MIN_WALL_LENGTH) return { floor, result: null, issues: [] };\n\n  if (!force) {\n    // Straightness by perpendicular offset rather than raw angle, so the tolerance stays\n    // meaningful at any wall length.\n    const offset = Math.abs(cross(p1, p2, node)) / span;\n    if (offset > Math.max(EPS_COINCIDENT, span * EPS_ANGLE)) {\n      return { floor, result: null, issues: [] };\n    }\n  }\n\n  // Forced over a bent corner, the survivor is the thicker of the two, since that is the\n  // one whose construction the rest of the plan is more likely to depend on.\n  const keep = !sameConstruction && w1.thickness < w2.thickness ? w2 : w1;\n\n  const next = cloneFloor(floor);\n  const id = newId('w');\n  next.walls[id] = {\n    id,\n    a: far1,\n    b: far2,\n    thickness: keep.thickness,\n    type: keep.type,\n    height: keep.height,\n    baseHeight: keep.baseHeight,\n  };\n\n  // Re-express every opening's offset against the merged wall's direction (far1 -> far2).\n  const len1 = dist(p1, node);\n  const len2 = dist(node, p2);\n  // Cutting a bent corner shortens the run, so positions are scaled along it rather than\n  // carried over, which would push an opening off the end of its own wall.\n  const scale = len1 + len2 > 0 ? span / (len1 + len2) : 1;\n  const issues: PlanIssue[] = [];\n\n  for (const opening of Object.values(floor.openings)) {\n    if (opening.wallId !== w1.id && opening.wallId !== w2.id) continue;\n    const onFirst = opening.wallId === w1.id;\n    const wall = onFirst ? w1 : w2;\n    const startsAtNode = wall.a === nodeId;\n    const lenOfWall = wallLength(floor, wall);\n    // Distance from the seam, then from the merged wall's own start.\n    const fromSeam = startsAtNode ? opening.offset : lenOfWall - opening.offset;\n    const alongOriginal = onFirst ? len1 - fromSeam : len1 + fromSeam;\n    const offsetOnMerged = alongOriginal * scale;\n\n    const width = Math.min(opening.width * scale, span - 2);\n    if (width < MIN_OPENING_WIDTH) {\n      issues.push(\n        issue(PlanIssueKind.OpeningDropped, 'An opening was removed: the wall it sat on became too short for it.', {\n          openingIds: [opening.id],\n          wallIds: [wall.id],\n        }),\n      );\n      delete next.openings[opening.id];\n      continue;\n    }\n\n    next.openings[opening.id] = {\n      ...opening,\n      wallId: id,\n      width,\n      offset: Math.min(Math.max(offsetOnMerged, width / 2), span - width / 2),\n    };\n  }\n\n  delete next.walls[w1.id];\n  delete next.walls[w2.id];\n  delete next.nodes[nodeId];\n\n  return { floor: next, result: { wallId: id }, issues };\n}\n\n// ─── detachWall ────────────────────────────────────────────────────────────────\n\nexport interface DetachWallResult {\n  /** The wall's end nodes after the detach, in `[a, b]` order. */\n  nodeIds: [string, string];\n  /** Connecting walls minted where an end was shared with a neighbour. */\n  connectorIds: string[];\n  /** Ends that became a straight seam once the wall left, and were dissolved away. */\n  dissolvedNodeIds: string[];\n}\n\n/**\n * Pulls a wall off the nodes it shares with its neighbours and moves it by `delta`,\n * leaving a connecting wall behind at each end that was shared.\n *\n * This is the extrude half of dragging a wall. A plain drag moves the shared end nodes,\n * so everything meeting the wall follows it; here the neighbours keep their ends and\n * only the new connectors grow, which is what you want when a partition joins the wall\n * halfway along and should stay put.\n *\n * A free end is only moved: there is nothing there to detach from, and a connector would\n * be zero length. For the same reason `delta` must be at least `MIN_WALL_LENGTH` long —\n * below that the caller should `moveNode` both ends instead.\n *\n * The connector continues whatever was already at the corner (its thickness, type and\n * heights) when exactly one wall was, so pulling a wall off a plain corner redraws\n * exactly as a plain drag would: the seam that leaves behind is straight and is\n * dissolved before returning. At a junction there is no single wall to continue, so the\n * connector takes the dragged wall's own construction.\n */\nexport function detachWall(floor: PlanFloor, wallId: string, delta: PlanPoint): PlanEdit<DetachWallResult | null> {\n  const wall = floor.walls[wallId];\n  if (!wall || wall.a === wall.b) return { floor, result: null, issues: [] };\n  if (Math.hypot(delta.x, delta.y) < MIN_WALL_LENGTH) return { floor, result: null, issues: [] };\n\n  const ends: [string, string] = [wall.a, wall.b];\n  const nodeIds: [string, string] = [wall.a, wall.b];\n  const sources: (PlanWall | null)[] = [null, null];\n  const connectorIds: string[] = [];\n  const issues: PlanIssue[] = [];\n  let out = floor;\n\n  // 1. Give the wall its own ends. `resolveNodeAt` rather than a bare node, because the\n  //    new end often lands in the middle of another wall — the usual case is pushing the\n  //    shared wall of two rooms sideways, where each end slides along the wall above and\n  //    below it — and only a split keeps a node off a wall's interior.\n  ends.forEach((nodeId, index) => {\n    const origin = floor.nodes[nodeId];\n    if (!origin) return;\n    const to = { x: origin.x + delta.x, y: origin.y + delta.y };\n    const others = wallsAtNode(floor, nodeId).filter((w) => w.id !== wallId);\n\n    if (others.length === 0) {\n      // A free end has nothing to detach from, and a connector there would be a wall\n      // between a node and itself.\n      const next = cloneFloor(out);\n      next.nodes[nodeId] = { ...next.nodes[nodeId], x: to.x, y: to.y };\n      out = next;\n      return;\n    }\n\n    const edit = resolveNodeAt(out, to, EPS_COINCIDENT);\n    out = edit.floor;\n    nodeIds[index] = edit.result.nodeId;\n    // The connector continues whatever was already at this corner, so pulling a wall off\n    // a plain corner redraws exactly as a plain drag would. At a junction there is no\n    // single wall to continue, so it takes the dragged wall's own construction.\n    sources[index] = others.length === 1 ? others[0] : wall;\n  });\n\n  // 2. Move the wall onto them. Its openings ride along untouched: a detach is a pure\n  //    translation, so the wall keeps its id, its direction and its length.\n  const moved = cloneFloor(out);\n  moved.walls[wallId] = { ...moved.walls[wallId], a: nodeIds[0], b: nodeIds[1] };\n  out = moved;\n\n  // 3. Bridge each end back to where it came from, unless a wall already runs there.\n  ends.forEach((nodeId, index) => {\n    const source = sources[index];\n    const from = out.nodes[nodeId];\n    const to = out.nodes[nodeIds[index]];\n    if (!source || !from || !to) return;\n    const edit = addWall(out, from, to, {\n      thickness: source.thickness,\n      type: source.type,\n      height: source.height,\n      baseHeight: source.baseHeight,\n    });\n    out = edit.floor;\n    connectorIds.push(...edit.result.wallIds);\n    issues.push(...edit.issues);\n  });\n\n  // 4. An end that was a plain corner is now a straight seam. Dissolving it is what\n  //    makes detaching a wall with nothing attached to it a no-op on the drawing.\n  const dissolvedNodeIds: string[] = [];\n  ends.forEach((nodeId, index) => {\n    if (nodeIds[index] === nodeId) return;\n    const edit = dissolveNode(out, nodeId);\n    if (!edit.result) return;\n    out = edit.floor;\n    dissolvedNodeIds.push(nodeId);\n    issues.push(...edit.issues);\n  });\n\n  return { floor: out, result: { nodeIds, connectorIds, dissolvedNodeIds }, issues };\n}\n\n// ─── weldShortWalls ────────────────────────────────────────────────────────────\n\n/**\n * Collapses every wall shorter than `minLength` by merging its two ends together.\n *\n * Squashing a wall to nothing is the one thing a drag can do that the model forbids, and\n * it is easy to do by accident: pushing a wall back onto the line it was detached from,\n * or dragging a corner past the one next to it. Deleting the short wall is the wrong\n * repair — it leaves two nodes sitting on the same point with the plan split between\n * them, which reads as two corners stacked on top of each other and derives as two\n * rooms. Merging is lossless, since the two ends are within `minLength` of each other by\n * definition.\n *\n * The end with more walls on it survives, so the corner that was already there keeps its\n * position and the one that arrived is the one that gives way.\n */\nexport function weldShortWalls(\n  floor: PlanFloor,\n  minLength: number = MIN_WALL_LENGTH,\n): PlanEdit<{ weldedWallIds: string[] }> {\n  let out = floor;\n  const weldedWallIds: string[] = [];\n  const issues: PlanIssue[] = [];\n\n  // Re-scan rather than iterate: one weld moves nodes, so it can shorten another wall to\n  // nothing in turn. Bounded by the wall count, since every pass removes at least one.\n  for (let guard = Object.keys(floor.walls).length; guard > 0; guard--) {\n    const short = Object.values(out.walls).find((w) => {\n      if (w.a === w.b) return false;\n      const a = out.nodes[w.a];\n      const b = out.nodes[w.b];\n      return a && b && dist(a, b) < minLength;\n    });\n    if (!short) break;\n\n    const keep = wallsAtNode(out, short.b).length > wallsAtNode(out, short.a).length ? short.b : short.a;\n    const edit = mergeNodes(out, keep, keep === short.a ? short.b : short.a);\n    if (edit.floor === out) break;\n    out = edit.floor;\n    weldedWallIds.push(short.id);\n    issues.push(...edit.issues);\n  }\n\n  return { floor: out, result: { weldedWallIds }, issues };\n}\n\n// ─── removeWall / moveNode ─────────────────────────────────────────────────────\n\nexport function removeWall(\n  floor: PlanFloor,\n  wallId: string,\n  opts: { pruneOrphanNodes?: boolean; dissolveCollinear?: boolean } = {},\n): PlanEdit<{ removedNodeIds: string[]; dissolvedWallIds: string[] }> {\n  const { pruneOrphanNodes = true, dissolveCollinear = true } = opts;\n  const wall = floor.walls[wallId];\n  if (!wall) return { floor, result: { removedNodeIds: [], dissolvedWallIds: [] }, issues: [] };\n\n  let next = cloneFloor(floor);\n  delete next.walls[wallId];\n  for (const opening of Object.values(next.openings)) {\n    if (opening.wallId === wallId) delete next.openings[opening.id];\n  }\n\n  const removedNodeIds: string[] = [];\n  const dissolvedWallIds: string[] = [];\n  const issues: PlanIssue[] = [];\n\n  for (const endpoint of [wall.a, wall.b]) {\n    const degree = wallsAtNode(next, endpoint).length;\n    if (degree === 0 && pruneOrphanNodes) {\n      delete next.nodes[endpoint];\n      removedNodeIds.push(endpoint);\n    } else if (degree === 2 && dissolveCollinear) {\n      // The natural inverse of the split that created this seam.\n      const edit = dissolveNode(next, endpoint);\n      if (edit.result) {\n        next = edit.floor;\n        dissolvedWallIds.push(edit.result.wallId);\n        removedNodeIds.push(endpoint);\n        issues.push(...edit.issues);\n      }\n    }\n  }\n\n  return { floor: next, result: { removedNodeIds, dissolvedWallIds }, issues };\n}\n\nexport function moveNode(floor: PlanFloor, nodeId: string, to: PlanPoint): PlanEdit {\n  const node = floor.nodes[nodeId];\n  if (!node) return { floor, result: undefined, issues: [] };\n  const next = cloneFloor(floor);\n  next.nodes[nodeId] = { ...node, x: to.x, y: to.y };\n  return { floor: next, result: undefined, issues: [] };\n}\n\n/**\n * Translates every node, and every room anchor with it.\n *\n * Room matching does not depend on this (it is primarily wall-id based), but a plan\n * that is dragged and then saved without a derive should still have sane anchors.\n */\nexport function transformPlan(floor: PlanFloor, dx: number, dy: number): PlanFloor {\n  const next = cloneFloor(floor);\n  for (const node of Object.values(floor.nodes)) {\n    next.nodes[node.id] = { ...node, x: node.x + dx, y: node.y + dy };\n  }\n  for (const room of Object.values(floor.rooms)) {\n    next.rooms[room.id] = { ...room, anchor: { x: room.anchor.x + dx, y: room.anchor.y + dy } };\n  }\n  return next;\n}\n\n/**\n * Multiplies every coordinate and dimension by `factor`.\n *\n * The one place a scale factor belongs: converting a unitless legacy plan into the\n * module's millimetre invariant, once, at the import boundary. The caller picks the\n * factor, because nothing in the old data says what it should be.\n */\nexport function scalePlan(floor: PlanFloor, factor: number): PlanFloor {\n  const next = cloneFloor(floor);\n  for (const node of Object.values(floor.nodes)) {\n    next.nodes[node.id] = { ...node, x: node.x * factor, y: node.y * factor };\n  }\n  for (const wall of Object.values(floor.walls)) {\n    next.walls[wall.id] = {\n      ...wall,\n      thickness: wall.thickness * factor,\n      height: wall.height === undefined ? undefined : wall.height * factor,\n      baseHeight: wall.baseHeight === undefined ? undefined : wall.baseHeight * factor,\n    };\n  }\n  for (const opening of Object.values(floor.openings)) {\n    next.openings[opening.id] = {\n      ...opening,\n      offset: opening.offset * factor,\n      width: opening.width * factor,\n      sill: opening.sill * factor,\n      head: opening.head * factor,\n    };\n  }\n  for (const room of Object.values(floor.rooms)) {\n    next.rooms[room.id] = {\n      ...room,\n      anchor: { x: room.anchor.x * factor, y: room.anchor.y * factor },\n      area: room.area * factor * factor,\n    };\n  }\n  return next;\n}\n\n// ─── Openings ──────────────────────────────────────────────────────────────────\n\nexport function addOpening(floor: PlanFloor, opening: Omit<PlanOpening, 'id'>): PlanEdit<{ openingId: string | null }> {\n  const wall = floor.walls[opening.wallId];\n  if (!wall) return { floor, result: { openingId: null }, issues: [] };\n\n  const len = wallLength(floor, wall);\n  const width = Math.min(opening.width, len - 2);\n  if (width < MIN_OPENING_WIDTH) {\n    return {\n      floor,\n      result: { openingId: null },\n      issues: [\n        issue(PlanIssueKind.OpeningDropped, 'That wall is too short for an opening.', {\n          wallIds: [wall.id],\n        }),\n      ],\n    };\n  }\n\n  const offset = Math.min(Math.max(opening.offset, width / 2), len - width / 2);\n  const next = cloneFloor(floor);\n  const id = newId('o');\n  next.openings[id] = { ...opening, id, offset, width };\n  return { floor: next, result: { openingId: id }, issues: [] };\n}\n\nexport function updateOpening(\n  floor: PlanFloor,\n  openingId: string,\n  patch: Partial<Omit<PlanOpening, 'id' | 'wallId'>>,\n): PlanEdit {\n  const opening = floor.openings[openingId];\n  if (!opening) return { floor, result: undefined, issues: [] };\n  const wall = floor.walls[opening.wallId];\n  if (!wall) return { floor, result: undefined, issues: [] };\n\n  const len = wallLength(floor, wall);\n  const merged = { ...opening, ...patch };\n  const width = Math.min(Math.max(merged.width, MIN_OPENING_WIDTH), Math.max(len - 2, MIN_OPENING_WIDTH));\n  const offset = Math.min(Math.max(merged.offset, width / 2), Math.max(len - width / 2, width / 2));\n\n  const next = cloneFloor(floor);\n  next.openings[openingId] = { ...merged, width, offset };\n  return { floor: next, result: undefined, issues: [] };\n}\n\nexport function removeOpening(floor: PlanFloor, openingId: string): PlanEdit {\n  if (!floor.openings[openingId]) return { floor, result: undefined, issues: [] };\n  const next = cloneFloor(floor);\n  delete next.openings[openingId];\n  return { floor: next, result: undefined, issues: [] };\n}\n\n// ─── Validation and cleanup ────────────────────────────────────────────────────\n\n/**\n * Reports every way the graph currently violates the planar invariant.\n *\n * O(W²), so run it in tests and in development, not on every keystroke.\n */\nexport function validatePlan(floor: PlanFloor): PlanIssue[] {\n  const issues: PlanIssue[] = [];\n  const walls = Object.values(floor.walls);\n\n  for (const wall of walls) {\n    const a = floor.nodes[wall.a];\n    const b = floor.nodes[wall.b];\n    if (wall.a === wall.b) {\n      issues.push(\n        issue(PlanIssueKind.SelfLoopWall, 'A wall starts and ends at the same node.', { wallIds: [wall.id] }),\n      );\n      continue;\n    }\n    if (!a || !b) {\n      issues.push(issue(PlanIssueKind.ZeroLengthWall, 'A wall references a missing node.', { wallIds: [wall.id] }));\n      continue;\n    }\n    if (dist(a, b) < MIN_WALL_LENGTH) {\n      issues.push(\n        issue(PlanIssueKind.ZeroLengthWall, 'A wall is shorter than the minimum length.', { wallIds: [wall.id] }),\n      );\n    }\n  }\n\n  const pairSeen = new Map<string, string>();\n  for (const wall of walls) {\n    const key = wall.a < wall.b ? `${wall.a}|${wall.b}` : `${wall.b}|${wall.a}`;\n    const prior = pairSeen.get(key);\n    if (prior) {\n      issues.push(\n        issue(PlanIssueKind.DuplicateWall, 'Two walls connect the same pair of nodes.', {\n          wallIds: [prior, wall.id],\n        }),\n      );\n    } else {\n      pairSeen.set(key, wall.id);\n    }\n  }\n\n  const nodes = Object.values(floor.nodes);\n  for (let i = 0; i < nodes.length; i++) {\n    for (let j = i + 1; j < nodes.length; j++) {\n      if (dist(nodes[i], nodes[j]) < EPS_COINCIDENT) {\n        issues.push(\n          issue(PlanIssueKind.CoincidentNodes, 'Two nodes occupy the same position.', {\n            nodeIds: [nodes[i].id, nodes[j].id],\n          }),\n        );\n      }\n    }\n  }\n\n  for (let i = 0; i < walls.length; i++) {\n    for (let j = i + 1; j < walls.length; j++) {\n      const w1 = walls[i];\n      const w2 = walls[j];\n      const a = floor.nodes[w1.a];\n      const b = floor.nodes[w1.b];\n      const c = floor.nodes[w2.a];\n      const d = floor.nodes[w2.b];\n      if (!a || !b || !c || !d) continue;\n      const hit = segmentIntersection(a, b, c, d);\n      if (hit.kind === 'proper') {\n        issues.push(\n          issue(PlanIssueKind.UnsplitCrossing, 'Two walls cross with no node at the intersection.', {\n            wallIds: [w1.id, w2.id],\n          }),\n        );\n      } else if (hit.kind === 'collinearOverlap') {\n        issues.push(\n          issue(PlanIssueKind.OverlappingWalls, 'Two walls overlap along the same line.', {\n            wallIds: [w1.id, w2.id],\n          }),\n        );\n      }\n    }\n  }\n\n  for (const wall of walls) {\n    const a = floor.nodes[wall.a];\n    const b = floor.nodes[wall.b];\n    if (!a || !b) continue;\n    for (const node of nodes) {\n      if (node.id === wall.a || node.id === wall.b) continue;\n      const r = pointToSegment(node, a, b);\n      if (r.dist < EPS_COINCIDENT && r.t > 0 && r.t < 1) {\n        issues.push(\n          issue(PlanIssueKind.UnsplitNodeOnWall, 'A node sits on a wall that was never split there.', {\n            wallIds: [wall.id],\n            nodeIds: [node.id],\n          }),\n        );\n      }\n    }\n  }\n\n  for (const opening of Object.values(floor.openings)) {\n    if (!floor.walls[opening.wallId]) {\n      issues.push(\n        issue(PlanIssueKind.DanglingOpening, 'An opening references a wall that no longer exists.', {\n          openingIds: [opening.id],\n        }),\n      );\n    }\n  }\n\n  const referenced = new Set<string>();\n  for (const wall of walls) {\n    referenced.add(wall.a);\n    referenced.add(wall.b);\n  }\n  for (const node of nodes) {\n    if (!referenced.has(node.id)) {\n      issues.push(issue(PlanIssueKind.OrphanNode, 'A node has no walls.', { nodeIds: [node.id] }));\n    }\n  }\n\n  return issues;\n}\n\n/**\n * Removes what validation can safely remove: degenerate walls, orphan nodes, dangling\n * openings, and duplicate walls. Idempotent.\n *\n * Deliberately does not touch unsplit crossings: fixing one changes the room structure,\n * which is the user's call, not a cleanup pass's.\n */\nexport function cleanupPlan(floor: PlanFloor): PlanEdit<PlanIssue[]> {\n  const fixed: PlanIssue[] = [];\n\n  // Welding comes first, and is why the sweep below only ever sees walls that are\n  // degenerate for some other reason: a wall squashed to nothing has two perfectly good\n  // ends, and deleting it would leave them stacked on the same point.\n  const welded = weldShortWalls(floor);\n  const next = cloneFloor(welded.floor);\n  for (const wallId of welded.result.weldedWallIds) {\n    fixed.push(\n      issue(PlanIssueKind.ZeroLengthWall, 'Welded the two ends of a wall with no length.', {\n        wallIds: [wallId],\n      }),\n    );\n  }\n\n  for (const wall of Object.values(next.walls)) {\n    const a = next.nodes[wall.a];\n    const b = next.nodes[wall.b];\n    if (wall.a === wall.b || !a || !b || dist(a, b) < MIN_WALL_LENGTH) {\n      delete next.walls[wall.id];\n      fixed.push(issue(PlanIssueKind.ZeroLengthWall, 'Removed a degenerate wall.', { wallIds: [wall.id] }));\n    }\n  }\n\n  const pairSeen = new Map<string, PlanWall>();\n  for (const wall of Object.values(next.walls)) {\n    const key = wall.a < wall.b ? `${wall.a}|${wall.b}` : `${wall.b}|${wall.a}`;\n    const prior = pairSeen.get(key);\n    if (!prior) {\n      pairSeen.set(key, wall);\n      continue;\n    }\n    const keep = wall.thickness >= prior.thickness ? wall : prior;\n    const drop = keep === wall ? prior : wall;\n    for (const opening of Object.values(next.openings)) {\n      if (opening.wallId === drop.id) next.openings[opening.id] = { ...opening, wallId: keep.id };\n    }\n    delete next.walls[drop.id];\n    pairSeen.set(key, keep);\n    fixed.push(issue(PlanIssueKind.DuplicateWall, 'Removed a duplicate wall.', { wallIds: [drop.id] }));\n  }\n\n  for (const opening of Object.values(next.openings)) {\n    if (!next.walls[opening.wallId]) {\n      delete next.openings[opening.id];\n      fixed.push(\n        issue(PlanIssueKind.DanglingOpening, 'Removed an opening with no wall.', {\n          openingIds: [opening.id],\n        }),\n      );\n    }\n  }\n\n  // One pass to count degrees, rather than scanning every wall per node: the naive form\n  // is O(nodes x walls), which is the dominant cost on a large plan.\n  const referenced = new Set<string>();\n  for (const wall of Object.values(next.walls)) {\n    referenced.add(wall.a);\n    referenced.add(wall.b);\n  }\n  for (const node of Object.values(next.nodes)) {\n    if (!referenced.has(node.id)) {\n      delete next.nodes[node.id];\n      fixed.push(issue(PlanIssueKind.OrphanNode, 'Removed a node with no walls.', { nodeIds: [node.id] }));\n    }\n  }\n\n  return { floor: next, result: fixed, issues: fixed };\n}\n\nexport { wallLength, wallsAtNode, findWallBetween };\n"],"mappings":"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"}

package/dist/esm/common/floorPlan/floorPlan.hit.mjs

@@ -1,2 +1,2 @@
-import{dist as e,pointToSegment as t}from"./floorPlan.geometry.mjs";import{roomAtPoint as n}from"./floorPlan.rooms.mjs";import{openingGeometry as r}from"./floorPlan.path.mjs";var i={node:10,opening:9,wall:8},a={node:18,opening:16,wall:14};function o(e,t){let n=t>0?t:1;return{node:e.node/n,opening:e.opening/n,wall:e.wall/n}}function s(i,a,o,s,c={}){let l=e=>!c.accept||c.accept.includes(e),u=e=>c.excludeIds?.has(e)??!1;if(l(`node`)){let t=null;for(let n of Object.values(i.nodes)){if(u(n.id))continue;let r=e(o,n);r<=s.node&&(!t||r<t.d)&&(t={id:n.id,d:r})}if(t)return{type:`node`,id:t.id}}if(l(`opening`)){let e=null;for(let n of Object.values(i.openings)){if(u(n.id))continue;let a=r(i,n);if(!a)continue;let c=t(o,a.p1,a.p2).dist;c<=s.opening&&(!e||c<e.d)&&(e={id:n.id,d:c})}if(e)return{type:`opening`,id:e.id}}if(l(`wall`)){let e=null;for(let n of Object.values(i.walls)){if(u(n.id))continue;let r=i.nodes[n.a],a=i.nodes[n.b];if(!r||!a)continue;let c=Math.max(s.wall,n.thickness/2),l=t(o,r,a).dist;l<=c&&(!e||l<e.d)&&(e={id:n.id,d:l})}if(e)return{type:`wall`,id:e.id}}if(l(`room`)){let e=n(a,o);if(e?.roomId&&!u(e.roomId))return{type:`room`,id:e.roomId}}return null}function c(e,t){return e===t?!0:!e||!t?!1:e.type===t.type&&e.id===t.id}export{i as HIT_PX,a as HIT_PX_COARSE,s as hitTest,c as selectionsEqual,o as worldTolerances};
+"use client";import{dist as e,pointToSegment as t}from"./floorPlan.geometry.mjs";import{roomAtPoint as n}from"./floorPlan.rooms.mjs";import{openingGeometry as r}from"./floorPlan.path.mjs";var i={node:10,opening:9,wall:8},a={node:18,opening:16,wall:14};function o(e,t){let n=t>0?t:1;return{node:e.node/n,opening:e.opening/n,wall:e.wall/n}}function s(i,a,o,s,c={}){let l=e=>!c.accept||c.accept.includes(e),u=e=>c.excludeIds?.has(e)??!1;if(l(`node`)){let t=null;for(let n of Object.values(i.nodes)){if(u(n.id))continue;let r=e(o,n);r<=s.node&&(!t||r<t.d)&&(t={id:n.id,d:r})}if(t)return{type:`node`,id:t.id}}if(l(`opening`)){let e=null;for(let n of Object.values(i.openings)){if(u(n.id))continue;let a=r(i,n);if(!a)continue;let c=t(o,a.p1,a.p2).dist;c<=s.opening&&(!e||c<e.d)&&(e={id:n.id,d:c})}if(e)return{type:`opening`,id:e.id}}if(l(`wall`)){let e=null;for(let n of Object.values(i.walls)){if(u(n.id))continue;let r=i.nodes[n.a],a=i.nodes[n.b];if(!r||!a)continue;let c=Math.max(s.wall,n.thickness/2),l=t(o,r,a).dist;l<=c&&(!e||l<e.d)&&(e={id:n.id,d:l})}if(e)return{type:`wall`,id:e.id}}if(l(`room`)){let e=n(a,o);if(e?.roomId&&!u(e.roomId))return{type:`room`,id:e.roomId}}return null}function c(e,t){return e===t?!0:!e||!t?!1:e.type===t.type&&e.id===t.id}export{i as HIT_PX,a as HIT_PX_COARSE,s as hitTest,c as selectionsEqual,o as worldTolerances};
 //# sourceMappingURL=floorPlan.hit.mjs.map

package/dist/esm/common/floorPlan/floorPlan.hit.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"floorPlan.hit.mjs","names":[],"sources":["../../../../package/common/floorPlan/floorPlan.hit.ts"],"sourcesContent":["/**\n * Hit testing against a derived plan.\n *\n * Tolerances arrive in WORLD units and are expected to have been converted from screen\n * pixels by the caller (`HIT_PX / view.zoom`), so a handle stays the same size on screen\n * at any zoom level.\n */\n\nimport { dist, pointToSegment } from './floorPlan.geometry';\nimport { openingGeometry } from './floorPlan.path';\nimport { roomAtPoint } from './floorPlan.rooms';\nimport type { DerivedRoom, PlanFloor, PlanPoint, PlanSelection } from './floorPlan.types';\n\nexport interface HitTolerances {\n  node: number;\n  opening: number;\n  wall: number;\n}\n\n/** Screen-pixel hit radii, divided by `view.zoom` to get world tolerances. */\nexport const HIT_PX: HitTolerances = { node: 10, opening: 9, wall: 8 };\n/** Wider targets for touch, where there is no pixel-accurate pointer. */\nexport const HIT_PX_COARSE: HitTolerances = { node: 18, opening: 16, wall: 14 };\n\nexport function worldTolerances(px: HitTolerances, zoom: number): HitTolerances {\n  const safeZoom = zoom > 0 ? zoom : 1;\n  return { node: px.node / safeZoom, opening: px.opening / safeZoom, wall: px.wall / safeZoom };\n}\n\nexport interface HitTestOptions {\n  /** Restricts what can be hit. Defaults to everything. */\n  accept?: Array<PlanSelection['type']>;\n  excludeIds?: ReadonlySet<string>;\n}\n\n/**\n * Finds what is under `point`, in priority order: node handle, opening, wall, then room\n * fill.\n *\n * The order is what makes editing feel right. A node sits on top of the walls that meet\n * there, and an opening sits on top of the wall it cuts, so the smaller, more specific\n * target always wins over the larger one underneath it.\n */\nexport function hitTest(\n  floor: PlanFloor,\n  rooms: DerivedRoom[],\n  point: PlanPoint,\n  tolerances: HitTolerances,\n  options: HitTestOptions = {},\n): PlanSelection | null {\n  const accepts = (type: PlanSelection['type']) => !options.accept || options.accept.includes(type);\n  const excluded = (id: string) => options.excludeIds?.has(id) ?? false;\n\n  if (accepts('node')) {\n    let best: { id: string; d: number } | null = null;\n    for (const node of Object.values(floor.nodes)) {\n      if (excluded(node.id)) continue;\n      const d = dist(point, node);\n      if (d <= tolerances.node && (!best || d < best.d)) best = { id: node.id, d };\n    }\n    if (best) return { type: 'node', id: best.id };\n  }\n\n  if (accepts('opening')) {\n    let best: { id: string; d: number } | null = null;\n    for (const opening of Object.values(floor.openings)) {\n      if (excluded(opening.id)) continue;\n      const geo = openingGeometry(floor, opening);\n      if (!geo) continue;\n      const d = pointToSegment(point, geo.p1, geo.p2).dist;\n      if (d <= tolerances.opening && (!best || d < best.d)) best = { id: opening.id, d };\n    }\n    if (best) return { type: 'opening', id: best.id };\n  }\n\n  if (accepts('wall')) {\n    let best: { id: string; d: number } | null = null;\n    for (const wall of Object.values(floor.walls)) {\n      if (excluded(wall.id)) continue;\n      const a = floor.nodes[wall.a];\n      const b = floor.nodes[wall.b];\n      if (!a || !b) continue;\n      // Half the wall's own thickness, so a thick wall is grabbable across its body\n      // rather than only along its centreline.\n      const reach = Math.max(tolerances.wall, wall.thickness / 2);\n      const d = pointToSegment(point, a, b).dist;\n      if (d <= reach && (!best || d < best.d)) best = { id: wall.id, d };\n    }\n    if (best) return { type: 'wall', id: best.id };\n  }\n\n  if (accepts('room')) {\n    const room = roomAtPoint(rooms, point);\n    if (room?.roomId && !excluded(room.roomId)) return { type: 'room', id: room.roomId };\n  }\n\n  return null;\n}\n\nexport function selectionsEqual(a: PlanSelection | null, b: PlanSelection | null): boolean {\n  if (a === b) return true;\n  if (!a || !b) return false;\n  return a.type === b.type && a.id === b.id;\n}\n"],"mappings":"+KAoBA,IAAa,EAAwB,CAAE,KAAM,GAAI,QAAS,EAAG,KAAM,CAAE,EAExD,EAA+B,CAAE,KAAM,GAAI,QAAS,GAAI,KAAM,EAAG,EAE9E,SAAgB,EAAgB,EAAmB,EAA6B,CAC9E,IAAM,EAAW,EAAO,EAAI,EAAO,EACnC,MAAO,CAAE,KAAM,EAAG,KAAO,EAAU,QAAS,EAAG,QAAU,EAAU,KAAM,EAAG,KAAO,CAAS,CAC9F,CAgBA,SAAgB,EACd,EACA,EACA,EACA,EACA,EAA0B,CAAC,EACL,CACtB,IAAM,EAAW,GAAgC,CAAC,EAAQ,QAAU,EAAQ,OAAO,SAAS,CAAI,EAC1F,EAAY,GAAe,EAAQ,YAAY,IAAI,CAAE,GAAK,GAEhE,GAAI,EAAQ,MAAM,EAAG,CACnB,IAAI,EAAyC,KAC7C,IAAK,IAAM,KAAQ,OAAO,OAAO,EAAM,KAAK,EAAG,CAC7C,GAAI,EAAS,EAAK,EAAE,EAAG,SACvB,IAAM,EAAI,EAAK,EAAO,CAAI,EACtB,GAAK,EAAW,OAAS,CAAC,GAAQ,EAAI,EAAK,KAAI,EAAO,CAAE,GAAI,EAAK,GAAI,GAAE,EAC7E,CACA,GAAI,EAAM,MAAO,CAAE,KAAM,OAAQ,GAAI,EAAK,EAAG,CAC/C,CAEA,GAAI,EAAQ,SAAS,EAAG,CACtB,IAAI,EAAyC,KAC7C,IAAK,IAAM,KAAW,OAAO,OAAO,EAAM,QAAQ,EAAG,CACnD,GAAI,EAAS,EAAQ,EAAE,EAAG,SAC1B,IAAM,EAAM,EAAgB,EAAO,CAAO,EAC1C,GAAI,CAAC,EAAK,SACV,IAAM,EAAI,EAAe,EAAO,EAAI,GAAI,EAAI,EAAE,CAAC,CAAC,KAC5C,GAAK,EAAW,UAAY,CAAC,GAAQ,EAAI,EAAK,KAAI,EAAO,CAAE,GAAI,EAAQ,GAAI,GAAE,EACnF,CACA,GAAI,EAAM,MAAO,CAAE,KAAM,UAAW,GAAI,EAAK,EAAG,CAClD,CAEA,GAAI,EAAQ,MAAM,EAAG,CACnB,IAAI,EAAyC,KAC7C,IAAK,IAAM,KAAQ,OAAO,OAAO,EAAM,KAAK,EAAG,CAC7C,GAAI,EAAS,EAAK,EAAE,EAAG,SACvB,IAAM,EAAI,EAAM,MAAM,EAAK,GACrB,EAAI,EAAM,MAAM,EAAK,GAC3B,GAAI,CAAC,GAAK,CAAC,EAAG,SAGd,IAAM,EAAQ,KAAK,IAAI,EAAW,KAAM,EAAK,UAAY,CAAC,EACpD,EAAI,EAAe,EAAO,EAAG,CAAC,CAAC,CAAC,KAClC,GAAK,IAAU,CAAC,GAAQ,EAAI,EAAK,KAAI,EAAO,CAAE,GAAI,EAAK,GAAI,GAAE,EACnE,CACA,GAAI,EAAM,MAAO,CAAE,KAAM,OAAQ,GAAI,EAAK,EAAG,CAC/C,CAEA,GAAI,EAAQ,MAAM,EAAG,CACnB,IAAM,EAAO,EAAY,EAAO,CAAK,EACrC,GAAI,GAAM,QAAU,CAAC,EAAS,EAAK,MAAM,EAAG,MAAO,CAAE,KAAM,OAAQ,GAAI,EAAK,MAAO,CACrF,CAEA,OAAO,IACT,CAEA,SAAgB,EAAgB,EAAyB,EAAkC,CAGzF,OAFI,IAAM,EAAU,GAChB,CAAC,GAAK,CAAC,EAAU,GACd,EAAE,OAAS,EAAE,MAAQ,EAAE,KAAO,EAAE,EACzC"}
+{"version":3,"file":"floorPlan.hit.mjs","names":[],"sources":["../../../../package/common/floorPlan/floorPlan.hit.ts"],"sourcesContent":["/**\n * Hit testing against a derived plan.\n *\n * Tolerances arrive in WORLD units and are expected to have been converted from screen\n * pixels by the caller (`HIT_PX / view.zoom`), so a handle stays the same size on screen\n * at any zoom level.\n */\n\nimport { dist, pointToSegment } from './floorPlan.geometry';\nimport { openingGeometry } from './floorPlan.path';\nimport { roomAtPoint } from './floorPlan.rooms';\nimport type { DerivedRoom, PlanFloor, PlanPoint, PlanSelection } from './floorPlan.types';\n\nexport interface HitTolerances {\n  node: number;\n  opening: number;\n  wall: number;\n}\n\n/** Screen-pixel hit radii, divided by `view.zoom` to get world tolerances. */\nexport const HIT_PX: HitTolerances = { node: 10, opening: 9, wall: 8 };\n/** Wider targets for touch, where there is no pixel-accurate pointer. */\nexport const HIT_PX_COARSE: HitTolerances = { node: 18, opening: 16, wall: 14 };\n\nexport function worldTolerances(px: HitTolerances, zoom: number): HitTolerances {\n  const safeZoom = zoom > 0 ? zoom : 1;\n  return { node: px.node / safeZoom, opening: px.opening / safeZoom, wall: px.wall / safeZoom };\n}\n\nexport interface HitTestOptions {\n  /** Restricts what can be hit. Defaults to everything. */\n  accept?: Array<PlanSelection['type']>;\n  excludeIds?: ReadonlySet<string>;\n}\n\n/**\n * Finds what is under `point`, in priority order: node handle, opening, wall, then room\n * fill.\n *\n * The order is what makes editing feel right. A node sits on top of the walls that meet\n * there, and an opening sits on top of the wall it cuts, so the smaller, more specific\n * target always wins over the larger one underneath it.\n */\nexport function hitTest(\n  floor: PlanFloor,\n  rooms: DerivedRoom[],\n  point: PlanPoint,\n  tolerances: HitTolerances,\n  options: HitTestOptions = {},\n): PlanSelection | null {\n  const accepts = (type: PlanSelection['type']) => !options.accept || options.accept.includes(type);\n  const excluded = (id: string) => options.excludeIds?.has(id) ?? false;\n\n  if (accepts('node')) {\n    let best: { id: string; d: number } | null = null;\n    for (const node of Object.values(floor.nodes)) {\n      if (excluded(node.id)) continue;\n      const d = dist(point, node);\n      if (d <= tolerances.node && (!best || d < best.d)) best = { id: node.id, d };\n    }\n    if (best) return { type: 'node', id: best.id };\n  }\n\n  if (accepts('opening')) {\n    let best: { id: string; d: number } | null = null;\n    for (const opening of Object.values(floor.openings)) {\n      if (excluded(opening.id)) continue;\n      const geo = openingGeometry(floor, opening);\n      if (!geo) continue;\n      const d = pointToSegment(point, geo.p1, geo.p2).dist;\n      if (d <= tolerances.opening && (!best || d < best.d)) best = { id: opening.id, d };\n    }\n    if (best) return { type: 'opening', id: best.id };\n  }\n\n  if (accepts('wall')) {\n    let best: { id: string; d: number } | null = null;\n    for (const wall of Object.values(floor.walls)) {\n      if (excluded(wall.id)) continue;\n      const a = floor.nodes[wall.a];\n      const b = floor.nodes[wall.b];\n      if (!a || !b) continue;\n      // Half the wall's own thickness, so a thick wall is grabbable across its body\n      // rather than only along its centreline.\n      const reach = Math.max(tolerances.wall, wall.thickness / 2);\n      const d = pointToSegment(point, a, b).dist;\n      if (d <= reach && (!best || d < best.d)) best = { id: wall.id, d };\n    }\n    if (best) return { type: 'wall', id: best.id };\n  }\n\n  if (accepts('room')) {\n    const room = roomAtPoint(rooms, point);\n    if (room?.roomId && !excluded(room.roomId)) return { type: 'room', id: room.roomId };\n  }\n\n  return null;\n}\n\nexport function selectionsEqual(a: PlanSelection | null, b: PlanSelection | null): boolean {\n  if (a === b) return true;\n  if (!a || !b) return false;\n  return a.type === b.type && a.id === b.id;\n}\n"],"mappings":"4LAoBA,IAAa,EAAwB,CAAE,KAAM,GAAI,QAAS,EAAG,KAAM,CAAE,EAExD,EAA+B,CAAE,KAAM,GAAI,QAAS,GAAI,KAAM,EAAG,EAE9E,SAAgB,EAAgB,EAAmB,EAA6B,CAC9E,IAAM,EAAW,EAAO,EAAI,EAAO,EACnC,MAAO,CAAE,KAAM,EAAG,KAAO,EAAU,QAAS,EAAG,QAAU,EAAU,KAAM,EAAG,KAAO,CAAS,CAC9F,CAgBA,SAAgB,EACd,EACA,EACA,EACA,EACA,EAA0B,CAAC,EACL,CACtB,IAAM,EAAW,GAAgC,CAAC,EAAQ,QAAU,EAAQ,OAAO,SAAS,CAAI,EAC1F,EAAY,GAAe,EAAQ,YAAY,IAAI,CAAE,GAAK,GAEhE,GAAI,EAAQ,MAAM,EAAG,CACnB,IAAI,EAAyC,KAC7C,IAAK,IAAM,KAAQ,OAAO,OAAO,EAAM,KAAK,EAAG,CAC7C,GAAI,EAAS,EAAK,EAAE,EAAG,SACvB,IAAM,EAAI,EAAK,EAAO,CAAI,EACtB,GAAK,EAAW,OAAS,CAAC,GAAQ,EAAI,EAAK,KAAI,EAAO,CAAE,GAAI,EAAK,GAAI,GAAE,EAC7E,CACA,GAAI,EAAM,MAAO,CAAE,KAAM,OAAQ,GAAI,EAAK,EAAG,CAC/C,CAEA,GAAI,EAAQ,SAAS,EAAG,CACtB,IAAI,EAAyC,KAC7C,IAAK,IAAM,KAAW,OAAO,OAAO,EAAM,QAAQ,EAAG,CACnD,GAAI,EAAS,EAAQ,EAAE,EAAG,SAC1B,IAAM,EAAM,EAAgB,EAAO,CAAO,EAC1C,GAAI,CAAC,EAAK,SACV,IAAM,EAAI,EAAe,EAAO,EAAI,GAAI,EAAI,EAAE,CAAC,CAAC,KAC5C,GAAK,EAAW,UAAY,CAAC,GAAQ,EAAI,EAAK,KAAI,EAAO,CAAE,GAAI,EAAQ,GAAI,GAAE,EACnF,CACA,GAAI,EAAM,MAAO,CAAE,KAAM,UAAW,GAAI,EAAK,EAAG,CAClD,CAEA,GAAI,EAAQ,MAAM,EAAG,CACnB,IAAI,EAAyC,KAC7C,IAAK,IAAM,KAAQ,OAAO,OAAO,EAAM,KAAK,EAAG,CAC7C,GAAI,EAAS,EAAK,EAAE,EAAG,SACvB,IAAM,EAAI,EAAM,MAAM,EAAK,GACrB,EAAI,EAAM,MAAM,EAAK,GAC3B,GAAI,CAAC,GAAK,CAAC,EAAG,SAGd,IAAM,EAAQ,KAAK,IAAI,EAAW,KAAM,EAAK,UAAY,CAAC,EACpD,EAAI,EAAe,EAAO,EAAG,CAAC,CAAC,CAAC,KAClC,GAAK,IAAU,CAAC,GAAQ,EAAI,EAAK,KAAI,EAAO,CAAE,GAAI,EAAK,GAAI,GAAE,EACnE,CACA,GAAI,EAAM,MAAO,CAAE,KAAM,OAAQ,GAAI,EAAK,EAAG,CAC/C,CAEA,GAAI,EAAQ,MAAM,EAAG,CACnB,IAAM,EAAO,EAAY,EAAO,CAAK,EACrC,GAAI,GAAM,QAAU,CAAC,EAAS,EAAK,MAAM,EAAG,MAAO,CAAE,KAAM,OAAQ,GAAI,EAAK,MAAO,CACrF,CAEA,OAAO,IACT,CAEA,SAAgB,EAAgB,EAAyB,EAAkC,CAGzF,OAFI,IAAM,EAAU,GAChB,CAAC,GAAK,CAAC,EAAU,GACd,EAAE,OAAS,EAAE,MAAQ,EAAE,KAAO,EAAE,EACzC"}

package/dist/esm/common/floorPlan/floorPlan.json.mjs

@@ -1,2 +1,2 @@
-import{DoorSwing as e,OpeningKind as t,PlanUnitSystem as n,WallType as r}from"./floorPlan.types.mjs";import{cleanupPlan as i,newId as a}from"./floorPlan.graph.mjs";import{emptyFloor as o}from"./floorPlan.plan.mjs";var s=1;function c(e,t={}){return JSON.stringify(e,null,t.pretty===!1?void 0:2)}function l(e){return typeof e==`object`&&!!e&&!Array.isArray(e)}function u(e,t){let n=typeof e==`string`?Number(e):e;return typeof n==`number`&&Number.isFinite(n)?n:t}function d(e,t){return typeof e==`string`?e:t}function f(e,t){return typeof e==`boolean`?e:t}function p(e,t,n){return typeof e==`string`&&t.includes(e)?e:n}function m(e,t){return l(e)?{x:u(e.x,t.x),y:u(e.y,t.y)}:t}function h(e){return Array.isArray(e)?e:l(e)?Object.values(e):[]}function g(e){let t={};for(let n of e)t[n.id]=n;return t}function _(n,a,s){let c=`floor ${a+1}`,_=l(n)?n:{};l(n)||s.push(`${c} was not an object, so it was read as empty`);let v=o();v.id=d(_.id,v.id),v.label=d(_.label,v.label),v.elevation=u(_.elevation,0),v.height=u(_.height,v.height);let y=[];for(let e of h(_.nodes))l(e)&&typeof e.id==`string`&&y.push({id:e.id,x:u(e.x,0),y:u(e.y,0)});v.nodes=g(y);let b=[],x=0;for(let e of h(_.walls)){if(!l(e)||typeof e.id!=`string`)continue;let t=d(e.a,``),n=d(e.b,``);if(!v.nodes[t]||!v.nodes[n]||t===n){x+=1;continue}b.push({id:e.id,a:t,b:n,thickness:Math.max(1,u(e.thickness,100)),height:e.height===void 0?void 0:u(e.height,0),baseHeight:e.baseHeight===void 0?void 0:u(e.baseHeight,0),type:p(e.type,Object.values(r),r.Interior)})}v.walls=g(b),x>0&&s.push(`${c}: dropped ${x} wall(s) whose corners were missing`);let S=[],C=0;for(let n of h(_.openings)){if(!l(n)||typeof n.id!=`string`)continue;let r=d(n.wallId,``);if(!v.walls[r]){C+=1;continue}S.push({id:n.id,wallId:r,kind:p(n.kind,Object.values(t),t.Door),offset:u(n.offset,0),width:Math.max(1,u(n.width,800)),sill:u(n.sill,0),head:u(n.head,2100),swing:n.swing===void 0?void 0:p(n.swing,Object.values(e),e.StartLeft)})}v.openings=g(S),C>0&&s.push(`${c}: dropped ${C} opening(s) with no wall to sit in`);let w=[];for(let e of h(_.rooms))l(e)&&typeof e.id==`string`&&w.push({id:e.id,name:d(e.name,``),colour:typeof e.colour==`string`?e.colour:void 0,usage:typeof e.usage==`string`?e.usage:void 0,anchor:m(e.anchor,{x:0,y:0}),anchorPinned:f(e.anchorPinned,!1),seq:u(e.seq,w.length),wallIds:Array.isArray(e.wallIds)?e.wallIds.filter(e=>typeof e==`string`&&!!v.walls[e]):[],area:u(e.area,0)});v.rooms=g(w);let T=i(v);return T.result.length>0&&s.push(`${c}: repaired ${T.result.length} inconsistency(ies) in the geometry`),T.floor}function v(e){let t=[],r;try{r=JSON.parse(e)}catch(e){return{plan:null,issues:[`Not valid JSON: ${e.message}`]}}if(!l(r))return{plan:null,issues:[`Not a floor plan: expected an object`]};if(r.version!==void 0&&r.version!==1)return{plan:null,issues:[`Plan format version ${String(r.version)} is not supported (this build reads version 1)`]};r.version===void 0&&t.push(`No format version, read as version 1`);let i=Array.isArray(r.floors)?r.floors:[];if(i.length===0){if(r.floors!==void 0)t.push(`No floors in the file, started an empty one`);else return{plan:null,issues:["Not a floor plan: no `floors`"]}}let o=(i.length>0?i:[void 0]).map((e,n)=>_(e,n,t));return{plan:{id:d(r.id,a(`plan`)),name:typeof r.name==`string`?r.name:void 0,version:1,unitSystem:p(r.unitSystem,Object.values(n),n.Metric),floors:o,revision:u(r.revision,0)+1},issues:t}}export{s as PLAN_FORMAT_VERSION,v as planFromJson,c as planToJson};
+"use client";import{DoorSwing as e,OpeningKind as t,PlanUnitSystem as n,WallType as r}from"./floorPlan.types.mjs";import{cleanupPlan as i,newId as a}from"./floorPlan.graph.mjs";import{emptyFloor as o}from"./floorPlan.plan.mjs";var s=1;function c(e,t={}){return JSON.stringify(e,null,t.pretty===!1?void 0:2)}function l(e){return typeof e==`object`&&!!e&&!Array.isArray(e)}function u(e,t){let n=typeof e==`string`?Number(e):e;return typeof n==`number`&&Number.isFinite(n)?n:t}function d(e,t){return typeof e==`string`?e:t}function f(e,t){return typeof e==`boolean`?e:t}function p(e,t,n){return typeof e==`string`&&t.includes(e)?e:n}function m(e,t){return l(e)?{x:u(e.x,t.x),y:u(e.y,t.y)}:t}function h(e){return Array.isArray(e)?e:l(e)?Object.values(e):[]}function g(e){let t={};for(let n of e)t[n.id]=n;return t}function _(n,a,s){let c=`floor ${a+1}`,_=l(n)?n:{};l(n)||s.push(`${c} was not an object, so it was read as empty`);let v=o();v.id=d(_.id,v.id),v.label=d(_.label,v.label),v.elevation=u(_.elevation,0),v.height=u(_.height,v.height);let y=[];for(let e of h(_.nodes))l(e)&&typeof e.id==`string`&&y.push({id:e.id,x:u(e.x,0),y:u(e.y,0)});v.nodes=g(y);let b=[],x=0;for(let e of h(_.walls)){if(!l(e)||typeof e.id!=`string`)continue;let t=d(e.a,``),n=d(e.b,``);if(!v.nodes[t]||!v.nodes[n]||t===n){x+=1;continue}b.push({id:e.id,a:t,b:n,thickness:Math.max(1,u(e.thickness,100)),height:e.height===void 0?void 0:u(e.height,0),baseHeight:e.baseHeight===void 0?void 0:u(e.baseHeight,0),type:p(e.type,Object.values(r),r.Interior)})}v.walls=g(b),x>0&&s.push(`${c}: dropped ${x} wall(s) whose corners were missing`);let S=[],C=0;for(let n of h(_.openings)){if(!l(n)||typeof n.id!=`string`)continue;let r=d(n.wallId,``);if(!v.walls[r]){C+=1;continue}S.push({id:n.id,wallId:r,kind:p(n.kind,Object.values(t),t.Door),offset:u(n.offset,0),width:Math.max(1,u(n.width,800)),sill:u(n.sill,0),head:u(n.head,2100),swing:n.swing===void 0?void 0:p(n.swing,Object.values(e),e.StartLeft)})}v.openings=g(S),C>0&&s.push(`${c}: dropped ${C} opening(s) with no wall to sit in`);let w=[];for(let e of h(_.rooms))l(e)&&typeof e.id==`string`&&w.push({id:e.id,name:d(e.name,``),colour:typeof e.colour==`string`?e.colour:void 0,usage:typeof e.usage==`string`?e.usage:void 0,anchor:m(e.anchor,{x:0,y:0}),anchorPinned:f(e.anchorPinned,!1),seq:u(e.seq,w.length),wallIds:Array.isArray(e.wallIds)?e.wallIds.filter(e=>typeof e==`string`&&!!v.walls[e]):[],area:u(e.area,0)});v.rooms=g(w);let T=i(v);return T.result.length>0&&s.push(`${c}: repaired ${T.result.length} inconsistency(ies) in the geometry`),T.floor}function v(e){let t=[],r;try{r=JSON.parse(e)}catch(e){return{plan:null,issues:[`Not valid JSON: ${e.message}`]}}if(!l(r))return{plan:null,issues:[`Not a floor plan: expected an object`]};if(r.version!==void 0&&r.version!==1)return{plan:null,issues:[`Plan format version ${String(r.version)} is not supported (this build reads version 1)`]};r.version===void 0&&t.push(`No format version, read as version 1`);let i=Array.isArray(r.floors)?r.floors:[];if(i.length===0){if(r.floors!==void 0)t.push(`No floors in the file, started an empty one`);else return{plan:null,issues:["Not a floor plan: no `floors`"]}}let o=(i.length>0?i:[void 0]).map((e,n)=>_(e,n,t));return{plan:{id:d(r.id,a(`plan`)),name:typeof r.name==`string`?r.name:void 0,version:1,unitSystem:p(r.unitSystem,Object.values(n),n.Metric),floors:o,revision:u(r.revision,0)+1},issues:t}}export{s as PLAN_FORMAT_VERSION,v as planFromJson,c as planToJson};
 //# sourceMappingURL=floorPlan.json.mjs.map

package/dist/esm/common/floorPlan/floorPlan.json.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"floorPlan.json.mjs","names":[],"sources":["../../../../package/common/floorPlan/floorPlan.json.ts"],"sourcesContent":["/**\n * Reading and writing a plan as JSON, which is the interchange format.\n *\n * Writing is trivial. Reading is not: the text comes off a disk, so it is untrusted, and\n * the component that receives the result renders it immediately. `planFromJson` therefore\n * rebuilds the plan field by field rather than casting the parsed object, so nothing that\n * was not checked can reach the renderer, and returns everything it had to fix so a\n * caller can tell the difference between a clean file and a salvaged one.\n *\n * It repairs rather than rejects wherever a repair is unambiguous: a wall whose node is\n * missing is dropped, a thickness of `\"200\"` is read as 200, an unknown wall type becomes\n * `Interior`. A file is only refused when there is nothing to salvage, because a plan a\n * user spent an hour on should not be lost to one bad field.\n */\n\nimport { cleanupPlan, newId } from './floorPlan.graph';\nimport { emptyFloor } from './floorPlan.plan';\nimport { DoorSwing, OpeningKind, PlanUnitSystem, WallType } from './floorPlan.types';\nimport type { FloorPlan, PlanFloor, PlanNode, PlanOpening, PlanPoint, PlanRoom, PlanWall } from './floorPlan.types';\n\n/** The only `version` a file may carry. Bump only for a breaking shape change. */\nexport const PLAN_FORMAT_VERSION = 1;\n\nexport interface PlanParseResult {\n  /** `null` only when the file could not be read as a plan at all. */\n  plan: FloorPlan | null;\n  /**\n   * Everything that had to be repaired or dropped, in plain language. Empty means the\n   * file was clean. A non-empty list with a plan means it was salvaged.\n   */\n  issues: string[];\n}\n\n/** A plan as JSON text, ready to write to a file. Indented unless told otherwise. */\nexport function planToJson(plan: FloorPlan, options: { pretty?: boolean } = {}): string {\n  return JSON.stringify(plan, null, options.pretty === false ? undefined : 2);\n}\n\n// ─── Field readers ─────────────────────────────────────────────────────────────\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value);\n}\n\n/** A finite number, also accepting the numeric strings a hand-edited file tends to grow. */\nfunction num(value: unknown, fallback: number): number {\n  const n = typeof value === 'string' ? Number(value) : value;\n  return typeof n === 'number' && Number.isFinite(n) ? n : fallback;\n}\n\nfunction str(value: unknown, fallback: string): string {\n  return typeof value === 'string' ? value : fallback;\n}\n\nfunction bool(value: unknown, fallback: boolean): boolean {\n  return typeof value === 'boolean' ? value : fallback;\n}\n\nfunction oneOf<T extends string>(value: unknown, allowed: readonly T[], fallback: T): T {\n  return typeof value === 'string' && (allowed as readonly string[]).includes(value) ? (value as T) : fallback;\n}\n\nfunction point(value: unknown, fallback: PlanPoint): PlanPoint {\n  if (!isRecord(value)) return fallback;\n  return { x: num(value.x, fallback.x), y: num(value.y, fallback.y) };\n}\n\n/**\n * The entries of a `Record<string, T>`, tolerating the array a different exporter might\n * have written. Entries without a usable `id` are dropped by the caller.\n */\nfunction entries(value: unknown): unknown[] {\n  if (Array.isArray(value)) return value;\n  if (isRecord(value)) return Object.values(value);\n  return [];\n}\n\nfunction byId<T extends { id: string }>(items: T[]): Record<string, T> {\n  const out: Record<string, T> = {};\n  for (const item of items) out[item.id] = item;\n  return out;\n}\n\n// ─── Floor ─────────────────────────────────────────────────────────────────────\n\nfunction readFloor(raw: unknown, index: number, issues: string[]): PlanFloor {\n  const where = `floor ${index + 1}`;\n  const source = isRecord(raw) ? raw : {};\n  if (!isRecord(raw)) issues.push(`${where} was not an object, so it was read as empty`);\n\n  const floor = emptyFloor();\n  floor.id = str(source.id, floor.id);\n  floor.label = str(source.label, floor.label);\n  floor.elevation = num(source.elevation, 0);\n  floor.height = num(source.height, floor.height);\n\n  const nodes: PlanNode[] = [];\n  for (const raw of entries(source.nodes)) {\n    if (!isRecord(raw) || typeof raw.id !== 'string') continue;\n    nodes.push({ id: raw.id, x: num(raw.x, 0), y: num(raw.y, 0) });\n  }\n  floor.nodes = byId(nodes);\n\n  const walls: PlanWall[] = [];\n  let orphanWalls = 0;\n  for (const raw of entries(source.walls)) {\n    if (!isRecord(raw) || typeof raw.id !== 'string') continue;\n    const a = str(raw.a, '');\n    const b = str(raw.b, '');\n    // A wall with no node to stand on would break face extraction, which assumes every\n    // wall resolves. There is no way to guess where it was meant to go.\n    if (!floor.nodes[a] || !floor.nodes[b] || a === b) {\n      orphanWalls += 1;\n      continue;\n    }\n    walls.push({\n      id: raw.id,\n      a,\n      b,\n      thickness: Math.max(1, num(raw.thickness, 100)),\n      height: raw.height === undefined ? undefined : num(raw.height, 0),\n      baseHeight: raw.baseHeight === undefined ? undefined : num(raw.baseHeight, 0),\n      type: oneOf(raw.type, Object.values(WallType), WallType.Interior),\n    });\n  }\n  floor.walls = byId(walls);\n  if (orphanWalls > 0) {\n    issues.push(`${where}: dropped ${orphanWalls} wall(s) whose corners were missing`);\n  }\n\n  const openings: PlanOpening[] = [];\n  let orphanOpenings = 0;\n  for (const raw of entries(source.openings)) {\n    if (!isRecord(raw) || typeof raw.id !== 'string') continue;\n    const wallId = str(raw.wallId, '');\n    if (!floor.walls[wallId]) {\n      orphanOpenings += 1;\n      continue;\n    }\n    openings.push({\n      id: raw.id,\n      wallId,\n      kind: oneOf(raw.kind, Object.values(OpeningKind), OpeningKind.Door),\n      offset: num(raw.offset, 0),\n      width: Math.max(1, num(raw.width, 800)),\n      sill: num(raw.sill, 0),\n      head: num(raw.head, 2100),\n      swing: raw.swing === undefined ? undefined : oneOf(raw.swing, Object.values(DoorSwing), DoorSwing.StartLeft),\n    });\n  }\n  floor.openings = byId(openings);\n  if (orphanOpenings > 0) {\n    issues.push(`${where}: dropped ${orphanOpenings} opening(s) with no wall to sit in`);\n  }\n\n  const rooms: PlanRoom[] = [];\n  for (const raw of entries(source.rooms)) {\n    if (!isRecord(raw) || typeof raw.id !== 'string') continue;\n    // A room is only a name attached to a face, and the face is recomputed on load, so a\n    // room whose walls have gone is kept rather than dropped: re-adding the wall brings\n    // its name back, and dropping it is the one way this model loses data for good.\n    rooms.push({\n      id: raw.id,\n      name: str(raw.name, ''),\n      colour: typeof raw.colour === 'string' ? raw.colour : undefined,\n      usage: typeof raw.usage === 'string' ? raw.usage : undefined,\n      anchor: point(raw.anchor, { x: 0, y: 0 }),\n      anchorPinned: bool(raw.anchorPinned, false),\n      seq: num(raw.seq, rooms.length),\n      wallIds: Array.isArray(raw.wallIds)\n        ? raw.wallIds.filter((id): id is string => typeof id === 'string' && !!floor.walls[id])\n        : [],\n      area: num(raw.area, 0),\n    });\n  }\n  floor.rooms = byId(rooms);\n\n  const cleaned = cleanupPlan(floor);\n  if (cleaned.result.length > 0) {\n    issues.push(`${where}: repaired ${cleaned.result.length} inconsistency(ies) in the geometry`);\n  }\n  return cleaned.floor;\n}\n\n// ─── Document ──────────────────────────────────────────────────────────────────\n\n/**\n * Reads JSON text as a plan, repairing what it can and reporting what it could not.\n *\n * `plan` is `null` only when the text is not JSON, is not an object, or carries a\n * `version` this build does not know. Everything else comes back as a usable plan.\n */\nexport function planFromJson(text: string): PlanParseResult {\n  const issues: string[] = [];\n\n  let raw: unknown;\n  try {\n    raw = JSON.parse(text);\n  } catch (error) {\n    return { plan: null, issues: [`Not valid JSON: ${(error as Error).message}`] };\n  }\n\n  if (!isRecord(raw)) return { plan: null, issues: ['Not a floor plan: expected an object'] };\n\n  if (raw.version !== undefined && raw.version !== PLAN_FORMAT_VERSION) {\n    // Refusing beats guessing: a future version may mean something different by the same\n    // field names, and silently misreading it loses the file's real contents.\n    return {\n      plan: null,\n      issues: [\n        `Plan format version ${String(raw.version)} is not supported ` +\n          `(this build reads version ${PLAN_FORMAT_VERSION})`,\n      ],\n    };\n  }\n  if (raw.version === undefined) issues.push('No format version, read as version 1');\n\n  const rawFloors = Array.isArray(raw.floors) ? raw.floors : [];\n  if (rawFloors.length === 0) {\n    if (raw.floors !== undefined) issues.push('No floors in the file, started an empty one');\n    else return { plan: null, issues: ['Not a floor plan: no `floors`'] };\n  }\n\n  const floors = (rawFloors.length > 0 ? rawFloors : [undefined]).map((floor, i) => readFloor(floor, i, issues));\n\n  return {\n    plan: {\n      id: str(raw.id, newId('plan')),\n      name: typeof raw.name === 'string' ? raw.name : undefined,\n      version: PLAN_FORMAT_VERSION,\n      unitSystem: oneOf(raw.unitSystem, Object.values(PlanUnitSystem), PlanUnitSystem.Metric),\n      floors,\n      // Bumped, not carried over: the plan in hand is not the one the file described if\n      // anything was repaired, and `derivePlan` memoises on this.\n      revision: num(raw.revision, 0) + 1,\n    },\n    issues,\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"floorPlan.json.mjs","names":[],"sources":["../../../../package/common/floorPlan/floorPlan.json.ts"],"sourcesContent":["/**\n * Reading and writing a plan as JSON, which is the interchange format.\n *\n * Writing is trivial. Reading is not: the text comes off a disk, so it is untrusted, and\n * the component that receives the result renders it immediately. `planFromJson` therefore\n * rebuilds the plan field by field rather than casting the parsed object, so nothing that\n * was not checked can reach the renderer, and returns everything it had to fix so a\n * caller can tell the difference between a clean file and a salvaged one.\n *\n * It repairs rather than rejects wherever a repair is unambiguous: a wall whose node is\n * missing is dropped, a thickness of `\"200\"` is read as 200, an unknown wall type becomes\n * `Interior`. A file is only refused when there is nothing to salvage, because a plan a\n * user spent an hour on should not be lost to one bad field.\n */\n\nimport { cleanupPlan, newId } from './floorPlan.graph';\nimport { emptyFloor } from './floorPlan.plan';\nimport { DoorSwing, OpeningKind, PlanUnitSystem, WallType } from './floorPlan.types';\nimport type { FloorPlan, PlanFloor, PlanNode, PlanOpening, PlanPoint, PlanRoom, PlanWall } from './floorPlan.types';\n\n/** The only `version` a file may carry. Bump only for a breaking shape change. */\nexport const PLAN_FORMAT_VERSION = 1;\n\nexport interface PlanParseResult {\n  /** `null` only when the file could not be read as a plan at all. */\n  plan: FloorPlan | null;\n  /**\n   * Everything that had to be repaired or dropped, in plain language. Empty means the\n   * file was clean. A non-empty list with a plan means it was salvaged.\n   */\n  issues: string[];\n}\n\n/** A plan as JSON text, ready to write to a file. Indented unless told otherwise. */\nexport function planToJson(plan: FloorPlan, options: { pretty?: boolean } = {}): string {\n  return JSON.stringify(plan, null, options.pretty === false ? undefined : 2);\n}\n\n// ─── Field readers ─────────────────────────────────────────────────────────────\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value);\n}\n\n/** A finite number, also accepting the numeric strings a hand-edited file tends to grow. */\nfunction num(value: unknown, fallback: number): number {\n  const n = typeof value === 'string' ? Number(value) : value;\n  return typeof n === 'number' && Number.isFinite(n) ? n : fallback;\n}\n\nfunction str(value: unknown, fallback: string): string {\n  return typeof value === 'string' ? value : fallback;\n}\n\nfunction bool(value: unknown, fallback: boolean): boolean {\n  return typeof value === 'boolean' ? value : fallback;\n}\n\nfunction oneOf<T extends string>(value: unknown, allowed: readonly T[], fallback: T): T {\n  return typeof value === 'string' && (allowed as readonly string[]).includes(value) ? (value as T) : fallback;\n}\n\nfunction point(value: unknown, fallback: PlanPoint): PlanPoint {\n  if (!isRecord(value)) return fallback;\n  return { x: num(value.x, fallback.x), y: num(value.y, fallback.y) };\n}\n\n/**\n * The entries of a `Record<string, T>`, tolerating the array a different exporter might\n * have written. Entries without a usable `id` are dropped by the caller.\n */\nfunction entries(value: unknown): unknown[] {\n  if (Array.isArray(value)) return value;\n  if (isRecord(value)) return Object.values(value);\n  return [];\n}\n\nfunction byId<T extends { id: string }>(items: T[]): Record<string, T> {\n  const out: Record<string, T> = {};\n  for (const item of items) out[item.id] = item;\n  return out;\n}\n\n// ─── Floor ─────────────────────────────────────────────────────────────────────\n\nfunction readFloor(raw: unknown, index: number, issues: string[]): PlanFloor {\n  const where = `floor ${index + 1}`;\n  const source = isRecord(raw) ? raw : {};\n  if (!isRecord(raw)) issues.push(`${where} was not an object, so it was read as empty`);\n\n  const floor = emptyFloor();\n  floor.id = str(source.id, floor.id);\n  floor.label = str(source.label, floor.label);\n  floor.elevation = num(source.elevation, 0);\n  floor.height = num(source.height, floor.height);\n\n  const nodes: PlanNode[] = [];\n  for (const raw of entries(source.nodes)) {\n    if (!isRecord(raw) || typeof raw.id !== 'string') continue;\n    nodes.push({ id: raw.id, x: num(raw.x, 0), y: num(raw.y, 0) });\n  }\n  floor.nodes = byId(nodes);\n\n  const walls: PlanWall[] = [];\n  let orphanWalls = 0;\n  for (const raw of entries(source.walls)) {\n    if (!isRecord(raw) || typeof raw.id !== 'string') continue;\n    const a = str(raw.a, '');\n    const b = str(raw.b, '');\n    // A wall with no node to stand on would break face extraction, which assumes every\n    // wall resolves. There is no way to guess where it was meant to go.\n    if (!floor.nodes[a] || !floor.nodes[b] || a === b) {\n      orphanWalls += 1;\n      continue;\n    }\n    walls.push({\n      id: raw.id,\n      a,\n      b,\n      thickness: Math.max(1, num(raw.thickness, 100)),\n      height: raw.height === undefined ? undefined : num(raw.height, 0),\n      baseHeight: raw.baseHeight === undefined ? undefined : num(raw.baseHeight, 0),\n      type: oneOf(raw.type, Object.values(WallType), WallType.Interior),\n    });\n  }\n  floor.walls = byId(walls);\n  if (orphanWalls > 0) {\n    issues.push(`${where}: dropped ${orphanWalls} wall(s) whose corners were missing`);\n  }\n\n  const openings: PlanOpening[] = [];\n  let orphanOpenings = 0;\n  for (const raw of entries(source.openings)) {\n    if (!isRecord(raw) || typeof raw.id !== 'string') continue;\n    const wallId = str(raw.wallId, '');\n    if (!floor.walls[wallId]) {\n      orphanOpenings += 1;\n      continue;\n    }\n    openings.push({\n      id: raw.id,\n      wallId,\n      kind: oneOf(raw.kind, Object.values(OpeningKind), OpeningKind.Door),\n      offset: num(raw.offset, 0),\n      width: Math.max(1, num(raw.width, 800)),\n      sill: num(raw.sill, 0),\n      head: num(raw.head, 2100),\n      swing: raw.swing === undefined ? undefined : oneOf(raw.swing, Object.values(DoorSwing), DoorSwing.StartLeft),\n    });\n  }\n  floor.openings = byId(openings);\n  if (orphanOpenings > 0) {\n    issues.push(`${where}: dropped ${orphanOpenings} opening(s) with no wall to sit in`);\n  }\n\n  const rooms: PlanRoom[] = [];\n  for (const raw of entries(source.rooms)) {\n    if (!isRecord(raw) || typeof raw.id !== 'string') continue;\n    // A room is only a name attached to a face, and the face is recomputed on load, so a\n    // room whose walls have gone is kept rather than dropped: re-adding the wall brings\n    // its name back, and dropping it is the one way this model loses data for good.\n    rooms.push({\n      id: raw.id,\n      name: str(raw.name, ''),\n      colour: typeof raw.colour === 'string' ? raw.colour : undefined,\n      usage: typeof raw.usage === 'string' ? raw.usage : undefined,\n      anchor: point(raw.anchor, { x: 0, y: 0 }),\n      anchorPinned: bool(raw.anchorPinned, false),\n      seq: num(raw.seq, rooms.length),\n      wallIds: Array.isArray(raw.wallIds)\n        ? raw.wallIds.filter((id): id is string => typeof id === 'string' && !!floor.walls[id])\n        : [],\n      area: num(raw.area, 0),\n    });\n  }\n  floor.rooms = byId(rooms);\n\n  const cleaned = cleanupPlan(floor);\n  if (cleaned.result.length > 0) {\n    issues.push(`${where}: repaired ${cleaned.result.length} inconsistency(ies) in the geometry`);\n  }\n  return cleaned.floor;\n}\n\n// ─── Document ──────────────────────────────────────────────────────────────────\n\n/**\n * Reads JSON text as a plan, repairing what it can and reporting what it could not.\n *\n * `plan` is `null` only when the text is not JSON, is not an object, or carries a\n * `version` this build does not know. Everything else comes back as a usable plan.\n */\nexport function planFromJson(text: string): PlanParseResult {\n  const issues: string[] = [];\n\n  let raw: unknown;\n  try {\n    raw = JSON.parse(text);\n  } catch (error) {\n    return { plan: null, issues: [`Not valid JSON: ${(error as Error).message}`] };\n  }\n\n  if (!isRecord(raw)) return { plan: null, issues: ['Not a floor plan: expected an object'] };\n\n  if (raw.version !== undefined && raw.version !== PLAN_FORMAT_VERSION) {\n    // Refusing beats guessing: a future version may mean something different by the same\n    // field names, and silently misreading it loses the file's real contents.\n    return {\n      plan: null,\n      issues: [\n        `Plan format version ${String(raw.version)} is not supported ` +\n          `(this build reads version ${PLAN_FORMAT_VERSION})`,\n      ],\n    };\n  }\n  if (raw.version === undefined) issues.push('No format version, read as version 1');\n\n  const rawFloors = Array.isArray(raw.floors) ? raw.floors : [];\n  if (rawFloors.length === 0) {\n    if (raw.floors !== undefined) issues.push('No floors in the file, started an empty one');\n    else return { plan: null, issues: ['Not a floor plan: no `floors`'] };\n  }\n\n  const floors = (rawFloors.length > 0 ? rawFloors : [undefined]).map((floor, i) => readFloor(floor, i, issues));\n\n  return {\n    plan: {\n      id: str(raw.id, newId('plan')),\n      name: typeof raw.name === 'string' ? raw.name : undefined,\n      version: PLAN_FORMAT_VERSION,\n      unitSystem: oneOf(raw.unitSystem, Object.values(PlanUnitSystem), PlanUnitSystem.Metric),\n      floors,\n      // Bumped, not carried over: the plan in hand is not the one the file described if\n      // anything was repaired, and `derivePlan` memoises on this.\n      revision: num(raw.revision, 0) + 1,\n    },\n    issues,\n  };\n}\n"],"mappings":"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"}

package/dist/esm/common/floorPlan/floorPlan.mesh.mjs

@@ -1,2 +1,2 @@
-import{dist as e}from"./floorPlan.geometry.mjs";import{derivePlan as t}from"./floorPlan.rooms.mjs";import{wallCentrelineSpans as n}from"./floorPlan.path.mjs";import{triangulate as r}from"./floorPlan.triangulate.mjs";var i=1e-6,a=1,o=class{constructor(){this.positions=[],this.normals=[],this.indices=[]}triangle(e,t,n){let r=t[0]-e[0],a=t[1]-e[1],o=t[2]-e[2],s=n[0]-e[0],c=n[1]-e[1],l=n[2]-e[2],u=a*l-o*c,d=o*s-r*l,f=r*c-a*s,p=Math.hypot(u,d,f);if(p<i)return;u/=p,d/=p,f/=p;let m=this.positions.length/3;for(let r of[e,t,n])this.positions.push(r[0],r[1],r[2]);for(let e=0;e<3;e++)this.normals.push(u,d,f);this.indices.push(m,m+1,m+2)}quad(e,t,n,r){this.triangle(e,t,n),this.triangle(e,n,r)}};function s(e){let t=new Map;for(let n of Object.values(e.walls))for(let e of[n.a,n.b]){let r=t.get(e);r?r.push(n):t.set(e,[n])}return t}var c=4;function l(e,t,n,r){let i=r.get(n);if(!i||i.length!==2)return null;let a=i[0].id===t.id?i[1]:i[0];if(a.thickness!==t.thickness)return null;let o=e.nodes[n],s=e.nodes[t.a===n?t.b:t.a],l=e.nodes[a.a===n?a.b:a.a];if(!o||!s||!l)return null;let d=u(s,o),f=u(o,l);if(!d||!f)return null;let p=d.x*f.x+d.y*f.y;if(p<-.999999)return null;let m={x:-d.y,y:d.x},h={x:-f.y,y:f.x},g=1+p,_={x:(m.x+h.x)/g,y:(m.y+h.y)/g};return Math.hypot(_.x,_.y)>c?null:t.b===n?_:{x:-_.x,y:-_.y}}function u(t,n){let r=e(t,n);return r<i?null:{x:(n.x-t.x)/r,y:(n.y-t.y)/r}}function d(t,n,r,a,o){let s=t.nodes[n.a],c=t.nodes[n.b];if(!s||!c)return null;let d=e(s,c);if(d<i||a-r<i)return null;let f=u(s,c),p=n.thickness/2,m={x:-f.y*p,y:f.x*p},h={x:s.x+f.x*r,y:s.y+f.y*r},g={x:s.x+f.x*a,y:s.y+f.y*a},_=r<i?l(t,n,n.a,o):null,v=a>d-i?l(t,n,n.b,o):null,y=(e,t,n)=>t?{x:e.x+t.x*p*n,y:e.y+t.y*p*n}:{x:e.x+m.x*n,y:e.y+m.y*n};return[y(h,_,1),y(g,v,1),y(g,v,-1),y(h,_,-1)]}function f(e,t,n,r){if(r-n<i)return;let a=t.map(e=>[e.x,n,e.y]),o=t.map(e=>[e.x,r,e.y]),s=0;for(let e=0;e<t.length;e++){let n=t[e],r=t[(e+1)%t.length];s+=n.x*r.y-r.x*n.y}let c=s<0;for(let n=0;n<t.length;n++){let r=(n+1)%t.length;c?e.quad(a[n],a[r],o[r],o[n]):e.quad(a[r],a[n],o[n],o[r])}for(let n=1;n+1<t.length;n++)c?(e.triangle(o[0],o[n],o[n+1]),e.triangle(a[0],a[n+1],a[n])):(e.triangle(o[0],o[n+1],o[n]),e.triangle(a[0],a[n],a[n+1]))}function p(e,t,n){return Object.values(e.openings).filter(e=>e.wallId===t.id).filter(e=>e.offset+e.width/2>i&&e.offset-e.width/2<n-i).sort((e,t)=>e.offset-t.offset)}function m(c,l={}){let{wallHeight:u,includeFloorSlab:m=!0,slabThickness:h=200,applyElevation:g=!0}=l,_=new o,v=[],y=g?c.elevation:0,b=m?h+a:0,x=s(c),S=_.indices.length;for(let t of Object.values(c.walls)){let r=c.nodes[t.a],a=c.nodes[t.b];if(!r||!a)continue;let o=e(r,a);if(o<i)continue;let s=y+(t.baseHeight??0)-b,l=s+(t.height??u??c.height);if(l-s<i)continue;let m=p(c,t,o);if(m.length===0){let e=d(c,t,0,o,x);e&&f(_,e,s,l);continue}for(let[e,r]of n(c,t)){let n=d(c,t,e,r,x);n&&f(_,n,s,l)}for(let e of m){let n=d(c,t,Math.max(0,e.offset-e.width/2),Math.min(o,e.offset+e.width/2),x);if(!n)continue;let r=s+Math.max(0,e.sill),a=s+Math.max(0,e.head);r>s+i&&f(_,n,s,Math.min(r,l)),a<l-i&&f(_,n,Math.max(a,s),l)}}if(_.indices.length>S&&v.push({part:`wall`,start:S,count:_.indices.length-S}),m){let e=_.indices.length;for(let e of t(c).rooms){let{vertices:t,indices:n}=r(e.outer,e.holes);if(n.length===0)continue;let i=y,a=y-h;for(let e=0;e<n.length;e+=3){let r=[t[n[e]],t[n[e+1]],t[n[e+2]]],o=r.map(e=>[e.x,i,e.y]),s=r.map(e=>[e.x,a,e.y]);_.triangle(o[0],o[2],o[1]),_.triangle(s[0],s[1],s[2])}for(let t of[e.outer,...e.holes])for(let e=0;e<t.length;e++){let n=t[e],r=t[(e+1)%t.length];_.quad([n.x,a,n.y],[n.x,i,n.y],[r.x,i,r.y],[r.x,a,r.y])}}_.indices.length>e&&v.push({part:`floor`,start:e,count:_.indices.length-e})}return{positions:new Float32Array(_.positions),normals:new Float32Array(_.normals),indices:new Uint32Array(_.indices),groups:v}}export{m as buildPlanMesh};
+"use client";import{dist as e}from"./floorPlan.geometry.mjs";import{derivePlan as t}from"./floorPlan.rooms.mjs";import{wallCentrelineSpans as n}from"./floorPlan.path.mjs";import{triangulate as r}from"./floorPlan.triangulate.mjs";var i=1e-6,a=1,o=class{constructor(){this.positions=[],this.normals=[],this.indices=[]}triangle(e,t,n){let r=t[0]-e[0],a=t[1]-e[1],o=t[2]-e[2],s=n[0]-e[0],c=n[1]-e[1],l=n[2]-e[2],u=a*l-o*c,d=o*s-r*l,f=r*c-a*s,p=Math.hypot(u,d,f);if(p<i)return;u/=p,d/=p,f/=p;let m=this.positions.length/3;for(let r of[e,t,n])this.positions.push(r[0],r[1],r[2]);for(let e=0;e<3;e++)this.normals.push(u,d,f);this.indices.push(m,m+1,m+2)}quad(e,t,n,r){this.triangle(e,t,n),this.triangle(e,n,r)}};function s(e){let t=new Map;for(let n of Object.values(e.walls))for(let e of[n.a,n.b]){let r=t.get(e);r?r.push(n):t.set(e,[n])}return t}var c=4;function l(e,t,n,r){let i=r.get(n);if(!i||i.length!==2)return null;let a=i[0].id===t.id?i[1]:i[0];if(a.thickness!==t.thickness)return null;let o=e.nodes[n],s=e.nodes[t.a===n?t.b:t.a],l=e.nodes[a.a===n?a.b:a.a];if(!o||!s||!l)return null;let d=u(s,o),f=u(o,l);if(!d||!f)return null;let p=d.x*f.x+d.y*f.y;if(p<-.999999)return null;let m={x:-d.y,y:d.x},h={x:-f.y,y:f.x},g=1+p,_={x:(m.x+h.x)/g,y:(m.y+h.y)/g};return Math.hypot(_.x,_.y)>c?null:t.b===n?_:{x:-_.x,y:-_.y}}function u(t,n){let r=e(t,n);return r<i?null:{x:(n.x-t.x)/r,y:(n.y-t.y)/r}}function d(t,n,r,a,o){let s=t.nodes[n.a],c=t.nodes[n.b];if(!s||!c)return null;let d=e(s,c);if(d<i||a-r<i)return null;let f=u(s,c),p=n.thickness/2,m={x:-f.y*p,y:f.x*p},h={x:s.x+f.x*r,y:s.y+f.y*r},g={x:s.x+f.x*a,y:s.y+f.y*a},_=r<i?l(t,n,n.a,o):null,v=a>d-i?l(t,n,n.b,o):null,y=(e,t,n)=>t?{x:e.x+t.x*p*n,y:e.y+t.y*p*n}:{x:e.x+m.x*n,y:e.y+m.y*n};return[y(h,_,1),y(g,v,1),y(g,v,-1),y(h,_,-1)]}function f(e,t,n,r){if(r-n<i)return;let a=t.map(e=>[e.x,n,e.y]),o=t.map(e=>[e.x,r,e.y]),s=0;for(let e=0;e<t.length;e++){let n=t[e],r=t[(e+1)%t.length];s+=n.x*r.y-r.x*n.y}let c=s<0;for(let n=0;n<t.length;n++){let r=(n+1)%t.length;c?e.quad(a[n],a[r],o[r],o[n]):e.quad(a[r],a[n],o[n],o[r])}for(let n=1;n+1<t.length;n++)c?(e.triangle(o[0],o[n],o[n+1]),e.triangle(a[0],a[n+1],a[n])):(e.triangle(o[0],o[n+1],o[n]),e.triangle(a[0],a[n],a[n+1]))}function p(e,t,n){return Object.values(e.openings).filter(e=>e.wallId===t.id).filter(e=>e.offset+e.width/2>i&&e.offset-e.width/2<n-i).sort((e,t)=>e.offset-t.offset)}function m(c,l={}){let{wallHeight:u,includeFloorSlab:m=!0,slabThickness:h=200,applyElevation:g=!0}=l,_=new o,v=[],y=g?c.elevation:0,b=m?h+a:0,x=s(c),S=_.indices.length;for(let t of Object.values(c.walls)){let r=c.nodes[t.a],a=c.nodes[t.b];if(!r||!a)continue;let o=e(r,a);if(o<i)continue;let s=y+(t.baseHeight??0)-b,l=s+(t.height??u??c.height);if(l-s<i)continue;let m=p(c,t,o);if(m.length===0){let e=d(c,t,0,o,x);e&&f(_,e,s,l);continue}for(let[e,r]of n(c,t)){let n=d(c,t,e,r,x);n&&f(_,n,s,l)}for(let e of m){let n=d(c,t,Math.max(0,e.offset-e.width/2),Math.min(o,e.offset+e.width/2),x);if(!n)continue;let r=s+Math.max(0,e.sill),a=s+Math.max(0,e.head);r>s+i&&f(_,n,s,Math.min(r,l)),a<l-i&&f(_,n,Math.max(a,s),l)}}if(_.indices.length>S&&v.push({part:`wall`,start:S,count:_.indices.length-S}),m){let e=_.indices.length;for(let e of t(c).rooms){let{vertices:t,indices:n}=r(e.outer,e.holes);if(n.length===0)continue;let i=y,a=y-h;for(let e=0;e<n.length;e+=3){let r=[t[n[e]],t[n[e+1]],t[n[e+2]]],o=r.map(e=>[e.x,i,e.y]),s=r.map(e=>[e.x,a,e.y]);_.triangle(o[0],o[2],o[1]),_.triangle(s[0],s[1],s[2])}for(let t of[e.outer,...e.holes])for(let e=0;e<t.length;e++){let n=t[e],r=t[(e+1)%t.length];_.quad([n.x,a,n.y],[n.x,i,n.y],[r.x,i,r.y],[r.x,a,r.y])}}_.indices.length>e&&v.push({part:`floor`,start:e,count:_.indices.length-e})}return{positions:new Float32Array(_.positions),normals:new Float32Array(_.normals),indices:new Uint32Array(_.indices),groups:v}}export{m as buildPlanMesh};
 //# sourceMappingURL=floorPlan.mesh.mjs.map