@pascal-app/editor 1.0.3 → 1.0.4

package/src/lib/roof-duplication.ts

@@ -2,6 +2,7 @@
 
 import {
   type AnyNodeId,
+  collectionIdsOf,
   generateId,
   type RoofNode,
   RoofNode as RoofNodeSchema,
@@ -103,6 +104,7 @@ export function duplicateRoofSubtree(
   })
 
   const segmentClones: RoofSegmentNode[] = []
+  const segmentSourceIds: AnyNodeId[] = []
   for (const childId of sourceRoof.children ?? []) {
     const childNode = scene.nodes[childId as AnyNodeId]
     if (childNode?.type !== 'roof-segment') {
@@ -116,11 +118,17 @@ export function duplicateRoofSubtree(
       metadata: buildDuplicateMetadata(childNode.metadata),
     })
     segmentClones.push(childClone)
+    segmentSourceIds.push(childNode.id)
   }
 
+  // Each copy is in the collections its source is in.
   scene.createNodes([
-    { node: roofClone, parentId },
-    ...segmentClones.map((segment) => ({ node: segment, parentId: roofClone.id as AnyNodeId })),
+    { node: roofClone, parentId, collectionIds: collectionIdsOf(scene.collections, sourceRoofId) },
+    ...segmentClones.map((segment, index) => ({
+      node: segment,
+      parentId: roofClone.id as AnyNodeId,
+      collectionIds: collectionIdsOf(scene.collections, segmentSourceIds[index]!),
+    })),
   ])
 
   const nextScene = useScene.getState()

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

@@ -0,0 +1,275 @@
+import { afterEach, describe, expect, test } from 'bun:test'
+import { readFileSync } from 'node:fs'
+import {
+  type AnyNode,
+  BuildingNode,
+  CeilingNode,
+  getWallArcData,
+  getWallFaceOffsets,
+  LevelNode,
+  SlabNode,
+  sceneRegistry,
+  WallNode,
+} from '@pascal-app/core'
+import { migrateCeilingRoomLinks, migrateRoomZones } from '@pascal-app/core/scene-migrations'
+import { BoxGeometry, Mesh, MeshBasicMaterial } from 'three'
+import {
+  buildRoomAssembly,
+  getRoomAssembly,
+  type RoomAssemblyHeights,
+  resolveRoomAssemblyHeights,
+  roomWallFaces,
+} from './room-assembly-overlay'
+import { RoomSelectionIndex, type RoomSelectionRecord } from './room-selection'
+
+const levelId = 'level_room_assembly'
+const buildingId = 'building_room_assembly'
+
+function wall(id: string, start: [number, number], end: [number, number], extra = {}) {
+  return WallNode.parse({
+    id: `wall_${id}`,
+    parentId: levelId,
+    start,
+    end,
+    thickness: 0.2,
+    ...extra,
+  })
+}
+
+function scene(walls: WallNode[], extra: AnyNode[] = []) {
+  const raw = Object.fromEntries(
+    [
+      BuildingNode.parse({ id: buildingId, children: [levelId] }),
+      LevelNode.parse({
+        id: levelId,
+        parentId: buildingId,
+        children: [...walls, ...extra].map((node) => node.id),
+      }),
+      ...walls,
+      ...extra,
+    ].map((node) => [node.id, node]),
+  )
+  return migrateCeilingRoomLinks(migrateRoomZones(raw).nodes).nodes as Record<string, AnyNode>
+}
+
+// Two 4 x 4 rooms split by `shared`, with a T-stem into the east room.
+function twoRooms(extraWalls: WallNode[] = []) {
+  return scene([
+    wall('south', [0, 0], [8, 0]),
+    wall('east', [8, 0], [8, 4]),
+    wall('north', [8, 4], [0, 4]),
+    wall('west', [0, 4], [0, 0]),
+    wall('shared', [4, 0], [4, 4]),
+    ...extraWalls,
+  ])
+}
+
+function roomAt(records: RoomSelectionRecord[], point: [number, number]) {
+  const [x, z] = point
+  return records.find(({ polygon }) => {
+    const xs = polygon.map((p) => p[0])
+    const zs = polygon.map((p) => p[1])
+    return x > Math.min(...xs) && x < Math.max(...xs) && z > Math.min(...zs) && z < Math.max(...zs)
+  })!
+}
+
+function withNodes(nodes: Record<string, AnyNode>, ...added: AnyNode[]) {
+  const level = nodes[levelId] as LevelNode
+  return {
+    ...nodes,
+    ...Object.fromEntries(added.map((node) => [node.id, node])),
+    [levelId]: { ...level, children: [...level.children, ...added.map((node) => node.id)] },
+  } as Record<string, AnyNode>
+}
+
+const heights = (tops: Record<string, number>, floorY = 0): RoomAssemblyHeights => ({
+  floorY,
+  wallTops: new Map(Object.entries(tops)),
+  ceiling: null,
+})
+
+const length = ({ from, to }: { from: readonly number[]; to: readonly number[] }) =>
+  Math.hypot(to[0]! - from[0]!, to[1]! - from[1]!)
+
+function yValues(array: Float32Array) {
+  const ys = new Set<number>()
+  for (let i = 1; i < array.length; i += 3) ys.add(Math.round(array[i]! * 1000) / 1000)
+  return [...ys].sort((a, b) => a - b)
+}
+
+afterEach(() => sceneRegistry.clear())
+
+describe('room assembly faces', () => {
+  test('only the room-facing face, clipped at the partition and the corners', () => {
+    const room = roomAt(new RoomSelectionIndex(levelId).update(twoRooms()), [2, 2])
+    const faces = roomWallFaces(room.geometry)
+    const byWall = new Map<string, typeof faces>()
+    for (const face of faces) byWall.set(face.wallId, [...(byWall.get(face.wallId) ?? []), face])
+    expect([...byWall.keys()].sort()).toEqual(
+      ['wall_north', 'wall_shared', 'wall_south', 'wall_west'].sort(),
+    )
+    const south = byWall.get('wall_south')!
+    expect(south.every(({ face }) => face === 'a')).toBe(true)
+    for (const { from, to } of south) {
+      expect(from[1]).toBeCloseTo(0.1)
+      expect(to[1]).toBeCloseTo(0.1)
+      for (const x of [from[0], to[0]]) {
+        expect(x).toBeGreaterThanOrEqual(0.1 - 1e-6)
+        expect(x).toBeLessThanOrEqual(3.9 + 1e-6)
+      }
+    }
+    expect(south.reduce((sum, face) => sum + length(face), 0)).toBeCloseTo(3.8)
+    // The partition contributes its west face only.
+    for (const { from, to } of byWall.get('wall_shared')!) {
+      expect(from[0]).toBeCloseTo(3.9)
+      expect(to[0]).toBeCloseTo(3.9)
+    }
+  })
+
+  test('a T-stem splits the host face into per-room t-ranges', () => {
+    const nodes = twoRooms([wall('stem', [4, 2], [8, 2])])
+    const records = new RoomSelectionIndex(levelId).update(nodes)
+    const lower = roomAt(records, [6, 1])
+    const upper = roomAt(records, [6, 3])
+    for (const [room, zMin, zMax] of [
+      [lower, 0.1, 1.9],
+      [upper, 2.1, 3.9],
+    ] as const) {
+      const shared = roomWallFaces(room.geometry).filter(({ wallId }) => wallId === 'wall_shared')
+      const span = room.spans.find(({ boundaryId }) => boundaryId === 'wall_shared')!
+      expect(shared.reduce((sum, face) => sum + length(face), 0)).toBeCloseTo(zMax - zMin)
+      for (const { from, to, face } of shared) {
+        expect(face).toBe(span.face)
+        for (const [x, z] of [from, to]) {
+          expect(x).toBeCloseTo(4.1)
+          expect(z).toBeGreaterThanOrEqual(zMin - 1e-6)
+          expect(z).toBeLessThanOrEqual(zMax + 1e-6)
+          const t = z / 4
+          expect(t).toBeGreaterThanOrEqual(span.t0 - 1e-6)
+          expect(t).toBeLessThanOrEqual(span.t1 + 1e-6)
+        }
+      }
+    }
+  })
+
+  test('curved faces follow the offset arc and only draw verticals at their ends', () => {
+    const nodes = twoRooms()
+    const curved = { ...(nodes.wall_shared as WallNode), curveOffset: 0.5 }
+    const room = roomAt(
+      new RoomSelectionIndex(levelId).update({ ...nodes, [curved.id]: curved }),
+      [1, 2],
+    )
+    const faces = roomWallFaces(room.geometry).filter(({ wallId }) => wallId === curved.id)
+    expect(faces.length).toBeGreaterThan(4)
+    const arc = getWallArcData(curved)!
+    const face = faces[0]!.face
+    const radius = arc.radius - arc.direction * getWallFaceOffsets(curved)[face]
+    for (const { from, to } of faces) {
+      for (const [x, z] of [from, to])
+        expect(Math.hypot(x - arc.center.x, z - arc.center.y)).toBeCloseTo(radius, 2)
+    }
+    const tops = Object.fromEntries(room.boundaryWallIds.map((id) => [id, 2.5]))
+    const { outline } = buildRoomAssembly(room.geometry, heights(tops))
+    let verticals = 0
+    for (let i = 0; i < outline.length; i += 6) {
+      if (
+        outline[i + 1]! !== outline[i + 4]! &&
+        Math.hypot(outline[i]! - outline[i + 3]!, outline[i + 2]! - outline[i + 5]!) < 1e-6
+      )
+        verticals++
+    }
+    // Four walls, two run ends each; the arc's chords share their joints.
+    expect(verticals).toBe(8)
+  })
+})
+
+describe('room assembly geometry', () => {
+  test('walls rise from the plate top to their own tops; the ceiling sits at its height', () => {
+    const base = twoRooms()
+    const initial = roomAt(new RoomSelectionIndex(levelId).update(base), [2, 2])
+    const polygon: [number, number][] = [
+      [0.1, 0.1],
+      [3.9, 0.1],
+      [3.9, 3.9],
+      [0.1, 3.9],
+    ]
+    const nodes = withNodes(
+      { ...base, wall_south: { ...(base.wall_south as WallNode), height: 2.1 } },
+      SlabNode.parse({ parentId: levelId, polygon, zoneIds: [initial.zoneId], elevation: 0.3 }),
+      CeilingNode.parse({ parentId: levelId, polygon, zoneId: initial.zoneId, height: 2.4 }),
+    )
+    const room = roomAt(new RoomSelectionIndex(levelId).update(nodes), [2, 2])
+    const resolved = resolveRoomAssemblyHeights(room, nodes)
+    expect(resolved.floorY).toBe(0.3)
+    expect(resolved.ceiling?.y).toBe(2.4)
+    expect(resolved.wallTops.get('wall_south')).toBe(2.1)
+    const planeTop = resolved.wallTops.get('wall_west')!
+    expect(planeTop).toBeGreaterThan(2.1)
+    const assembly = buildRoomAssembly(room.geometry, resolved)
+    expect(yValues(assembly.floor)).toEqual([0.305])
+    expect(yValues(assembly.surfaces)).toEqual(
+      [0.305, 2.1, 2.38, Math.round(planeTop * 1000) / 1000].sort((a, b) => a - b),
+    )
+    expect(yValues(assembly.outline)).toContain(2.38)
+    expect(assembly.floor.length).toBeGreaterThan(0)
+  })
+
+  test('cache hits on the same topology revision and misses on topology or height change', () => {
+    const index = new RoomSelectionIndex(levelId)
+    const nodes = twoRooms()
+    const room = roomAt(index.update(nodes), [2, 2])
+    const tops = Object.fromEntries(room.boundaryWallIds.map((id) => [id, 2.5]))
+    const first = getRoomAssembly(room.geometry, heights(tops))
+    // A fresh heights object with equal values and an unrelated scene edit both hit.
+    expect(getRoomAssembly(room.geometry, heights({ ...tops }))).toBe(first)
+    const zone = nodes[room.zoneId]!
+    const renamed = roomAt(
+      index.update({ ...nodes, [zone.id]: { ...zone, name: 'Kitchen' } as AnyNode }),
+      [2, 2],
+    )
+    expect(renamed.geometry).toBe(room.geometry)
+    expect(getRoomAssembly(renamed.geometry, heights(tops))).toBe(first)
+    expect(getRoomAssembly(room.geometry, heights({ ...tops, wall_south: 2 }))).not.toBe(first)
+    const moved = roomAt(
+      index.update({
+        ...nodes,
+        wall_shared: { ...(nodes.wall_shared as WallNode), start: [5, 0], end: [5, 4] },
+      }),
+      [2, 2],
+    )
+    expect(moved.geometry).not.toBe(room.geometry)
+    const rebuilt = getRoomAssembly(moved.geometry, heights(tops))
+    expect(rebuilt).not.toBe(first)
+    expect(rebuilt.floor.length).toBeGreaterThan(0)
+  })
+
+  test('building and resolving never touch the rendered wall meshes', () => {
+    const nodes = twoRooms()
+    const room = roomAt(new RoomSelectionIndex(levelId).update(nodes), [2, 2])
+    const meshes = room.boundaryWallIds.map((id) => {
+      const mesh = new Mesh(new BoxGeometry(), new MeshBasicMaterial())
+      mesh.userData = { batched: true, pascalId: id }
+      sceneRegistry.nodes.set(id, mesh)
+      return {
+        mesh,
+        material: mesh.material,
+        geometry: mesh.geometry,
+        layers: mesh.layers.mask,
+        userData: structuredClone(mesh.userData),
+        visible: mesh.visible,
+      }
+    })
+    getRoomAssembly(room.geometry, resolveRoomAssemblyHeights(room, nodes))
+    for (const { mesh, material, geometry, layers, userData, visible } of meshes) {
+      expect(mesh.material).toBe(material)
+      expect(mesh.geometry).toBe(geometry)
+      expect(mesh.layers.mask).toBe(layers)
+      expect(mesh.userData).toEqual(userData)
+      expect(mesh.visible).toBe(visible)
+    }
+    for (const file of ['./room-assembly-overlay.ts', '../components/editor/room-highlight.tsx']) {
+      const source = readFileSync(new URL(file, import.meta.url), 'utf8')
+      expect(source).not.toMatch(/\.material\s*=[^=]|userData|sceneRegistry\.nodes\.set/)
+    }
+  })
+})

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

@@ -0,0 +1,266 @@
+import {
+  type AnyNode,
+  type AnyNodeId,
+  area,
+  getWallArcData,
+  getWallBaseElevationForNodes,
+  getWallCurveFrameAt,
+  getWallFaceOffsets,
+  getWallPlaneTop,
+  resolveCeilingHeight,
+  resolveWallTop,
+  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, resolveWallTop(wall, getWallPlaneTop(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,
+  }
+}