@pascal-app/editor 1.0.6 → 1.1.0

package/src/lib/room-push-dimensions.test.ts

@@ -2,17 +2,19 @@ import { describe, expect, test } from 'bun:test'
 import {
   type AnyNode,
   createRoomTopologyIndex,
+  formatLinearMeasurement,
   LevelNode,
   type Point,
   WallNode,
 } from '@pascal-app/core'
-import { formatLinearMeasurement } from './measurements'
 import {
   DIMENSION_FLOOR_LIFT,
   mezzanineEdgeDimensions,
   type RoomDimension,
+  type WallDimensionFaces,
   wallPushDimensionRooms,
   wallPushDimensions,
+  wallSelectionDimensions,
 } from './room-push-dimensions'
 
 // Rooms are real: the walls go through core's room topology, so the faces the
@@ -66,6 +68,20 @@ function measure(
   })
 }
 
+function selection({ nodes, walls }: Scene, wall: WallNode, faces: WallDimensionFaces) {
+  const index = createRoomTopologyIndex()
+  index.rebuildLevel(LEVEL, nodes)
+  const rooms = index.getLevelTopology(LEVEL)?.rooms ?? []
+  return wallSelectionDimensions({
+    rooms: wallPushDimensionRooms(rooms, { wallId: wall.id, t0: 0, t1: 1 }, () => 0),
+    wall,
+    walls,
+    faces,
+    resolve: (id) => nodes[id],
+    baseElevation: 0,
+  })
+}
+
 const distances = (dimensions: RoomDimension[]) =>
   dimensions.map((dimension) => Number(dimension.distance.toFixed(4)))
 
@@ -206,6 +222,27 @@ describe('two rooms sharing the moving wall', () => {
     expect(west.key).not.toBe(east.key)
   })
 
+  test('selected, a shared wall shows both room widths and no outside size, whatever the faces', () => {
+    for (const faces of ['both', 'interior', 'exterior'] as const) {
+      const dimensions = selection(rooms, middle, faces)
+      expect(dimensions.map((dimension) => dimension.faces)).toEqual(['interior', 'interior'])
+      expect(distances(dimensions).sort()).toEqual([3.8, 3.8])
+    }
+  })
+
+  test('selected, an exterior wall adds the outside size across the building', () => {
+    const east = wallAt(rooms, [8, 0], [8, 4])
+    const dimensions = selection(rooms, east, 'both')
+    const outside = dimensions.find((dimension) => dimension.faces === 'exterior')!
+    // Outer face to outer face, past the middle wall, clear of the room width's line.
+    expect(outside.distance).toBeCloseTo(8 + THICKNESS)
+    expect(outside.from[0]).toBeCloseTo(8 + THICKNESS / 2)
+    expect(outside.to[0]).toBeCloseTo(-THICKNESS / 2)
+    expect(distances(dimensions.filter((dimension) => dimension.faces === 'interior'))).toEqual([
+      3.8,
+    ])
+  })
+
   test('a push over part of the wall measures only the rooms along that part', () => {
     const dimensions = measure(rooms, middle, [1, 0], 0, { t0: 0, t1: 0.5 })
     expect(dimensions).toHaveLength(2)

package/src/lib/room-push-dimensions.ts

@@ -4,6 +4,7 @@ import {
   getWallFaceOffsets,
   isCurvedWall,
   type Point,
+  type SeparatorNode,
   type WallNode,
 } from '@pascal-app/core'
 
@@ -153,12 +154,62 @@ export function wallPushDimensionRooms(
   )
 }
 
+/**
+ * The rooms along a pushed edge of invisible walls, as `wallPushDimensionRooms`
+ * reads them along a wall: each room's stretch of the edge's separators, put
+ * on the edge's one `line` (`[0, 1]` its length), faced as that line runs.
+ */
+export function separatorEdgeDimensionRooms(
+  rooms: ReadonlyArray<{ id: string; spans: readonly BoundarySpan[] }>,
+  edge: {
+    line: Pick<SeparatorNode, 'start' | 'end'>
+    separators: ReadonlyArray<{ separatorId: string; t0: number; t1: number }>
+  },
+  resolve: (id: string) => AnyNode | undefined,
+  elevationOf: (roomId: string) => number,
+): PushDimensionRoom[] {
+  const { start, end } = edge.line
+  const dx = end[0] - start[0]
+  const dz = end[1] - start[1]
+  const lengthSq = dx * dx + dz * dz
+  if (lengthSq < 1e-12) return []
+  const members = new Set(edge.separators.map((member) => member.separatorId))
+  const along = ([x, z]: Point) => ((x - start[0]) * dx + (z - start[1]) * dz) / lengthSq
+  return rooms.flatMap((room) =>
+    room.spans.flatMap((own): PushDimensionRoom[] => {
+      const member = edge.separators.find((entry) => entry.separatorId === own.boundaryId)
+      const separator = resolve(own.boundaryId)
+      if (!member || separator?.type !== 'separator') return []
+      const t0 = Math.max(member.t0, own.t0)
+      const t1 = Math.min(member.t1, own.t1)
+      if (t1 - t0 < 1e-4) return []
+      const sx = separator.end[0] - separator.start[0]
+      const sz = separator.end[1] - separator.start[1]
+      const point = (t: number): Point => [separator.start[0] + sx * t, separator.start[1] + sz * t]
+      const [u0, u1] = [along(point(t0)), along(point(t1))]
+      // A separator drawn against the edge's line has its faces the other way round.
+      const same = sx * dx + sz * dz > 0
+      return [
+        {
+          id: room.id,
+          face: same ? own.face : own.face === 'a' ? 'b' : 'a',
+          t0: Math.min(u0, u1),
+          t1: Math.max(u0, u1),
+          others: room.spans.filter((other) => !members.has(other.boundaryId)),
+          elevation: elevationOf(room.id),
+        },
+      ]
+    }),
+  )
+}
+
 /**
  * The live dimensions of a wall push: for every room along the pushed stretch,
  * the moving face (the resting face moved `distance` along `outward` — a push
  * is a pure translation) to each facing parallel boundary of that room, read
  * through `resolve` so the preview's geometry counts. Per side of the wall:
- * nearest first, one per distinct distance, at most three.
+ * nearest first, one per distinct distance, at most three. An edge of
+ * invisible walls is measured as its one line.
  */
 export function wallPushDimensions({
   rooms,
@@ -168,7 +219,7 @@ export function wallPushDimensions({
   resolve,
 }: {
   rooms: readonly PushDimensionRoom[]
-  wall: WallNode
+  wall: WallNode | SeparatorNode
   outward: Point
   distance: number
   resolve: (id: string) => AnyNode | undefined
@@ -195,6 +246,179 @@ export function wallPushDimensions({
   )
 }
 
+/** Whether two dimensions measure the same span, either way round. */
+export function sameRoomDimension(a: RoomDimension, b: RoomDimension): boolean {
+  const near = (p: Point, q: Point) => Math.hypot(p[0] - q[0], p[1] - q[1]) < 1e-3
+  return (near(a.from, b.from) && near(a.to, b.to)) || (near(a.from, b.to) && near(a.to, b.from))
+}
+
+/** A selected wall's temporary dimension: a room width (ID) or the outside size (OD). */
+export type WallSelectionDimension = RoomDimension & { faces: 'interior' | 'exterior' }
+
+/** A selection's temporary dimension with the node it runs from: typing it moves that node. */
+export type OwnedSelectionDimension = WallSelectionDimension & { ownerId: string }
+
+/**
+ * Several selected nodes' temporary dimensions as one list, keys unique across
+ * owners. Two selected walls across one room both measure it: the width shows
+ * once, owned by the first.
+ */
+export function mergeSelectionDimensions(
+  owners: ReadonlyArray<{ ownerId: string; dimensions: readonly WallSelectionDimension[] }>,
+): OwnedSelectionDimension[] {
+  const kept: OwnedSelectionDimension[] = []
+  for (const { ownerId, dimensions } of owners)
+    for (const dimension of dimensions)
+      if (!kept.some((other) => sameRoomDimension(other, dimension)))
+        kept.push({ ...dimension, key: `${ownerId}:${dimension.key}`, ownerId })
+  return kept
+}
+
+/** Which faces a selected wall's temporary dimensions measure to. */
+export type WallDimensionFaces = 'interior' | 'exterior' | 'both'
+
+const CONNECTION_TOLERANCE = 0.03
+/** Where along the shared stretch the outside size is drawn, clear of the room widths at its middle. */
+const EXTERIOR_DIMENSION_AT = 0.25
+
+function pointSegmentDistance(p: Point, a: Point, b: Point): number {
+  const dx = b[0] - a[0]
+  const dz = b[1] - a[1]
+  const lengthSq = dx * dx + dz * dz
+  const t =
+    lengthSq < 1e-12
+      ? 0
+      : Math.max(0, Math.min(1, ((p[0] - a[0]) * dx + (p[1] - a[1]) * dz) / lengthSq))
+  return Math.hypot(p[0] - (a[0] + dx * t), p[1] - (a[1] + dz * t))
+}
+
+function wallsTouch(left: WallNode, right: WallNode): boolean {
+  return (
+    [left.start, left.end].some(
+      (p) => pointSegmentDistance(p, right.start, right.end) <= CONNECTION_TOLERANCE,
+    ) ||
+    [right.start, right.end].some(
+      (p) => pointSegmentDistance(p, left.start, left.end) <= CONNECTION_TOLERANCE,
+    )
+  )
+}
+
+/** The walls joined to `wall` through shared corners and T junctions, itself included. */
+function connectedWalls(wall: WallNode, walls: readonly WallNode[]): WallNode[] {
+  const found = new Map<string, WallNode>([[wall.id, wall]])
+  const queue = [wall]
+  for (let current = queue.pop(); current; current = queue.pop()) {
+    for (const candidate of walls) {
+      if (found.has(candidate.id) || !wallsTouch(current, candidate)) continue
+      found.set(candidate.id, candidate)
+      queue.push(candidate)
+    }
+  }
+  return [...found.values()]
+}
+
+/**
+ * The outside size across the building from a wall's exterior face: to the
+ * far face of the farthest parallel wall of the same connected building that
+ * shares some of its length — the opposite exterior wall. Null when nothing
+ * is across (a lone wall, a curved one).
+ */
+function overallExteriorDimension(
+  wall: WallNode,
+  exteriorFace: 'a' | 'b',
+  walls: readonly WallNode[],
+): Measured | null {
+  const own = boundaryFace(wall, 0, 1, exteriorFace)
+  if (!own) return null
+  const dx = own.end[0] - own.start[0]
+  const dz = own.end[1] - own.start[1]
+  const length = Math.hypot(dx, dz)
+  const dir: Point = [dx / length, dz / length]
+  // The face's room-ward normal points out of the building here: across is its opposite.
+  const across: Point = [-own.inward[0], -own.inward[1]]
+  const along = (p: Point) => (p[0] - own.start[0]) * dir[0] + (p[1] - own.start[1]) * dir[1]
+  let best: { distance: number; lo: number; hi: number } | null = null
+  for (const other of connectedWalls(wall, walls)) {
+    if (other.id === wall.id) continue
+    for (const face of ['a', 'b'] as const) {
+      const candidate = boundaryFace(other, 0, 1, face)
+      if (!candidate) continue
+      const fx = candidate.end[0] - candidate.start[0]
+      const fz = candidate.end[1] - candidate.start[1]
+      const faceLength = Math.hypot(fx, fz)
+      if (Math.abs(dir[0] * fz - dir[1] * fx) / faceLength > PARALLEL_SIN) continue
+      const distance =
+        (candidate.start[0] - own.start[0]) * across[0] +
+        (candidate.start[1] - own.start[1]) * across[1]
+      if (distance <= MIN_GAP) continue
+      const a = along(candidate.start)
+      const b = along(candidate.end)
+      const lo = Math.max(0, Math.min(a, b))
+      const hi = Math.min(length, Math.max(a, b))
+      if (hi - lo < MIN_OVERLAP) continue
+      if (!best || distance > best.distance + SAME_DISTANCE) best = { distance, lo, hi }
+    }
+  }
+  if (!best) return null
+  const at = (u: number): Point => [own.start[0] + dir[0] * u, own.start[1] + dir[1] * u]
+  const [lo, hi] = [at(best.lo), at(best.hi)]
+  // Measured from the same end of the stretch whichever way the wall was drawn,
+  // so the walls on either side of the building put their outside size in one place.
+  const fromLo = Math.abs(lo[0] - hi[0]) > 1e-6 ? lo[0] < hi[0] : lo[1] <= hi[1]
+  const offset = (best.hi - best.lo) * EXTERIOR_DIMENSION_AT
+  const from = at(fromLo ? best.lo + offset : best.hi - offset)
+  return {
+    from,
+    to: [from[0] + across[0] * best.distance, from[1] + across[1] * best.distance],
+    distance: best.distance,
+  }
+}
+
+/**
+ * The temporary dimensions of a selected wall at rest, in 2D and 3D: the room
+ * widths a push of it shows (its face to each facing wall, both sides — ID),
+ * and for an exterior wall the outside size across the building (OD). `faces`
+ * picks which; a wall with no outside (rooms on both faces) shows its room
+ * widths whatever the choice. Each dimension runs `from` the selected wall,
+ * so typing a value moves that wall (`commitDimensionValue`).
+ */
+export function wallSelectionDimensions({
+  rooms,
+  wall,
+  walls,
+  faces,
+  resolve,
+  baseElevation,
+}: {
+  rooms: readonly PushDimensionRoom[]
+  wall: WallNode
+  /** The level's walls, for the opposite exterior wall. */
+  walls: readonly WallNode[]
+  faces: WallDimensionFaces
+  resolve: (id: string) => AnyNode | undefined
+  /** The wall's base, for a dimension with no room floor to stand on. */
+  baseElevation: number
+}): WallSelectionDimension[] {
+  const interior = wallPushDimensions({ rooms, wall, outward: [0, 0], distance: 0, resolve }).map(
+    (dimension): WallSelectionDimension => ({ ...dimension, faces: 'interior' }),
+  )
+  const roomFaces = new Set(rooms.map((room) => room.face))
+  const exteriorFace = roomFaces.size === 1 ? (roomFaces.has('a') ? 'b' : 'a') : null
+  if (!exteriorFace || faces === 'interior') return interior
+  const overall = overallExteriorDimension(wall, exteriorFace, walls)
+  const exterior: WallSelectionDimension[] = overall
+    ? [
+        {
+          ...overall,
+          key: 'exterior',
+          faces: 'exterior',
+          elevation: (rooms[0]?.elevation ?? baseElevation) + DIMENSION_FLOOR_LIFT,
+        },
+      ]
+    : []
+  return faces === 'exterior' ? exterior : [...interior, ...exterior]
+}
+
 /**
  * The live dimensions of a mezzanine edge push: the resting edge moved
  * `distance` along `outward`, to each facing parallel edge of the outline the

package/src/lib/room-selection.test.ts

@@ -868,17 +868,34 @@ describe('room drill-down state through the mounted selection manager', () => {
       expect(useViewer.getState().selection.selectedIds).toEqual(['wall_free'])
     })
   })
-  test('the 2D plan resolves walls room-first and drills on the second click', async () => {
+  test('the 2D plan gives a wall hit to the wall and a room interior to the room', async () => {
     await withRooms(async ({ left, right }) => {
-      expect(resolvePlanRoomHit('wall_west', [-0.05, 2])).toEqual(left)
+      // Without the kind's `planHitSelectsNode`, a band hit stays room-first.
       expect(resolvePlanRoomHit('wall_shared', [3.95, 2])).toEqual(left)
-      expect(resolvePlanRoomHit('wall_shared', [4.05, 2])).toEqual(right)
-      expect(resolvePlanRoomHit('wall_free', [9.95, 1])).toBeNull()
-      const hit = resolvePlanRoomHit('wall_west', [-0.05, 2])
+      // The wall definition declares it (its floor-plan extension).
+      const get = nodeRegistry.get.bind(nodeRegistry)
+      const spy = spyOn(nodeRegistry, 'get').mockImplementation(((kind: string) =>
+        kind === 'wall'
+          ? ({
+              ...get(kind),
+              extensions: { 'pascal:editor/floorplan': { planHitSelectsNode: true } },
+            } as AnyNodeDefinition)
+          : get(kind)) as typeof nodeRegistry.get)
+      try {
+        // Either half of a shared wall's band is the wall, never the room beside it.
+        expect(resolvePlanRoomHit('wall_west', [-0.05, 2])).toBeNull()
+        expect(resolvePlanRoomHit('wall_shared', [3.95, 2])).toBeNull()
+        expect(resolvePlanRoomHit('wall_shared', [4.05, 2])).toBeNull()
+        expect(resolvePlanRoomHit('wall_free', [9.95, 1])).toBeNull()
+      } finally {
+        spy.mockRestore()
+      }
+      expect(resolvePlanRoomHit(null, [2, 2])).toEqual(left)
+      expect(resolvePlanRoomHit(null, [6, 2])).toEqual(right)
       const select = async (modifiers = plain) => {
         let selected = false
         await act(async () => {
-          selected = selectRoomFromHit(hit, modifiers, 'wall_west')
+          selected = selectRoomFromHit(resolvePlanRoomHit(null, [2, 2]), modifiers, null)
         })
         return selected
       }

package/src/lib/scene-bounds.test.ts

@@ -172,6 +172,150 @@ describe('computeSceneBoundsXZ', () => {
     expect(bounds!.center).toEqual([2, 2])
   })
 
+  describe('ancestor transforms', () => {
+    function makeBuilding(
+      id: string,
+      position: [number, number, number],
+      rotationY = 0,
+      parentId: string | null = null,
+    ): AnyNode {
+      return {
+        object: 'node',
+        id,
+        type: 'building',
+        parentId,
+        visible: true,
+        metadata: {},
+        children: [],
+        position,
+        rotation: [0, rotationY, 0],
+      } as unknown as AnyNode
+    }
+
+    function makeLevel(id: string, parentId: string): AnyNode {
+      return {
+        object: 'node',
+        id,
+        type: 'level',
+        parentId,
+        visible: true,
+        metadata: {},
+        children: [],
+        level: 0,
+      } as unknown as AnyNode
+    }
+
+    function child(node: AnyNode, parentId: string): AnyNode {
+      return { ...node, parentId } as AnyNode
+    }
+
+    function expectClose(actual: [number, number], expected: [number, number]) {
+      expect(actual[0]).toBeCloseTo(expected[0], 9)
+      expect(actual[1]).toBeCloseTo(expected[1], 9)
+    }
+
+    test('carries building-local walls and zones through a translated building', () => {
+      const nodes = [
+        makeBuilding('building_a', [100, 0, 100]),
+        makeLevel('level_a', 'building_a'),
+        child(makeWall([-5, -4], [5, -4]), 'level_a'),
+        child(
+          makeZone([
+            [-5, -4],
+            [5, -4],
+            [5, 4],
+            [-5, 4],
+          ]),
+          'level_a',
+        ),
+      ]
+      const bounds = computeSceneBoundsXZ(nodes)!
+      expectClose(bounds.min, [95, 96])
+      expectClose(bounds.max, [105, 104])
+      expectClose(bounds.center, [100, 100])
+    })
+
+    test('turns building-local geometry by the building yaw', () => {
+      // three.js Y rotation by +90°: local (x, z) → (z, −x).
+      const nodes = [
+        makeBuilding('building_r', [10, 0, 0], Math.PI / 2),
+        makeLevel('level_r', 'building_r'),
+        child(makeWall([0, 0], [8, 0]), 'level_r'),
+        child(makeWall([8, 0], [8, 2]), 'level_r'),
+      ]
+      const bounds = computeSceneBoundsXZ(nodes)!
+      expectClose(bounds.min, [10, -8])
+      expectClose(bounds.max, [12, 0])
+      expectClose(bounds.size, [2, 8])
+    })
+
+    test('composes nested positioned and rotated ancestors', () => {
+      const item = {
+        object: 'node',
+        id: 'item_host',
+        type: 'item',
+        parentId: 'level_n',
+        visible: true,
+        metadata: {},
+        children: [],
+        position: [2, 0, 0],
+        rotation: [0, Math.PI / 2, 0],
+      } as unknown as AnyNode
+      const hosted = {
+        object: 'node',
+        id: 'item_hosted',
+        type: 'item',
+        parentId: 'item_host',
+        visible: true,
+        metadata: {},
+        children: [],
+        position: [1, 0, 0],
+        rotation: [0, 0, 0],
+      } as unknown as AnyNode
+      // Building at (50, 50) turned 90°: the host lands at (50, 48), and the
+      // hosted item (1, 0) under a total 180° yaw lands one metre further −x.
+      const nodes = [
+        makeBuilding('building_n', [50, 0, 50], Math.PI / 2),
+        makeLevel('level_n', 'building_n'),
+        item,
+        hosted,
+      ]
+      const bounds = computeSceneBoundsXZ(nodes)!
+      expectClose(bounds.min, [49, 48])
+      expectClose(bounds.max, [50, 50])
+    })
+
+    test('leaves geometry under an untransformed building unchanged', () => {
+      const nodes = [
+        makeBuilding('building_0', [0, 0, 0]),
+        makeLevel('level_0', 'building_0'),
+        child(makeWall([0, 0], [4, 0]), 'level_0'),
+        child(makeWall([4, 0], [4, 3]), 'level_0'),
+      ]
+      const bounds = computeSceneBoundsXZ(nodes)!
+      expect(bounds.min).toEqual([0, 0])
+      expect(bounds.max).toEqual([4, 3])
+    })
+  })
+
+  test('a door on a wall is bounded by the wall, not its wall-local position', () => {
+    const wall = makeWall([50, 50], [60, 50])
+    const door = {
+      object: 'node',
+      id: 'door_1',
+      type: 'door',
+      parentId: wall.id,
+      visible: true,
+      metadata: {},
+      position: [2, 1, 0],
+    } as unknown as AnyNode
+    const bounds = computeSceneBoundsXZ([wall, door])
+    expect(bounds).not.toBeNull()
+    expect(bounds!.min[0]).toBe(50)
+    expect(bounds!.max[0]).toBe(60)
+    expect(bounds!.center).toEqual([55, 50])
+  })
+
   test('skips non-finite coordinates', () => {
     const nodes: AnyNode[] = [makeWall([Number.NaN, 0], [4, 2]), makeWall([0, 0], [1, 1])]
     const bounds = computeSceneBoundsXZ(nodes)

package/src/lib/scene-bounds.ts

@@ -11,6 +11,7 @@
  * tree and derives an axis-aligned bounding box on the XZ (plan) plane.
  */
 
+import { turnPlanPoint, yawOf } from '@pascal-app/core'
 import type { AnyNode } from '@pascal-app/core/schema'
 
 export type SceneBoundsXZ = {
@@ -27,13 +28,19 @@ export type SceneBoundsXZ = {
 // A very small guard against degenerate bounds (e.g. a single wall of zero length).
 const MIN_BOUNDS_EXTENT = 0.0001
 
-function extendPoint(
-  acc: { minX: number; minZ: number; maxX: number; maxZ: number; hasPoint: boolean },
-  x: unknown,
-  z: unknown,
-): void {
-  if (typeof x !== 'number' || typeof z !== 'number') return
-  if (!(Number.isFinite(x) && Number.isFinite(z))) return
+/** A node's plan frame in world XZ: local (x, z) → origin + turnPlanPoint(x, z, yaw). */
+type PlanFrame = { x: number; z: number; yaw: number }
+
+const WORLD_FRAME: PlanFrame = { x: 0, z: 0, yaw: 0 }
+
+type BoundsAcc = { minX: number; minZ: number; maxX: number; maxZ: number; hasPoint: boolean }
+
+function extendPoint(acc: BoundsAcc, frame: PlanFrame, localX: unknown, localZ: unknown): void {
+  if (typeof localX !== 'number' || typeof localZ !== 'number') return
+  if (!(Number.isFinite(localX) && Number.isFinite(localZ))) return
+  const [tx, tz] = frame.yaw === 0 ? [localX, localZ] : turnPlanPoint(localX, localZ, frame.yaw)
+  const x = frame.x + tx
+  const z = frame.z + tz
   if (x < acc.minX) acc.minX = x
   if (x > acc.maxX) acc.maxX = x
   if (z < acc.minZ) acc.minZ = z
@@ -50,6 +57,9 @@ function extendPoint(
  *   - `polygon`      → zone, slab, site-boundary polygons.
  *   - `position`     → building/item/door/window position; uses [x, z] only.
  *
+ * Each point is in its parent's frame, so it is carried to world XZ through
+ * the ancestors' `position` and `rotation` yaw (a moved or turned building).
+ *
  * Site-node polygons are intentionally excluded when they are the default
  * 30×30 bootstrap polygon — otherwise a brand-new empty scene would frame
  * an empty square around the origin. We still include site polygons that
@@ -63,7 +73,7 @@ export function computeSceneBoundsXZ(
   const list: AnyNode[] = Array.isArray(nodes) ? nodes : Object.values(nodes)
   if (list.length === 0) return null
 
-  const acc = {
+  const acc: BoundsAcc = {
     minX: Number.POSITIVE_INFINITY,
     minZ: Number.POSITIVE_INFINITY,
     maxX: Number.NEGATIVE_INFINITY,
@@ -71,15 +81,24 @@ export function computeSceneBoundsXZ(
     hasPoint: false,
   }
 
+  const byId = new Map<string, AnyNode>()
+  for (const node of list) {
+    if (node && typeof node === 'object' && typeof node.id === 'string') byId.set(node.id, node)
+  }
+  const frameOf = createFrameResolver(byId)
+
   for (const node of list) {
     if (!node || typeof node !== 'object') continue
     const anyNode = node as unknown as Record<string, unknown>
+    // A node's own fields live in its parent's frame (a building's walls are
+    // building-local), so every point goes through the ancestors' transforms.
+    const frame = frameOf(node.parentId ?? null)
 
     // Wall / fence endpoints in level coordinates.
     const start = anyNode.start as unknown
     const end = anyNode.end as unknown
-    if (Array.isArray(start) && start.length >= 2) extendPoint(acc, start[0], start[1])
-    if (Array.isArray(end) && end.length >= 2) extendPoint(acc, end[0], end[1])
+    if (Array.isArray(start) && start.length >= 2) extendPoint(acc, frame, start[0], start[1])
+    if (Array.isArray(end) && end.length >= 2) extendPoint(acc, frame, end[0], end[1])
 
     // Zone / slab polygons (and explicit polygon-shaped site boundaries).
     const polygon = anyNode.polygon as unknown
@@ -88,7 +107,7 @@ export function computeSceneBoundsXZ(
       // points under `polygon.points` (a discriminated PropertyLineData shape).
       for (const point of polygon) {
         if (Array.isArray(point) && point.length >= 2) {
-          extendPoint(acc, point[0], point[1])
+          extendPoint(acc, frame, point[0], point[1])
         }
       }
     } else if (
@@ -105,16 +124,18 @@ export function computeSceneBoundsXZ(
       } else {
         for (const point of points) {
           if (Array.isArray(point) && point.length >= 2) {
-            extendPoint(acc, point[0], point[1])
+            extendPoint(acc, frame, point[0], point[1])
           }
         }
       }
     }
 
-    // Position on the XZ plane (3D position = [x, y, z]).
+    // Position on the XZ plane (3D position = [x, y, z]). A node hosted on a
+    // wall (door, window, wall item) has a wall-local position, and the
+    // wall's endpoints already bound it.
     const position = anyNode.position as unknown
-    if (Array.isArray(position) && position.length >= 3) {
-      extendPoint(acc, position[0], position[2])
+    if (Array.isArray(position) && position.length >= 3 && !isWallHosted(node, byId)) {
+      extendPoint(acc, frame, position[0], position[2])
     }
   }
 
@@ -146,6 +167,49 @@ export function computeSceneBoundsXZ(
   }
 }
 
+/**
+ * World plan frame of each node, composed down the parent chain the way the
+ * renderers nest groups: a node with a `position` (building, item) translates
+ * its children and turns them by its `rotation` yaw; nodes without one (site,
+ * level) pass their parent's frame through.
+ */
+function createFrameResolver(byId: Map<string, AnyNode>): (id: string | null) => PlanFrame {
+  const cache = new Map<string, PlanFrame>()
+  const resolving = new Set<string>()
+
+  const resolve = (id: string | null): PlanFrame => {
+    if (!id) return WORLD_FRAME
+    const cached = cache.get(id)
+    if (cached) return cached
+    const node = byId.get(id)
+    if (!node || resolving.has(id)) return WORLD_FRAME
+    resolving.add(id)
+    const parent = resolve(node.parentId ?? null)
+    resolving.delete(id)
+
+    const anyNode = node as unknown as Record<string, unknown>
+    const position = anyNode.position
+    let frame = parent
+    if (Array.isArray(position) && position.length >= 3) {
+      const px = Number.isFinite(position[0]) ? (position[0] as number) : 0
+      const pz = Number.isFinite(position[2]) ? (position[2] as number) : 0
+      const [tx, tz] = turnPlanPoint(px, pz, parent.yaw)
+      frame = { x: parent.x + tx, z: parent.z + tz, yaw: parent.yaw + yawOf(anyNode.rotation) }
+    }
+    cache.set(id, frame)
+    return frame
+  }
+
+  return resolve
+}
+
+function isWallHosted(node: AnyNode, byId: Map<string, AnyNode>): boolean {
+  const parent = node.parentId ? byId.get(node.parentId) : undefined
+  if (!parent) return false
+  const anyParent = parent as unknown as Record<string, unknown>
+  return Array.isArray(anyParent.start) && Array.isArray(anyParent.end)
+}
+
 /**
  * Matches the `SiteNode` bootstrap polygon defined in
  * `packages/core/src/schema/nodes/site.ts` (a 30×30 square at the origin).