@pascal-app/editor 1.0.4 → 1.0.5

package/src/lib/level-selection.ts

@@ -1,5 +1,5 @@
 import type { AnyNodeId, BuildingNode, LevelNode } from '@pascal-app/core'
-import { useScene } from '@pascal-app/core'
+import { findLevelAncestorId, useScene } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
 
 function getAdjacentLevelIdForDeletion(levelId: AnyNodeId): LevelNode['id'] | null {
@@ -29,3 +29,18 @@ export function deleteLevelWithFallbackSelection(levelId: AnyNodeId) {
     useViewer.getState().setSelection({ levelId: nextLevelId })
   }
 }
+
+/**
+ * Selects a node a tool just made, on its own level when that is not the one in view: a roof drawn
+ * over a storey's walls lands on the level above, which the editor hides while the storey is
+ * selected, so selecting it there alone would leave it out of sight.
+ */
+export function selectPlacedNode(nodeId: AnyNodeId) {
+  const levelId = findLevelAncestorId(nodeId, useScene.getState().nodes)
+  const { selection, setSelection } = useViewer.getState()
+  setSelection(
+    levelId && levelId !== selection.levelId
+      ? { levelId: levelId as LevelNode['id'], selectedIds: [nodeId] }
+      : { selectedIds: [nodeId] },
+  )
+}

package/src/lib/lot/clean-ring.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, test } from 'bun:test'
+import { classifyEdges, setbackEnvelope } from '@pascal-app/core'
 import type { Pt } from '../floorplan/site-plan/geometry'
-import { classifyEdges, polygonArea, setbackEnvelope } from '../floorplan/site-plan/geometry'
+import { polygonArea } from '../floorplan/site-plan/geometry'
 import {
   cleanLotRing,
   describeRingCleanup,

package/src/lib/lot/drop-in.ts

@@ -24,15 +24,12 @@
 import {
   type AnyNode,
   type AnyNodeId,
-  type BuildingNode,
   generateId,
+  placeBuildingPose,
   SiteNode,
+  siteBrief,
   useScene,
 } from '@pascal-app/core'
-import {
-  buildingRecentreOffset,
-  buildSitePlanDrawing,
-} from '../floorplan/site-plan/build-site-plan-drawing'
 import {
   answered,
   type CodeBasisData,
@@ -339,27 +336,15 @@ export async function dropInLot(
     terrainFailure = 'skipped'
   }
 
-  // Centre the building on the lot when its footprint fell outside the new ring.
+  // A house the new lot leaves past its lines stands centred on the buildable area again, facing
+  // as it did.
   let recentred = false
   const after = useScene.getState()
-  const drawing = buildSitePlanDrawing({
-    collections: after.collections,
-    installedPlugins: after.installedPlugins,
-    materials: after.materials,
-    nodes: after.nodes,
-    rootNodeIds: after.rootNodeIds,
-  })
-  const offset = buildingRecentreOffset(drawing.meta.lot, drawing.meta.footprintBounds)
-  if (offset && drawing.meta.buildingId) {
-    const building = after.nodes[drawing.meta.buildingId as AnyNodeId] as BuildingNode | undefined
-    if (building) {
-      after.updateNode(building.id, {
-        position: [
-          building.position[0] + offset[0],
-          building.position[1],
-          building.position[2] + offset[1],
-        ],
-      })
+  const brief = siteBrief(after.nodes)
+  if (brief?.buildingId && brief.footprint?.fit === 'outside') {
+    const placed = placeBuildingPose(after.nodes, { buildingId: brief.buildingId })
+    if (placed.ok && placed.moved) {
+      after.updateNode(placed.buildingId as AnyNodeId, { position: placed.position })
       recentred = true
     }
   }

package/src/lib/lot/lot-patch.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from 'bun:test'
-import { edgeLength } from '../floorplan/site-plan/geometry'
+import { edgeLength } from '@pascal-app/core'
 import {
   DEFAULT_SETBACKS_M,
   DEFAULT_SETBACKS_SOURCE,

package/src/lib/lot/lot-patch.ts

@@ -22,13 +22,13 @@
  * - `northRotation` is 0: the parcel frame is x east / z south, so plan up
  *   is true north.
  */
-import type { SiteNode, SiteSetbacks } from '@pascal-app/core'
+import { edgeLength, type SiteNode, type SiteSetbacks } from '@pascal-app/core'
 import {
   detectFrontEdgeFromRoads,
   type FrontEdgeMatch,
   type RoadCenterline,
 } from '../floorplan/site-plan/front-edge'
-import { edgeLength, METRES_PER_FOOT, type Pt } from '../floorplan/site-plan/geometry'
+import { METRES_PER_FOOT, type Pt } from '../floorplan/site-plan/geometry'
 import { sameStreet } from '../floorplan/site-plan/street-name'
 import { cleanLotRing, describeRingCleanup } from './clean-ring'
 import { detectFrontEdgeFromFrontage, type FrontageMatch } from './dossier'

package/src/lib/measurement-kind.test.ts

@@ -19,12 +19,10 @@ describe('creatable measurement kinds', () => {
     }
   })
 
-  test.each([
-    'smart',
-    'unknown',
-    null,
-    undefined,
-  ])('falls back from a non-creatable persisted value: %s', (value) => {
-    expect(normalizeCreatableMeasurementKind(value)).toBe(DEFAULT_CREATABLE_MEASUREMENT_KIND)
-  })
+  test.each(['smart', 'unknown', null, undefined])(
+    'falls back from a non-creatable persisted value: %s',
+    (value) => {
+      expect(normalizeCreatableMeasurementKind(value)).toBe(DEFAULT_CREATABLE_MEASUREMENT_KIND)
+    },
+  )
 })

package/src/lib/measurements.test.ts

@@ -1,4 +1,5 @@
 import { describe, expect, test } from 'bun:test'
+import { measurementHint, parseMeasurement } from '../index'
 import {
   buildMeasurementAngleArcPoints,
   cubicMetersToVolumeUnit,
@@ -190,3 +191,25 @@ describe('volume measurements', () => {
     expect(formatVolumeLabel(Number.NEGATIVE_INFINITY, 'metric')).toBe('--')
   })
 })
+
+describe('typed measurement fields', () => {
+  test('canonicalizes explicit, compound, and scientific dimensions', () => {
+    const length = { kind: 'length', unitId: 'm' } as const
+    expect(parseMeasurement('180cm', length)).toBeCloseTo(1.8)
+    expect(parseMeasurement('1m80', length)).toBeCloseTo(1.8)
+    expect(parseMeasurement(`5'11"`, length)).toBeCloseTo(1.8034)
+    expect(parseMeasurement('1.234e-4 m', length)).toBeCloseTo(0.0001234, 10)
+    expect(parseMeasurement('6', length, { bareUnit: 'ft' })).toBeCloseTo(1.8288)
+    expect(parseMeasurement('180deg', { kind: 'angle', unitId: 'rad' })).toBeCloseTo(Math.PI)
+  })
+
+  test('rejects ranges, incomplete arithmetic, and nonfinite input', () => {
+    const length = { kind: 'length', unitId: 'm' } as const
+    for (const input of ['2+3 m', '2-3 m', 'between 2 and 3 m', '1e999 m']) {
+      expect(parseMeasurement(input, length)).toBeNull()
+      expect(measurementHint(input, length)).toBeNull()
+    }
+    expect(measurementHint('180cm', length)).toBe('= 1.80 m')
+    expect(measurementHint('6', length)).toBeNull()
+  })
+})

package/src/lib/orbit-floor-clearance.test.ts

@@ -1,5 +1,8 @@
 import { expect, test } from 'bun:test'
 import {
+  DIVE_DEPTH,
+  DIVE_MARGIN,
+  diveFloorY,
   floorLimitAt,
   glideFloorLimit,
   LOOK_UP_PITCH_GAIN,
@@ -7,8 +10,11 @@ import {
   MAX_ORBIT_POLAR_ANGLE,
   ORBIT_FLOOR_CLEARANCE,
   ORBIT_TARGET_HEIGHT,
+  OVERVIEW_GROUND_CLEARANCE,
   orbitAngleBelowFloor,
   orbitCameraAboveFloor,
+  orbitFloorMinY,
+  overviewEyeY,
 } from './orbit-floor-clearance'
 
 type Vec3 = { x: number; y: number; z: number }
@@ -163,3 +169,33 @@ test('a change in floor height is glided over, never popped', () => {
   }
   expect(limit).toBeCloseTo(0.75, 6)
 })
+
+test('a pivot sent four storeys down keeps the eye where it was, over the ground; a diver stays under', () => {
+  // Eye 12 m up over a pivot at 1.1; the pivot goes to -12: the move alone would put the eye at -0.1.
+  expect(overviewEyeY(12 - 13.1, 12, -0.05, false)).toBe(12)
+  // An eye that was already low is brought up to the clearance.
+  expect(overviewEyeY(-9, 0.5, -0.05, false)).toBe(-0.05 + OVERVIEW_GROUND_CLEARANCE)
+  // The move leaves it high enough: it goes with the pivot, as always.
+  expect(overviewEyeY(20, 25, -0.05, false)).toBe(20)
+  // The person is under the ground: the move is theirs.
+  expect(overviewEyeY(-8, 12, -0.05, true)).toBe(-8)
+})
+
+test('the dive floor sits 3 m under the lowest ground, or 1 m under the deepest drawn thing when that is deeper', () => {
+  // A house at grade: nothing drawn is deeper than the ground's 3 m.
+  expect(diveFloorY(-0.05, -0.36)).toBeCloseTo(-0.05 - DIVE_DEPTH, 9)
+  expect(diveFloorY(-0.05, null)).toBeCloseTo(-0.05 - DIVE_DEPTH, 9)
+  // The villa's basement footing at -3.83 goes a metre deeper.
+  expect(diveFloorY(-0.05, -3.83)).toBeCloseTo(-3.83 - DIVE_MARGIN, 9)
+})
+
+test('the eye may sit the clearance over the dive floor from any storey, over the level floor otherwise', () => {
+  const dive = diveFloorY(-0.05, null)
+  // The ground floor, and a storey four metres up: both dive to the same floor.
+  expect(orbitFloorMinY(0, dive)).toBeCloseTo(dive + ORBIT_FLOOR_CLEARANCE, 9)
+  expect(orbitFloorMinY(4, dive)).toBeCloseTo(dive + ORBIT_FLOOR_CLEARANCE, 9)
+  // No dive (Solid): the level's floor, as before.
+  expect(orbitFloorMinY(4, null)).toBeCloseTo(4 + ORBIT_FLOOR_CLEARANCE, 9)
+  // A basement deeper than the dive floor keeps its own floor: the dive never lifts the limit.
+  expect(orbitFloorMinY(-12, dive)).toBeCloseTo(-12 + ORBIT_FLOOR_CLEARANCE, 9)
+})

package/src/lib/orbit-floor-clearance.ts

@@ -11,8 +11,31 @@ export const ORBIT_FLOOR_CLEARANCE = 0.45
  */
 export const ORBIT_TARGET_HEIGHT = 1.1
 
+/**
+ * The dive under the ground: with the ground on Auto the orbit's eye may leave the ground for the
+ * earth under any building, down to a floor this far under the lowest ground, or this far under
+ * the deepest thing drawn (a basement's footing), whichever is deeper.
+ */
+export const DIVE_DEPTH = 3
+export const DIVE_MARGIN = 1
+
 const DEGREE = Math.PI / 180
 
+/** The floor of the dive, world Y: the eye's clearance over it is {@link ORBIT_FLOOR_CLEARANCE}. */
+export function diveFloorY(lowestGroundY: number, deepestDrawnY: number | null): number {
+  const underGround = lowestGroundY - DIVE_DEPTH
+  return deepestDrawnY === null ? underGround : Math.min(underGround, deepestDrawnY - DIVE_MARGIN)
+}
+
+/**
+ * The lowest the orbit's eye may sit: the clearance over the selected level's floor, or over the
+ * dive's floor when the person may dive and it lies deeper (`diveFloor` null: no dive). Selecting a
+ * level never lifts the limit above the dive floor, so a dive works from any storey.
+ */
+export function orbitFloorMinY(levelFloorY: number, diveFloor: number | null): number {
+  return Math.min(levelFloorY, diveFloor ?? levelFloorY) + ORBIT_FLOOR_CLEARANCE
+}
+
 /** The steepest an orbit camera looks: straight down is 0, straight up π. */
 export const MAX_ORBIT_POLAR_ANGLE = Math.PI - 0.05
 
@@ -104,3 +127,28 @@ export function glideFloorLimit(current: number | null, target: number, delta: n
   if (current === null || !(delta > 0)) return current ?? target
   return target + (current - target) * Math.exp(-delta / FLOOR_GLIDE_SECONDS)
 }
+
+/**
+ * How far over the ground the overview's eye stays when the pivot goes down to a deep level: the
+ * ground is a medium, the eye above it sees the level through the hole and the dive is the
+ * person's own act, so picking a level four storeys under grade does not sink the eye with it.
+ */
+export const OVERVIEW_GROUND_CLEARANCE = 2
+
+/**
+ * The height an overview eye is kept at when its pivot moves to another level: `movedEyeY` as the
+ * move leaves it (the eye following the pivot down), unless that would sink the eye under the
+ * ground (the eye was above it, `wasUnder` false): then the eye stays where it was, over the ground
+ * (at least {@link OVERVIEW_GROUND_CLEARANCE} over it), and looks down at the new pivot. An eye
+ * already under the ground (the person dived) goes where the move puts it.
+ */
+export function overviewEyeY(
+  movedEyeY: number,
+  previousEyeY: number,
+  groundY: number,
+  wasUnder: boolean,
+): number {
+  const lowest = groundY + OVERVIEW_GROUND_CLEARANCE
+  if (wasUnder || movedEyeY >= lowest) return movedEyeY
+  return Math.max(previousEyeY, lowest)
+}

package/src/lib/paint-pass-through.test.ts

@@ -7,6 +7,7 @@ import {
   Group,
   type Intersection,
   Mesh,
+  MeshBasicMaterial,
   Path,
   Ray,
   Shape,
@@ -74,6 +75,16 @@ describe('paint passes through an empty opening', () => {
   it('without a drawn mesh the hit is the wall', () => {
     expect(wallHitInOpening(null, new Ray(), 1)).toBe(false)
   })
+
+  it('a drawn mesh with a group its material array has no entry for is the wall, without throwing', () => {
+    const torn = new Mesh(drawn.geometry.clone(), [new MeshBasicMaterial()])
+    torn.geometry.clearGroups()
+    torn.geometry.addGroup(0, Number.POSITIVE_INFINITY, 3)
+    torn.updateMatrixWorld(true)
+    const ray = new Ray(new Vector3(2, 1, 5), new Vector3(0, 0, -1))
+    expect(() => wallHitInOpening(torn, ray, 5 - 0.2)).not.toThrow()
+    expect(wallHitInOpening(torn, ray, 5 - 0.2)).toBe(false)
+  })
 })
 
 describe('a door part found behind the floor seen through its opening', () => {

package/src/lib/paint-pass-through.ts

@@ -1,5 +1,5 @@
 import type { AnyNode } from '@pascal-app/core'
-import { setSurfaceRaycastLayers } from '@pascal-app/viewer'
+import { hasMaterialsForGroups, setSurfaceRaycastLayers } from '@pascal-app/viewer'
 import { type Intersection, Mesh, type Object3D, type Ray, Raycaster } from 'three'
 
 /**
@@ -62,7 +62,9 @@ export function wallHitInOpening(
   ray: Ray,
   hitDistance: number,
 ): boolean {
-  if (!(drawn instanceof Mesh)) return false
+  // A mesh caught between a palette and the groups a preview gave it cannot be
+  // raycast (three reads each group's material); the hit stands this move.
+  if (!(drawn instanceof Mesh && hasMaterialsForGroups(drawn))) return false
   drawnRaycaster.ray.copy(ray)
   drawnRaycaster.far = Number.POSITIVE_INFINITY
   const hits: Intersection[] = []

package/src/lib/paint-scope.ts

@@ -337,6 +337,7 @@ function boundaryPointKey(point: readonly [number, number]): string {
 function boundarySegmentKey(boundary: WallBoundaryFace): string {
   const forward = boundary.points.map(boundaryPointKey).join('|')
   const reverse = [...boundary.points].reverse().map(boundaryPointKey).join('|')
+  // biome-ignore lint/complexity/useMathMinMax: lexicographic string comparison
   return `${boundary.wallId}:${forward < reverse ? forward : reverse}`
 }
 

package/src/lib/parametric-node-update.ts

@@ -6,13 +6,14 @@ import {
   useScene,
 } from '@pascal-app/core'
 
-export function commitParametricNodeFields(
+/** A field edit with what its kind's parametrics derive and reconcile from it, as updates. */
+export function parametricNodeUpdates(
   nodeId: AnyNodeId,
   requestedPatch: Partial<AnyNode>,
-): void {
-  const scene = useScene.getState()
-  const node = scene.nodes[nodeId]
-  if (!node) return
+): { id: AnyNodeId; data: Partial<AnyNode> }[] {
+  const nodes = useScene.getState().nodes
+  const node = nodes[nodeId]
+  if (!node) return []
 
   const parametrics = nodeRegistry.get(node.type)?.parametrics as
     | ParametricDescriptor<AnyNode>
@@ -31,7 +32,15 @@ export function commitParametricNodeFields(
   ]
   if (parametrics?.reconcile) {
     const next = { ...node, ...patch } as AnyNode
-    updates.push(...parametrics.reconcile(node, next, { ...scene.nodes, [nodeId]: next }))
+    updates.push(...parametrics.reconcile(node, next, { ...nodes, [nodeId]: next }))
   }
-  scene.updateNodes(updates)
+  return updates
+}
+
+export function commitParametricNodeFields(
+  nodeId: AnyNodeId,
+  requestedPatch: Partial<AnyNode>,
+): void {
+  const updates = parametricNodeUpdates(nodeId, requestedPatch)
+  if (updates.length) useScene.getState().updateNodes(updates)
 }

package/src/lib/plugin-chat.ts

@@ -28,6 +28,19 @@ export type ChatToolCardProps = {
   }
 }
 
+/**
+ * What a plugin's start screen does through the host's chat, before anything is said. `send` sends
+ * a message now, its pictures by reference (a host-stored image), and `attach` puts files on the
+ * next message, in the composer: both at the level that runs the plugin's tools. `requirePro` only
+ * asks whether the person's plan includes that level ("Pro" is the hosted product's name for it):
+ * it answers false after offering the upgrade, and changes nothing in the chat.
+ */
+export type ChatStartProps = {
+  send(text: string, images?: readonly { url: string; name: string }[]): void
+  attach(files: readonly File[]): void
+  requirePro(): boolean
+}
+
 /**
  * A plugin's contribution to a host's chat, exported from its browser entry beside its panels and
  * views; its tool contracts are its `./agent-tools` export. Which tools a turn offers, and to whom,
@@ -47,4 +60,6 @@ export type PluginChatExtension = {
   actions?: readonly { id: string; label: string; hint: string; prompt: string }[]
   /** File extensions or MIME types the plugin's tools read, which the composer then accepts. */
   accepts?: readonly string[]
+  /** What the chat shows while its thread is empty, loaded lazily. */
+  start?: () => Promise<{ default: ComponentType<ChatStartProps> }>
 }

package/src/lib/point-ask/__fixtures__/consumer-browser.tsx

@@ -0,0 +1,76 @@
+import { useScene } from '@pascal-app/core'
+import { act } from 'react'
+import { createRoot } from 'react-dom/client'
+import { PerspectiveCamera, Raycaster } from 'three'
+import { setEditorThreeContext } from '../../../components/editor/three-context-bridge'
+import { PointAskLayer } from '../../../components/point-ask/point-ask-layer'
+import { useAutoSave } from '../../../hooks/use-auto-save'
+import useEditor from '../../../store/use-editor'
+import { type PointBubble, usePointAsk } from '../../../store/use-point-ask'
+import { changeMore, endCompare, redoAsk, sendBubble, startCompare, undoAsk } from '../session'
+
+// Same-package entry: the private fixture uses this window boundary, never Editor src imports.
+const saves: unknown[] = []
+let saveControls: ReturnType<typeof useAutoSave>
+function Host() {
+  saveControls = useAutoSave({
+    onSave: async (scene) => {
+      saves.push(structuredClone(scene))
+    },
+  })
+  return <PointAskLayer />
+}
+const element = document.createElement('div')
+element.id = 'point-consumer-editor'
+document.body.append(element)
+const root = createRoot(element)
+// Only the DOM mode precondition and CPU projection: no renderer or GPU is created.
+const canvas = document.createElement('canvas')
+canvas.width = 800
+canvas.height = 600
+document.body.append(canvas)
+const camera = new PerspectiveCamera(50, 4 / 3, 0.1, 100)
+camera.position.set(2, 5, 8)
+camera.lookAt(2, 0, 2)
+setEditorThreeContext({ camera, raycaster: new Raycaster(), domElement: canvas })
+useEditor.setState({
+  viewMode: '3d',
+  workspaceMode: 'edit',
+  isPreviewMode: false,
+  isFirstPersonMode: false,
+})
+;(globalThis as unknown as { IS_REACT_ACT_ENVIRONMENT: boolean }).IS_REACT_ACT_ENVIRONMENT = true
+await act(async () => {
+  root.render(<Host />)
+})
+
+const fixture = {
+  scene: useScene,
+  point: usePointAsk,
+  act,
+  saves,
+  open: (bubble: PointBubble) =>
+    act(async () => {
+      usePointAsk.getState().openBubble(bubble)
+    }),
+  send: (text: string) =>
+    act(async () => {
+      await sendBubble(text, { x: 0, y: 0, width: 100, height: 20 })
+    }),
+  changeMore,
+  undo: undoAsk,
+  redo: redoAsk,
+  startCompare,
+  endCompare,
+  beginLoad: () => saveControls.beginSceneLoad(),
+  completeLoad: () => saveControls.completeSceneLoad(),
+  saveNow: () => saveControls.saveNow(),
+  unmount: () =>
+    act(async () => {
+      root.unmount()
+      setEditorThreeContext(null)
+      canvas.remove()
+    }),
+}
+;(window as unknown as { pointEditorFixture: typeof fixture }).pointEditorFixture = fixture
+window.dispatchEvent(new Event('point-editor-fixture-ready'))

package/src/lib/point-ask/__fixtures__/house.ts

@@ -0,0 +1,81 @@
+import {
+  type AnyNode,
+  ItemNode,
+  LevelNode,
+  WallNode,
+  WindowNode,
+  ZoneNode,
+  DoorNode,
+} from '@pascal-app/core'
+
+// One 4 × 3 m kitchen on a ground level, as the point-ask tests share it: four walls, the room they
+// make, a window in the north wall, a door in the south wall and a sofa on the floor.
+export const LEVEL_ID = 'level_0'
+
+const wall = (id: string, start: [number, number], end: [number, number]) =>
+  WallNode.parse({ id, parentId: LEVEL_ID, start, end, height: 2.6 })
+
+const walls = [
+  wall('wall_north', [0, 0], [4, 0]),
+  wall('wall_east', [4, 0], [4, 3]),
+  wall('wall_south', [4, 3], [0, 3]),
+  wall('wall_west', [0, 3], [0, 0]),
+]
+
+const zone = ZoneNode.parse({
+  id: 'zone_kitchen',
+  parentId: LEVEL_ID,
+  name: 'Kitchen',
+  polygon: [
+    [0, 0],
+    [4, 0],
+    [4, 3],
+    [0, 3],
+  ],
+  boundaryWallIds: walls.map((w) => w.id),
+})
+
+const window = WindowNode.parse({
+  id: 'window_north',
+  parentId: 'wall_north',
+  wallId: 'wall_north',
+  position: [2, 1.4, 0],
+  width: 1.2,
+  height: 1.4,
+})
+
+const door = DoorNode.parse({
+  id: 'door_front',
+  parentId: 'wall_south',
+  wallId: 'wall_south',
+  position: [2, 1.05, 0],
+  width: 0.9,
+  height: 2.1,
+})
+
+const sofa = ItemNode.parse({
+  id: 'item_sofa',
+  parentId: LEVEL_ID,
+  name: 'Sofa',
+  position: [1.5, 0, 1.5],
+  asset: {
+    id: 'sofa',
+    category: 'furniture',
+    name: 'Oslo 3-seat',
+    thumbnail: '',
+    src: 'asset://sofa.glb',
+    dimensions: [2.1, 0.85, 0.95],
+  },
+})
+
+const level = LevelNode.parse({
+  id: LEVEL_ID,
+  children: [...walls.map((w) => w.id), zone.id, sofa.id],
+})
+
+/** The scene as `useScene` holds it: nodes by id. */
+export function house(extra: AnyNode[] = []): Record<string, AnyNode> {
+  return Object.fromEntries(
+    [level, ...walls, zone, window, door, sofa, ...extra].map((node) => [node.id, node as AnyNode]),
+  )
+}