@pascal-app/editor 1.0.7 → 1.1.1

package/src/lib/room-assembly-overlay.ts

@@ -1,265 +0,0 @@
-import {
-  type AnyNode,
-  type AnyNodeId,
-  area,
-  getWallArcData,
-  getWallBaseElevationForNodes,
-  getWallCurveFrameAt,
-  getWallFaceOffsets,
-  getWallTop,
-  resolveCeilingHeight,
-  roomDrawnFloor,
-  type WallNode,
-} from '@pascal-app/core'
-import { ShapeUtils, Vector2 } from 'three'
-import type { RoomSelectionGeometry, RoomSelectionRecord } from './room-selection'
-
-type Point = readonly [number, number]
-type Ring = readonly Point[]
-
-/** Everything the assembly depends on besides the room's topology geometry. */
-export type RoomAssemblyHeights = {
-  /** Level-local Y of the room's plate top (the level plane without a plate). */
-  floorY: number
-  /** Level-local Y of each boundary wall's top. */
-  wallTops: ReadonlyMap<string, number>
-  ceiling: { polygon: Ring; holes: readonly Ring[]; y: number } | null
-}
-
-export type RoomWallFacePortion = { wallId: string; face: 'a' | 'b'; from: Point; to: Point }
-
-/** Flat level-local position buffers; the renderer only wraps them. */
-export type RoomAssembly = {
-  floor: Float32Array
-  surfaces: Float32Array
-  outline: Float32Array
-  faces: RoomWallFacePortion[]
-}
-
-const ON_FACE = 1e-3
-const FLOOR_LIFT = 0.005
-const CEILING_DROP = 0.02
-const CURVE_SAMPLES = 24
-const MIN_PIECE_AREA = 0.01
-
-/**
- * Curved boundaries leave hairline slivers between the sampled room face and
- * the sampled wall footprint; they would add stray face runs.
- */
-function clearPieces(geometry: RoomSelectionGeometry) {
-  return geometry.clearPolygon.filter((piece) => area([piece]) >= MIN_PIECE_AREA)
-}
-
-export function resolveRoomAssemblyHeights(
-  room: RoomSelectionRecord,
-  nodes: Readonly<Record<string, AnyNode>>,
-): RoomAssemblyHeights {
-  const sceneNodes = nodes as Record<AnyNodeId, AnyNode>
-  const { levelId } = room.key
-  const zone = nodes[room.zoneId]
-  let floorY = 0
-  // A drawn slab floors the room even with its floor switched off.
-  if (zone?.type === 'zone' && (zone.hasFloor !== false || roomDrawnFloor(nodes, zone.id))) {
-    const level = nodes[levelId]
-    const plate =
-      level?.type === 'level'
-        ? level.children
-            .map((id) => nodes[id])
-            .find((node) => node?.type === 'slab' && node.zoneIds?.includes(room.zoneId))
-        : undefined
-    const drawn = plate ? null : roomDrawnFloor(nodes, room.zoneId)
-    const linked =
-      plate ?? (drawn ? nodes[drawn.slabId] : room.slabId ? nodes[room.slabId] : undefined)
-    floorY = (linked?.type === 'slab' ? linked.elevation : zone.floor?.elevation) ?? 0
-  }
-  const wallTops = new Map<string, number>()
-  for (const id of room.boundaryWallIds) {
-    const wall = nodes[id]
-    if (wall?.type !== 'wall') continue
-    const base = getWallBaseElevationForNodes(wall, sceneNodes)
-    wallTops.set(id, getWallTop(wall, levelId, sceneNodes, base))
-  }
-  const ceilingNode = room.ceilingId ? nodes[room.ceilingId] : undefined
-  const ceiling =
-    ceilingNode?.type === 'ceiling'
-      ? {
-          polygon: ceilingNode.polygon,
-          holes: ceilingNode.holes,
-          y: resolveCeilingHeight(ceilingNode, sceneNodes),
-        }
-      : null
-  return { floorY, wallTops, ceiling }
-}
-
-function heightsKey({ floorY, wallTops, ceiling }: RoomAssemblyHeights) {
-  const rings = ceiling ? [ceiling.polygon, ...ceiling.holes].map((ring) => ring.join(' ')) : []
-  return [floorY, ...wallTops, ceiling?.y, ...rings].join('|')
-}
-
-const cache = new WeakMap<RoomSelectionGeometry, { key: string; assembly: RoomAssembly }>()
-
-/**
- * The room geometry object is reused for as long as the level topology
- * revision stands, so it keys the cache; heights and the ceiling outline are
- * compared by value. Hover changes and pointer moves only ever hit.
- */
-export function getRoomAssembly(
-  geometry: RoomSelectionGeometry,
-  heights: RoomAssemblyHeights,
-): RoomAssembly {
-  const key = heightsKey(heights)
-  const cached = cache.get(geometry)
-  if (cached?.key === key) return cached.assembly
-  const assembly = buildRoomAssembly(geometry, heights)
-  cache.set(geometry, { key, assembly })
-  return assembly
-}
-
-function faceTest(wall: WallNode, face: 'a' | 'b') {
-  const offset = getWallFaceOffsets(wall)[face]
-  const arc = getWallArcData(wall)
-  if (arc) {
-    const radius = arc.radius - arc.direction * offset
-    return ([x, z]: Point) =>
-      Math.abs(Math.hypot(x - arc.center.x, z - arc.center.y) - radius) < ON_FACE
-  }
-  const dx = wall.end[0] - wall.start[0]
-  const dz = wall.end[1] - wall.start[1]
-  const length = Math.hypot(dx, dz)
-  if (length < 1e-9) return () => false
-  return ([x, z]: Point) =>
-    Math.abs(((x - wall.start[0]) * -dz + (z - wall.start[1]) * dx) / length - offset) < ON_FACE
-}
-
-function* ringEdges(ring: Ring) {
-  for (let i = 0; i < ring.length; i++) yield [ring[i]!, ring[(i + 1) % ring.length]!] as const
-}
-
-function overlap(p: Point, q: Point, a: Point, b: Point): [Point, Point] | null {
-  const ex = b[0] - a[0]
-  const ez = b[1] - a[1]
-  const lengthSq = ex * ex + ez * ez
-  if (lengthSq < 1e-12) return null
-  const length = Math.sqrt(lengthSq)
-  const offLine = ([x, z]: Point) => Math.abs((x - a[0]) * ez - (z - a[1]) * ex) / length
-  if (offLine(p) > ON_FACE || offLine(q) > ON_FACE) return null
-  const up = ((p[0] - a[0]) * ex + (p[1] - a[1]) * ez) / lengthSq
-  const uq = ((q[0] - a[0]) * ex + (q[1] - a[1]) * ez) / lengthSq
-  const lo = Math.max(0, Math.min(up, uq))
-  const hi = Math.min(1, Math.max(up, uq))
-  if ((hi - lo) * length < 1e-4) return null
-  return [
-    [a[0] + ex * lo, a[1] + ez * lo],
-    [a[0] + ex * hi, a[1] + ez * hi],
-  ]
-}
-
-/**
- * The room-facing part of each boundary wall face. The clear polygon's
- * boundary is exactly the mitered faces the room sees, clipped by T-stems
- * and separators, so its edges are matched against each wall's footprint
- * face edges; that also keeps collinear walls apart.
- */
-export function roomWallFaces(geometry: RoomSelectionGeometry): RoomWallFacePortion[] {
-  const rings = clearPieces(geometry).flatMap(({ outer, holes }) => [outer, ...holes])
-  const faces: RoomWallFacePortion[] = []
-  const seen = new Set<string>()
-  for (const span of geometry.spans) {
-    if (span.kind !== 'wall') continue
-    const wallId = span.boundaryId
-    const wall = geometry.context.walls.get(wallId)
-    if (!wall) continue
-    if (!rings.length) {
-      faces.push(...sampledFace(wall, span.face, span.t0, span.t1))
-      continue
-    }
-    const key = `${wallId}:${span.face}`
-    const footprint = geometry.context.wallFootprints.get(wallId)
-    if (seen.has(key) || !footprint) continue
-    seen.add(key)
-    const onFace = faceTest(wall, span.face)
-    const faceEdges = [...ringEdges(footprint)].filter(([a, b]) => onFace(a) && onFace(b))
-    for (const ring of rings) {
-      for (const [p, q] of ringEdges(ring)) {
-        if (!(onFace(p) && onFace(q))) continue
-        for (const [a, b] of faceEdges) {
-          const portion = overlap(p, q, a, b)
-          if (portion) faces.push({ wallId, face: span.face, from: portion[0], to: portion[1] })
-        }
-      }
-    }
-  }
-  return faces
-}
-
-// Only used when the clear polygon could not be computed for the room.
-function sampledFace(wall: WallNode, face: 'a' | 'b', t0: number, t1: number) {
-  const offset = getWallFaceOffsets(wall)[face]
-  const steps = getWallArcData(wall) ? CURVE_SAMPLES : 1
-  const points = Array.from({ length: steps + 1 }, (_, i): Point => {
-    const { point, normal } = getWallCurveFrameAt(wall, t0 + ((t1 - t0) * i) / steps)
-    return [point.x + normal.x * offset, point.y + normal.y * offset]
-  })
-  return points
-    .slice(1)
-    .map((to, i): RoomWallFacePortion => ({ wallId: wall.id, face, from: points[i]!, to }))
-}
-
-function pushTriangles(target: number[], outer: Ring, holes: readonly Ring[], y: number) {
-  const contour = outer.map(([x, z]) => new Vector2(x, z))
-  const holePoints = holes.map((ring) => ring.map(([x, z]) => new Vector2(x, z)))
-  const points = [...contour, ...holePoints.flat()]
-  for (const triangle of ShapeUtils.triangulateShape(contour, holePoints)) {
-    for (const index of triangle) target.push(points[index]!.x, y, points[index]!.y)
-  }
-}
-
-function pushRing(target: number[], ring: Ring, y: number) {
-  for (const [[ax, az], [bx, bz]] of ringEdges(ring)) target.push(ax, y, az, bx, y, bz)
-}
-
-export function buildRoomAssembly(
-  geometry: RoomSelectionGeometry,
-  heights: RoomAssemblyHeights,
-): RoomAssembly {
-  const floor: number[] = []
-  const surfaces: number[] = []
-  const outline: number[] = []
-  const floorY = heights.floorY + FLOOR_LIFT
-  for (const { outer, holes } of clearPieces(geometry)) {
-    pushTriangles(floor, outer, holes, floorY)
-    for (const ring of [outer, ...holes]) pushRing(outline, ring, floorY)
-  }
-  const faces = roomWallFaces(geometry)
-  const ends = new Map<string, { point: Point; top: number; count: number }>()
-  for (const { wallId, from, to } of faces) {
-    const top = heights.wallTops.get(wallId)
-    if (top === undefined || top <= floorY) continue
-    const [ax, az] = from
-    const [bx, bz] = to
-    surfaces.push(ax, floorY, az, bx, floorY, bz, bx, top, bz)
-    surfaces.push(ax, floorY, az, bx, top, bz, ax, top, az)
-    outline.push(ax, top, az, bx, top, bz)
-    for (const point of [from, to]) {
-      const key = `${wallId}:${point[0].toFixed(4)},${point[1].toFixed(4)}`
-      const end = ends.get(key)
-      if (end) end.count++
-      else ends.set(key, { point, top, count: 1 })
-    }
-  }
-  // Verticals only where a face run starts or stops, not between curve chords.
-  for (const { point, top, count } of ends.values()) {
-    if (count === 1) outline.push(point[0], floorY, point[1], point[0], top, point[1])
-  }
-  if (heights.ceiling) {
-    const { polygon, holes, y } = heights.ceiling
-    pushTriangles(surfaces, polygon, holes, y - CEILING_DROP)
-    for (const ring of [polygon, ...holes]) pushRing(outline, ring, y - CEILING_DROP)
-  }
-  return {
-    floor: new Float32Array(floor),
-    surfaces: new Float32Array(surfaces),
-    outline: new Float32Array(outline),
-    faces,
-  }
-}

package/src/lib/room-selection.ts

@@ -1,417 +0,0 @@
-import {
-  type AnyNode,
-  area,
-  type BoundaryNode,
-  type BoundarySpan,
-  containsPoint,
-  createRoomTopologyIndex,
-  getWallArcData,
-  getWallFaceOffsets,
-  type MultiPolygon,
-  roomClearPolygon,
-  type TopologyRoom,
-  type WallNode,
-  type ZoneNode,
-} from '@pascal-app/core'
-import type { SelectionModifierKeys } from './selection-routing'
-import { polygonMatchesZoneFootprint } from './zone-content'
-
-export type RoomKey = { levelId: string; zoneId: string }
-
-export function sameRoom(a: RoomKey | null, b: RoomKey | null): boolean {
-  return a === b || (!!a && !!b && a.levelId === b.levelId && a.zoneId === b.zoneId)
-}
-
-export function shouldSelectRoom(
-  selected: RoomKey | null,
-  hit: RoomKey | null,
-  modifiers: SelectionModifierKeys,
-): boolean {
-  return (
-    !!hit &&
-    !sameRoom(selected, hit) &&
-    !(modifiers.alt || modifiers.shift || modifiers.ctrl || modifiers.meta)
-  )
-}
-
-export type RoomSelectionGeometry = TopologyRoom & {
-  key: RoomKey
-  boundaryWallIds: string[]
-  clearPolygon: ReturnType<typeof roomClearPolygon>
-  area: number
-  hitPolygon: MultiPolygon
-  /** A stacked open-below room (`floor.support: 'open'`) inside its host room. */
-  mezzanine: { hostZoneId: string } | null
-}
-
-export type RoomSelectionRecord = RoomSelectionGeometry & {
-  geometry: RoomSelectionGeometry
-  name: string
-  zoneId: string
-  slabId: string | null
-  slabName: string | null
-  ceilingId: string | null
-  ceilingName: string | null
-}
-
-type Nodes = Record<string, AnyNode>
-
-function describeRoomGeometry(
-  levelId: string,
-  room: TopologyRoom,
-  zone: ZoneNode,
-): RoomSelectionGeometry {
-  const clearPolygon = roomClearPolygon(room)
-  return {
-    ...room,
-    key: { levelId, zoneId: zone.id },
-    boundaryWallIds: [
-      ...new Set(room.spans.filter((span) => span.kind === 'wall').map((span) => span.boundaryId)),
-    ],
-    clearPolygon,
-    area: area([{ outer: zone.polygon, holes: zone.holes }]),
-    hitPolygon: [{ outer: room.polygon, holes: room.holes }],
-    mezzanine: null,
-  }
-}
-
-export function isMezzanineZone(node: AnyNode | undefined): node is ZoneNode {
-  return node?.type === 'zone' && node.floor?.support === 'open'
-}
-
-/**
- * A mezzanine as a selectable room. It has no walls of its own: its outline is
- * the zone's polygon, its floor the zone's own plate, and it bounds nothing.
- */
-function describeMezzanineGeometry(
-  levelId: string,
-  zone: ZoneNode,
-  context: TopologyRoom['context'],
-): RoomSelectionGeometry {
-  const polygon = zone.polygon.map(([x, z]) => [x, z] as [number, number])
-  const holes = (zone.holes ?? []).map((ring) => ring.map(([x, z]) => [x, z] as [number, number]))
-  const outline = [{ outer: polygon, holes }]
-  return {
-    id: `mezzanine:${zone.id}`,
-    polygon,
-    holes,
-    spans: [],
-    context,
-    key: { levelId, zoneId: zone.id },
-    boundaryWallIds: [],
-    clearPolygon: outline,
-    area: area(outline),
-    hitPolygon: outline,
-    mezzanine: { hostZoneId: zone.hostZoneId ?? '' },
-  }
-}
-
-const NO_WALLS: TopologyRoom['context'] = {
-  revision: -1,
-  walls: new Map(),
-  wallFootprints: new Map(),
-}
-
-/**
- * A zone that bounds no room (a drawn area), outlined the way a room is: its
- * polygon as the floor, no walls of its own.
- */
-export function describeZoneOutline(levelId: string, zone: ZoneNode): RoomSelectionRecord {
-  const geometry: RoomSelectionGeometry = {
-    ...describeMezzanineGeometry(levelId, zone, NO_WALLS),
-    id: `zone:${zone.id}`,
-    mezzanine: null,
-  }
-  return {
-    ...geometry,
-    geometry,
-    name: zone.name || 'Zone',
-    zoneId: zone.id,
-    slabId: null,
-    slabName: null,
-    ceilingId: null,
-    ceilingName: null,
-  }
-}
-
-function describeRoom(
-  geometry: RoomSelectionGeometry,
-  candidates: readonly AnyNode[],
-): RoomSelectionRecord {
-  const { clearPolygon } = geometry
-  const matches = (node: AnyNode) =>
-    (node.type === 'zone' || node.type === 'slab' || node.type === 'ceiling') &&
-    (polygonMatchesZoneFootprint(node.polygon, geometry.polygon) ||
-      clearPolygon.some(({ outer }) => polygonMatchesZoneFootprint(node.polygon, outer)))
-  const slab = geometry.mezzanine
-    ? candidates.find(
-        (node) =>
-          node.type === 'slab' &&
-          node.support === 'open' &&
-          !!node.zoneIds?.includes(geometry.key.zoneId),
-      )
-    : candidates.find(
-        (node) =>
-          node.type === 'slab' && node.support !== 'open' && node.autoFromWalls && matches(node),
-      )
-  const ceiling = candidates.find(
-    (node) => node.type === 'ceiling' && node.zoneId === geometry.key.zoneId,
-  )
-  const zone = candidates.find(
-    (node): node is ZoneNode => node.type === 'zone' && node.id === geometry.key.zoneId,
-  )!
-  return {
-    ...geometry,
-    geometry,
-    name: zone.name || 'Room',
-    area: area([{ outer: zone.polygon, holes: zone.holes }]),
-    zoneId: zone.id,
-    slabId: slab?.id ?? null,
-    slabName: slab ? slab.name || 'Slab' : null,
-    ceilingId: ceiling?.id ?? null,
-    ceilingName: ceiling ? ceiling.name || 'Ceiling' : null,
-  }
-}
-
-type RoomHitIndex = Pick<
-  ReturnType<typeof createRoomTopologyIndex>,
-  'roomAtPoint' | 'roomForWallHit' | 'spansForWall'
-> & {
-  /** The selectable room a zone is (a mezzanine's own plate or ceiling points at it). */
-  roomForZone?: (levelId: string, zoneId: string) => TopologyRoom | null
-}
-const wallFrames = new WeakMap<WallNode, ReturnType<typeof wallHitFrame>>()
-
-function wallHitFrame(wall: WallNode) {
-  const dx = wall.end[0] - wall.start[0]
-  const dz = wall.end[1] - wall.start[1]
-  const length = Math.hypot(dx, dz)
-  const offsets = getWallFaceOffsets(wall)
-  return {
-    dx,
-    dz,
-    lengthSq: length * length,
-    nx: -dz / length,
-    nz: dx / length,
-    arc: getWallArcData(wall),
-    center: (offsets.a + offsets.b) / 2,
-  }
-}
-
-export function resolveRoomHit<T extends RoomHitIndex>(
-  index: T,
-  levelId: string,
-  node: AnyNode | null,
-  point: [number, number],
-  view?: '2d' | '3d',
-): ReturnType<T['roomAtPoint']>
-export function resolveRoomHit(
-  index: RoomHitIndex,
-  levelId: string,
-  node: AnyNode | null,
-  point: [number, number],
-  view: '2d' | '3d' = '2d',
-): TopologyRoom | null {
-  // A mezzanine's plate (railing included) and ceiling name their own room; the
-  // host floor under it and every other surface resolve by the point, which
-  // never lands in a mezzanine.
-  if (node?.type === 'slab' && node.support === 'open')
-    return index.roomForZone?.(levelId, node.zoneIds?.[0] ?? '') ?? null
-  if (node?.type === 'ceiling' && node.zoneId) {
-    const own = index.roomForZone?.(levelId, node.zoneId)
-    if (own) return own
-  }
-  if (!node || node.type === 'slab' || node.type === 'ceiling')
-    return index.roomAtPoint(levelId, point)
-  if (node.type !== 'wall') return null
-  let frame = wallFrames.get(node)
-  if (!frame) {
-    frame = wallHitFrame(node)
-    wallFrames.set(node, frame)
-  }
-  const { dx, dz, lengthSq, arc } = frame
-  if (!lengthSq) return null
-  const station = Math.max(
-    0,
-    Math.min(1, ((point[0] - node.start[0]) * dx + (point[1] - node.start[1]) * dz) / lengthSq),
-  )
-  let x = node.start[0] + station * dx
-  let z = node.start[1] + station * dz
-  let nx = frame.nx
-  let nz = frame.nz
-  if (arc) {
-    const angle = Math.atan2(point[1] - arc.center.y, point[0] - arc.center.x)
-    const delta = Math.atan2(Math.sin(angle - arc.startAngle), Math.cos(angle - arc.startAngle))
-    const t = Math.max(0, Math.min(1, delta / arc.delta))
-    const theta = arc.startAngle + arc.delta * t
-    const cos = Math.cos(theta)
-    const sin = Math.sin(theta)
-    x = arc.center.x + cos * arc.radius
-    z = arc.center.y + sin * arc.radius
-    nx = -cos * arc.direction
-    nz = -sin * arc.direction
-  }
-  const localZ = (point[0] - x) * nx + (point[1] - z) * nz
-  // Justified bodies can lie entirely on one side of the reference line.
-  const center = view === '3d' ? frame.center : 0
-  const face = localZ >= center ? 'a' : 'b'
-  // Room first: a face with no room behind it (the exterior) still resolves
-  // to the room on the other face, or to the wall's only room; only walls
-  // bounding no room reach the wall itself.
-  return (
-    index.roomForWallHit(levelId, node.id, face, station) ??
-    index.roomForWallHit(levelId, node.id, face === 'a' ? 'b' : 'a', station) ??
-    soleWallRoom(index, levelId, node.id)
-  )
-}
-
-function soleWallRoom(index: RoomHitIndex, levelId: string, wallId: string) {
-  let sole: BoundarySpan | null = null
-  for (const span of index.spansForWall(levelId, wallId)) {
-    if (sole && sole.roomId !== span.roomId) return null
-    sole ??= span
-  }
-  return sole && index.roomForWallHit(levelId, wallId, sole.face, (sole.t0 + sole.t1) / 2)
-}
-
-function isBoundary(node: AnyNode): node is BoundaryNode {
-  return node.type === 'wall' || node.type === 'separator'
-}
-
-function sameBoundary(a: BoundaryNode, b: AnyNode | undefined) {
-  return (
-    !!b &&
-    isBoundary(b) &&
-    a.type === b.type &&
-    a.parentId === b.parentId &&
-    a.start[0] === b.start[0] &&
-    a.start[1] === b.start[1] &&
-    a.end[0] === b.end[0] &&
-    a.end[1] === b.end[1] &&
-    (a.type === 'separator' ||
-      (b.type === 'wall' &&
-        a.curveOffset === b.curveOffset &&
-        a.thickness === b.thickness &&
-        a.justification === b.justification))
-  )
-}
-
-export class RoomSelectionIndex {
-  readonly topology = createRoomTopologyIndex()
-  private nodes: Nodes | null = null
-  private records: RoomSelectionRecord[] = []
-  private geometry: RoomSelectionGeometry[] = []
-  private candidates: AnyNode[] = []
-  private revision = -1
-  private readonly roomsById = new Map<string, RoomSelectionGeometry>()
-
-  roomAtPoint(_levelId: string, point: [number, number]): RoomSelectionGeometry | null {
-    for (const room of this.geometry)
-      if (!room.mezzanine && containsPoint(room.hitPolygon, point)) return room
-    return null
-  }
-
-  roomForZone(_levelId: string, zoneId: string): RoomSelectionGeometry | null {
-    return this.geometry.find((room) => room.key.zoneId === zoneId) ?? null
-  }
-
-  roomForWallHit(
-    levelId: string,
-    wallId: string,
-    face: 'a' | 'b',
-    t: number,
-  ): RoomSelectionGeometry | null {
-    const spans = this.topology.getLevelTopology(levelId)?.spansByBoundary.get(wallId)
-    if (!spans) return null
-    for (const span of spans) {
-      if (span.face === face && t >= span.t0 && (t < span.t1 || (t === 1 && span.t1 === 1)))
-        return this.roomsById.get(span.roomId) ?? null
-    }
-    return null
-  }
-
-  spansForWall(levelId: string, wallId: string) {
-    return this.topology.spansForWall(levelId, wallId)
-  }
-
-  constructor(readonly levelId: string) {}
-
-  update(nodes: Nodes): RoomSelectionRecord[] {
-    if (nodes === this.nodes) return this.records
-    if (!this.nodes) this.topology.rebuildLevel(this.levelId, nodes)
-    else {
-      const changed = new Set<string>()
-      for (const snapshot of [this.nodes, nodes]) {
-        for (const node of Object.values(snapshot)) {
-          if (
-            isBoundary(node) &&
-            node.parentId === this.levelId &&
-            !sameBoundary(node, snapshot === nodes ? this.nodes[node.id] : nodes[node.id])
-          )
-            changed.add(node.id)
-        }
-      }
-      if (changed.size) this.topology.applyWallDelta(this.levelId, changed, this.nodes, nodes)
-    }
-    this.nodes = nodes
-    const topology = this.topology.getLevelTopology(this.levelId)
-    const geometryChanged = topology?.revision !== this.revision
-    const candidates = Object.values(nodes).filter(
-      (node) =>
-        node.parentId === this.levelId &&
-        (node.type === 'slab' || node.type === 'ceiling' || node.type === 'zone'),
-    )
-    const candidatesChanged =
-      candidates.length !== this.candidates.length ||
-      candidates.some((node, i) => node !== this.candidates[i])
-    if (!geometryChanged && !candidatesChanged) return this.records
-    if (geometryChanged || candidatesChanged) {
-      this.revision = topology?.revision ?? -1
-      const previous = new Map(this.geometry.map((room) => [room.key.zoneId, room]))
-      const matched = new Set<string>()
-      const zones = candidates
-        .filter(
-          (node): node is ZoneNode =>
-            node.type === 'zone' &&
-            node.spaceRole === 'room' &&
-            node.enclosureStatus !== 'open' &&
-            !isMezzanineZone(node),
-        )
-        .sort((a, b) => a.id.localeCompare(b.id))
-      this.geometry = (topology?.rooms ?? []).flatMap((room) => {
-        const boundaryIds = [...new Set(room.spans.map((span) => span.boundaryId))].sort().join('|')
-        const available = zones.filter((zone) => !matched.has(zone.id))
-        const zone =
-          available.find(
-            (node) =>
-              [...node.boundaryWallIds, ...node.boundarySeparatorIds].sort().join('|') ===
-              boundaryIds,
-          ) ??
-          available.find(
-            (node) =>
-              !!node.seed && containsPoint([{ outer: room.polygon, holes: room.holes }], node.seed),
-          )
-        if (!zone) return []
-        matched.add(zone.id)
-        return [
-          (!geometryChanged && previous.get(zone.id)) ||
-            describeRoomGeometry(this.levelId, room, zone),
-        ]
-      })
-      const context = topology?.rooms[0]?.context
-      if (context)
-        for (const zone of candidates) {
-          if (!isMezzanineZone(zone) || zone.spaceRole !== 'room') continue
-          const hosted =
-            zone.hostZoneId && this.geometry.some((room) => room.key.zoneId === zone.hostZoneId)
-          if (!hosted) continue
-          this.geometry.push(describeMezzanineGeometry(this.levelId, zone, context))
-        }
-      this.roomsById.clear()
-      for (const room of this.geometry) this.roomsById.set(room.id, room)
-    }
-    this.candidates = candidates
-    this.records = this.geometry.map((room) => describeRoom(room, candidates))
-    return this.records
-  }
-}