@pascal-app/editor 1.0.4 → 1.0.5

package/src/components/editor/custom-camera-controls.tsx

@@ -7,7 +7,10 @@ import {
   type CameraControlFitSceneEvent,
   type CameraControlFrameEvent,
   type CameraPose,
+  deepestDrawnY,
   emitter,
+  groundHeightAt,
+  lowestGroundY,
   sceneRegistry,
   useScene,
 } from '@pascal-app/core'
@@ -53,9 +56,11 @@ import {
   syncKeyboardPanMotion,
 } from '../../lib/keyboard-pan'
 import {
+  diveFloorY,
   MAX_ORBIT_POLAR_ANGLE,
-  ORBIT_FLOOR_CLEARANCE,
   ORBIT_TARGET_HEIGHT,
+  orbitFloorMinY,
+  overviewEyeY,
 } from '../../lib/orbit-floor-clearance'
 import { editorOwnsOneFingerDrag } from '../../lib/touch-gesture-priority'
 import { frameViewerCamera } from '../../lib/viewer-selection'
@@ -102,6 +107,18 @@ function orbitGroundY(
   return floorY + ORBIT_TARGET_HEIGHT
 }
 
+/**
+ * `eyeY` for an overview eye at (x, z) whose pivot is being sent to another level: kept over the
+ * ground it was over (a deep level shown is looked at through the hole, not from under the lid),
+ * unless the person has dived.
+ */
+function keepEyeOverGround(x: number, eyeY: number, z: number, previousEyeY = eyeY): number {
+  const { nodes } = useScene.getState()
+  const siteId = sceneRegistry.byType.site?.values().next().value as AnyNodeId | undefined
+  const groundY = groundHeightAt(siteId ? nodes[siteId] : null, x, z)
+  return overviewEyeY(eyeY, previousEyeY, groundY, useViewer.getState().eyeUnderGround)
+}
+
 function levelOf(nodeId: string): string | null {
   const nodes = useScene.getState().nodes
   let node: AnyNode | undefined = nodes[nodeId as AnyNodeId]
@@ -393,7 +410,23 @@ export const CustomCameraControls = ({ paused = false }: { paused?: boolean }) =
     currentLevelId ? getLevelPresentationY(currentLevelId, state.nodes, levelMode) : 0,
   )
   const allowUnderground = !isPreviewMode && allowUndergroundCamera
-  const floorMinY = allowUnderground ? null : floorY + ORBIT_FLOOR_CLEARANCE
+  // With the ground on Auto the eye may dive under any building, down to the dive's floor; Solid
+  // keeps the eye over the ground.
+  const groundMode = useViewer((state) => state.groundMode)
+  const diveFloor = useScene((state) =>
+    groundMode === 'auto'
+      ? diveFloorY(lowestGroundY(state.nodes), deepestDrawnY(state.nodes))
+      : null,
+  )
+  const floorMinY = allowUnderground ? null : orbitFloorMinY(floorY, diveFloor)
+  // The viewer mounts the eye's fill light before the first dive, so crossing the ground compiles nothing.
+  const mayDive = allowUnderground || diveFloor !== null
+  useEffect(() => {
+    useViewer.setState({ diveAvailable: mayDive })
+    return () => {
+      useViewer.setState({ diveAvailable: false })
+    }
+  }, [mayDive])
   const maxPolarAngle =
     allowUnderground || cameraMode === 'perspective'
       ? MAX_ORBIT_POLAR_ANGLE
@@ -594,12 +627,39 @@ export const CustomCameraControls = ({ paused = false }: { paused?: boolean }) =
     if (!controls.current) return
     if (firstLoad.current) {
       firstLoad.current = false
-      controls.current.setLookAt(20, 20 + targetY, 20, 0, targetY, 0, true)
+      controls.current.setLookAt(
+        20,
+        keepEyeOverGround(20, 20 + targetY, 20, 20),
+        20,
+        0,
+        targetY,
+        0,
+        true,
+      )
     }
     controls.current.getOrbitTarget(currentTarget)
     // Idempotence guard: skip when already there — also swallows the thumbnail
     // generator's synchronous stacked→restore levelMode round-trip.
     if (Math.abs(currentTarget.y - targetY) < 1e-3) return
+    // The pivot goes down with the level; the eye follows it unless that would sink it under the
+    // ground (a basement four storeys down): then it stays over the ground, looking down.
+    controls.current.getPosition(tempPosition, false)
+    const movedEyeY = tempPosition.y + targetY - currentTarget.y
+    const eyeY = isPerspectiveCamera(camera)
+      ? keepEyeOverGround(tempPosition.x, movedEyeY, tempPosition.z, tempPosition.y)
+      : movedEyeY
+    if (eyeY > movedEyeY) {
+      controls.current.setLookAt(
+        tempPosition.x,
+        eyeY,
+        tempPosition.z,
+        currentTarget.x,
+        targetY,
+        currentTarget.z,
+        true,
+      )
+      return
+    }
     controls.current.moveTo(currentTarget.x, targetY, currentTarget.z, true)
   }, [
     camera,
@@ -627,8 +687,9 @@ export const CustomCameraControls = ({ paused = false }: { paused?: boolean }) =
     floorSurface.levelId = currentLevelId ?? null
     if (!controls.current) return
     controls.current.floorMinY = floorMinY
-    controls.current.floorSurface = floorSurface
-  }, [camera, currentLevelId, floorMinY, floorSurface, isFirstPersonMode])
+    // The level's floor and the ground hold the eye over them; the dive goes through both.
+    controls.current.floorSurface = diveFloor === null ? floorSurface : null
+  }, [camera, currentLevelId, diveFloor, floorMinY, floorSurface, isFirstPersonMode])
 
   const focusNode = useCallback(
     (nodeId: string) => {
@@ -660,7 +721,11 @@ export const CustomCameraControls = ({ paused = false }: { paused?: boolean }) =
       controls.current.getTarget(tempTarget)
       tempDelta.copy(tempCenter).sub(tempTarget)
 
-      const focusedY = tempPosition.y + tempDelta.y
+      const focusedX = tempPosition.x + tempDelta.x
+      const focusedZ = tempPosition.z + tempDelta.z
+      const focusedY = isPerspectiveCamera(camera)
+        ? keepEyeOverGround(focusedX, tempPosition.y + tempDelta.y, focusedZ, tempPosition.y)
+        : tempPosition.y + tempDelta.y
       const floorMinY = isPerspectiveCamera(camera) ? controls.current.floorLimitY : null
       controls.current.setLookAt(
         tempPosition.x + tempDelta.x,
@@ -1315,7 +1380,15 @@ export const CustomCameraControls = ({ paused = false }: { paused?: boolean }) =
       const groundY = orbitGroundY(lastLevelId.current)
       if (!bounds) {
         // Restore default framing pose when no bounds were computed.
-        controls.current.setLookAt(20, 20 + groundY, 20, 0, groundY, 0, true)
+        controls.current.setLookAt(
+          20,
+          keepEyeOverGround(20, 20 + groundY, 20, 20),
+          20,
+          0,
+          groundY,
+          0,
+          true,
+        )
         return
       }
       const [cx, cz] = bounds.center
@@ -1327,7 +1400,7 @@ export const CustomCameraControls = ({ paused = false }: { paused?: boolean }) =
       const height = Math.max(maxExtent * 0.8, 10)
       controls.current.setLookAt(
         cx + distance * 0.7,
-        height + groundY,
+        keepEyeOverGround(cx + distance * 0.7, height + groundY, cz + distance * 0.7, height),
         cz + distance * 0.7,
         cx,
         groundY,

package/src/components/editor/editor-layout-mobile.tsx

@@ -214,7 +214,7 @@ export function EditorLayoutMobile({
   }, [panelSheetHeight, committedSheetH])
 
   return (
-    <div className="dark flex h-full w-full flex-col bg-sidebar text-foreground">
+    <div className="flex h-full w-full flex-col bg-sidebar text-foreground">
       {navbarSlot}
 
       <div

package/src/components/editor/editor-layout-v2.tsx

@@ -332,7 +332,7 @@ export function EditorLayoutV2({
   }
 
   return (
-    <div className="dark flex h-full w-full flex-col bg-sidebar text-foreground">
+    <div className="flex h-full w-full flex-col bg-sidebar text-foreground">
       {/* Top navbar */}
       {navbarSlot}
 

package/src/components/editor/export-manager.tsx

@@ -1,12 +1,13 @@
 'use client'
 
-import { emitter } from '@pascal-app/core'
+import { emitter, getProjectFileSink, type ProjectFileSink } from '@pascal-app/core'
 import { disposeObject3DResources, snapLevelsToTruePositions, useViewer } from '@pascal-app/viewer'
 import { useThree } from '@react-three/fiber'
 import { useEffect } from 'react'
 import * as THREE from 'three'
 import { OBJExporter } from 'three/examples/jsm/exporters/OBJExporter.js'
 import { STLExporter } from 'three/examples/jsm/exporters/STLExporter.js'
+import { downloadProjectFile } from '../../lib/download-project-file'
 import {
   exportSceneToGlb,
   prepareSceneForExport,
@@ -58,6 +59,7 @@ export function ExportManager() {
 
   useEffect(() => {
     const exportFn: ModelExport = async (format = 'glb', requested = {}) => {
+      const finishArtifact = artifactFinisher(getProjectFileSink())
       // Resolve once: scene preparation prunes hidden nodes by default, and the
       // IFC writer must drop the same nodes it rebuilds parametrically.
       const options = { ...requested, onlyVisible: requested.onlyVisible ?? true }
@@ -262,22 +264,15 @@ export function ExportManager() {
   return null
 }
 
-function finishArtifact(
-  blob: Blob,
-  filename: string,
-  download: boolean | undefined,
-  metadata?: unknown,
-  warnings?: readonly string[],
-): ModelExportArtifact {
-  if (download !== false) downloadBlob(blob, filename)
-  return { blob, filename, metadata, warnings: warnings?.length ? warnings : undefined }
-}
-
-function downloadBlob(blob: Blob, filename: string) {
-  const url = URL.createObjectURL(blob)
-  const link = document.createElement('a')
-  link.href = url
-  link.download = filename
-  link.click()
-  URL.revokeObjectURL(url)
+function artifactFinisher(sink: ProjectFileSink | null) {
+  return async (
+    blob: Blob,
+    filename: string,
+    download: boolean | undefined,
+    metadata?: unknown,
+    warnings?: readonly string[],
+  ): Promise<ModelExportArtifact> => {
+    if (download !== false) await downloadProjectFile(blob, filename, sink)
+    return { blob, filename, metadata, warnings: warnings?.length ? warnings : undefined }
+  }
 }

package/src/components/editor/first-person/build-collider-world.test.ts

@@ -7,16 +7,20 @@ import {
   CeilingNode,
   ColumnNode,
   createTerrainField,
+  DoorNode,
   ElevatorNode,
   encodeTerrainField,
   flattenPatch,
+  GeometryArtifactManifest,
   LevelNode,
   nodeRegistry,
   registerNode,
   ShelfNode,
   SiteNode,
   SlabNode,
+  StairNode,
   sceneRegistry,
+  useInteractive,
   useScene,
 } from '@pascal-app/core'
 import { hideFromScene, STAND_CLEARANCE, showInScene } from '@pascal-app/viewer'
@@ -325,3 +329,268 @@ describe('buildFirstPersonColliderWorldFromRegistry', () => {
     world.dispose()
   })
 })
+
+// A door built from a script is drawn by its model: the leaves are the model's own and its `open`
+// clip moves them. What the player is stopped by is a stand-in leaf box at the door's frame, and
+// that box has to follow the door's own open state, not the native `operationState` the clip
+// never touches.
+describe('a door built from a script', () => {
+  const source = {
+    kind: 'script' as const,
+    script: 'b'.repeat(64),
+    artifact: 'a'.repeat(64),
+    manifest: GeometryArtifactManifest.parse({
+      bounds: { min: [-0.6, 0, -0.11], max: [0.6, 2.55, 0.11] },
+      triangles: 12,
+      animations: [{ name: 'open', duration: 1.3 }],
+    }),
+  }
+  // The door mechanism's open state for a script: the first control toggle of the item.
+  const mechanism = {
+    verb: 'open',
+    icon: 'door',
+    has: (node: AnyNode) => Boolean((node as { source?: unknown }).source),
+    isOn: (node: AnyNode, state: ReturnType<typeof useInteractive.getState>) =>
+      Boolean(state.items[node.id as never]?.controlValues[0]),
+    set: () => {},
+  }
+
+  function mountScriptedDoor(language: 'three' | 'bpy' = 'three') {
+    registerNode({
+      kind: 'door',
+      schema: DoorNode,
+      schemaVersion: 1,
+      category: 'structure',
+      capabilities: { mechanism },
+    } as unknown as AnyNodeDefinition)
+    registerColliderDefinition('column', ColumnNode, 'structure')
+    const door = DoorNode.parse({
+      id: 'door_shoji',
+      doorType: 'sliding',
+      width: 1.2,
+      height: 2.55,
+      source: { ...source, language },
+    })
+    const column = ColumnNode.parse({ id: 'column_far' })
+    setSceneNodes([door, column])
+    mountNode(column, [1, 2, 1], [10, 1, 0])
+    // The door's registered group, as its renderer builds it: the compiled model under it, with
+    // the agent's 1 m deep `cutout` box and two leaves.
+    const group = new Group()
+    group.position.set(0, 1.275, 0)
+    const box = (name: string, size: [number, number, number], x: number, z: number) => {
+      const mesh = new Mesh(new BoxGeometry(...size), new MeshBasicMaterial())
+      mesh.name = name
+      mesh.position.set(x, 0, z)
+      group.add(mesh)
+    }
+    box('cutout', [1.2, 2.55, 1], 0, 0)
+    box('leaf_0', [0.5, 2.4, 0.02], -0.255, 0.025)
+    box('leaf_1', [0.5, 2.4, 0.02], 0.255, -0.025)
+    group.updateMatrixWorld(true)
+    sceneRegistry.nodes.set(door.id, group)
+    sceneRegistry.byType.door!.add(door.id)
+    return door
+  }
+
+  /** Walk straight at the doorway from the front, at hip height: where the first thing is hit. */
+  function firstHitAcrossDoorway() {
+    const world = buildFirstPersonColliderWorldFromRegistry()
+    if (!world) return null
+    const raycaster = new Raycaster(new Vector3(0, 1, -3), new Vector3(0, 0, 1))
+    const hit = raycaster.intersectObject(world.mesh, false)[0]
+    world.dispose()
+    return hit ? { z: hit.point.z } : null
+  }
+
+  afterEach(() => {
+    useInteractive.setState({ items: {} } as never)
+    sceneRegistry.clear()
+    nodeRegistry._reset()
+    useScene.setState({ nodes: {}, rootNodeIds: [] } as never)
+  })
+
+  test('a closed one stops the player at its leaf, not at the model’s cutout box', () => {
+    mountScriptedDoor()
+    useInteractive.setState({ items: { door_shoji: { controlValues: [false] } } } as never)
+
+    const hit = firstHitAcrossDoorway()
+    expect(hit).not.toBeNull()
+    // the stand-in leaf is 0.06 m deep at the frame; the cutout would stop the player at z = -0.5
+    expect(hit!.z).toBeCloseTo(-0.03, 3)
+  })
+
+  test('an open one can be walked through, and its cutout never collides', () => {
+    mountScriptedDoor()
+    useInteractive.setState({ items: { door_shoji: { controlValues: [true] } } } as never)
+
+    expect(firstHitAcrossDoorway()).toBeNull()
+  })
+  test('a Blender-built door follows its mechanism the same way: the language makes no difference', () => {
+    mountScriptedDoor('bpy')
+    useInteractive.setState({ items: { door_shoji: { controlValues: [false] } } } as never)
+    expect(firstHitAcrossDoorway()?.z).toBeCloseTo(-0.03, 3)
+
+    useInteractive.setState({ items: { door_shoji: { controlValues: [true] } } } as never)
+    expect(firstHitAcrossDoorway()).toBeNull()
+  })
+})
+
+// The ground is a sheet across the lot, and under a house with a basement the sheet ran across the
+// stairwell: a walker going down the stair met it at grade. The ground is drawn open over what the
+// house covers (`coveredBelowGradeFootprints`), and the walker's ground is cut open over the same.
+describe('a basement under the house', () => {
+  afterEach(() => {
+    sceneRegistry.clear()
+    nodeRegistry._reset()
+    useScene.setState({ nodes: {}, rootNodeIds: [] } as never)
+  })
+
+  type Box = { size: [number, number, number]; at: [number, number, number] }
+
+  function mountBoxes(node: AnyNode, boxes: Box[]) {
+    const group = new Group()
+    for (const { size, at } of boxes) {
+      const mesh = new Mesh(new BoxGeometry(...size), new MeshBasicMaterial())
+      mesh.position.set(...at)
+      group.add(mesh)
+    }
+    group.updateMatrixWorld(true)
+    sceneRegistry.nodes.set(node.id, group)
+    sceneRegistry.byType[node.type]!.add(node.id)
+  }
+
+  const rect = (x0: number, x1: number, z0: number, z1: number): Array<[number, number]> => [
+    [x0, z0],
+    [x1, z0],
+    [x1, z1],
+    [x0, z1],
+  ]
+  const TREADS = 14
+  const RISE = 0.2
+  const FLOOR_G = 0.05
+  const FLOOR_B = -2.95
+
+  /**
+   * An 8 m square house on a flat site (or a flat sculpted one) over a basement whose floor lies at
+   * -2.95 m, its plan 1.3..6.7 × 1.4..6.6. The ground floor is a slab with the stairwell cut out of
+   * it, and a stair of 14 treads, 0.2 m each, goes down along +x from x = 2 at z 3..4.
+   */
+  function house(sculpted: boolean) {
+    registerColliderDefinition('slab', SlabNode, 'structure', 'floor')
+    registerColliderDefinition('stair', StairNode, 'structure')
+    const field = createTerrainField({ cols: 21, rows: 21, spacing: 1, origin: [-6, -6] })
+    const site = SiteNode.parse({
+      id: 'site_test',
+      children: ['building_a'],
+      ...(sculpted ? { terrain: encodeTerrainField(field) } : {}),
+    })
+    const building = BuildingNode.parse({
+      id: 'building_a',
+      parentId: site.id,
+      children: ['level_b', 'level_g'],
+    })
+    const basement = LevelNode.parse({
+      id: 'level_b',
+      parentId: building.id,
+      level: -1,
+      baseElevation: -3,
+      height: 3,
+      children: ['slab_b'],
+    })
+    const ground = LevelNode.parse({
+      id: 'level_g',
+      parentId: building.id,
+      level: 0,
+      height: 3,
+      children: ['slab_g'],
+    })
+    const slabB = SlabNode.parse({
+      id: 'slab_b',
+      parentId: basement.id,
+      polygon: rect(1.3, 6.7, 1.4, 6.6),
+      elevation: 0.05,
+    })
+    const slabG = SlabNode.parse({
+      id: 'slab_g',
+      parentId: ground.id,
+      polygon: rect(0, 8, 0, 8),
+      elevation: FLOOR_G,
+    })
+    const stair = StairNode.parse({ id: 'stair_a', parentId: basement.id })
+    setSceneNodes([site, building, basement, ground, slabB, slabG, stair])
+    mountRegistryGroup(site)
+    mountBoxes(slabB, [{ size: [5.4, 0.1, 5.2], at: [4, FLOOR_B - 0.05, 4] }])
+    // The ground floor around the stairwell (x 2..5.4, z 3..4).
+    mountBoxes(slabG, [
+      { size: [2, 0.1, 8], at: [1, FLOOR_G - 0.05, 4] },
+      { size: [2.6, 0.1, 8], at: [6.7, FLOOR_G - 0.05, 4] },
+      { size: [3.4, 0.1, 3], at: [3.7, FLOOR_G - 0.05, 1.5] },
+      { size: [3.4, 0.1, 4], at: [3.7, FLOOR_G - 0.05, 6] },
+    ])
+    mountBoxes(
+      stair,
+      Array.from({ length: TREADS }, (_, i) => ({
+        size: [0.3, RISE, 1] as [number, number, number],
+        at: [2.15 + 0.3 * i, FLOOR_G - RISE * (i + 1) - RISE / 2, 3.5] as [number, number, number],
+      })),
+    )
+  }
+
+  const UP = new Vector3(0, 1, 0)
+  /** The first upward-facing surface under (x, z), looking down from `from`. */
+  function floorUnder(mesh: Mesh, x: number, z: number, from: number): number | null {
+    const raycaster = new Raycaster()
+    raycaster.set(new Vector3(x, from, z), new Vector3(0, -1, 0))
+    const hit = raycaster
+      .intersectObject(mesh, false)
+      .find(
+        (h) => !h.face || h.face.normal.clone().transformDirection(mesh.matrixWorld).dot(UP) > 0.2,
+      )
+    return hit ? hit.point.y : null
+  }
+
+  for (const sculpted of [false, true]) {
+    describe(sculpted ? 'on sculpted ground' : 'on flat ground', () => {
+      test('a walker goes down the stair from the ground floor to the basement', () => {
+        house(sculpted)
+        const world = buildFirstPersonColliderWorldFromRegistry()!
+        expect(world).not.toBeNull()
+
+        // Eye-level search from half a metre over the floor the walker stands on, a step at a time
+        // along the stair's run: the floor found is the next one he stands on.
+        let floor = floorUnder(world.mesh, 1, 3.5, 3)!
+        expect(floor).toBeCloseTo(FLOOR_G, 6)
+        const floors = [floor]
+        for (let x = 1.1; x < 6.5; x += 0.1) {
+          floor = floorUnder(world.mesh, x, 3.5, floor + 0.5) ?? Number.NaN
+          floors.push(floor)
+        }
+        // He never stands on the ground sheet (0 m) once past the stairwell's edge, and ends on
+        // the basement's floor; no step is deeper than a tread.
+        expect(Math.min(...floors)).toBeCloseTo(FLOOR_B, 6)
+        for (let i = 1; i < floors.length; i += 1)
+          expect(floors[i - 1]! - floors[i]!).toBeLessThanOrEqual(RISE + 1e-6)
+        world.dispose()
+      })
+
+      test('the ground is open over the part of the basement the house covers, and closed past it', () => {
+        house(sculpted)
+        const world = buildFirstPersonColliderWorldFromRegistry()!
+        // Under the ground floor's slab, looking down from just under it: the ground sheet is
+        // there outside the basement's plan and gone inside it, where the basement's floor is.
+        const under = (x: number, z: number) => floorUnder(world.mesh, x, z, FLOOR_G - 0.03)
+        expect(under(1.2, 5)).toBeCloseTo(0, 6)
+        expect(under(1.4, 5)).toBeCloseTo(FLOOR_B, 6)
+        expect(under(6.6, 5)).toBeCloseTo(FLOOR_B, 6)
+        expect(under(6.8, 5)).toBeCloseTo(0, 6)
+        expect(under(4, 1.3)).toBeCloseTo(0, 6)
+        expect(under(4, 1.5)).toBeCloseTo(FLOOR_B, 6)
+        // Outside the house: the garden is walked on as before.
+        expect(floorUnder(world.mesh, 12, 5, 3)).toBeCloseTo(0, 6)
+        expect(floorUnder(world.mesh, -3, -3, 3)).toBeCloseTo(0, 6)
+        world.dispose()
+      })
+    })
+  }
+})

package/src/components/editor/first-person/build-collider-world.ts

@@ -1,10 +1,12 @@
 import {
   type AnyNode,
   type AnyNodeId,
+  coveredBelowGradeFootprints,
   type DoorNode,
   getGarageVisibleOpeningRatio,
   getLevelElevations,
   isOperationDoorType,
+  nodeMechanism,
   nodeRegistry,
   sceneRegistry,
   terrainFieldOf,
@@ -15,6 +17,7 @@ import * as THREE from 'three'
 import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js'
 import { acceleratedRaycast, computeBoundsTree, disposeBoundsTree } from 'three-mesh-bvh'
 import { computeSceneBoundsXZ } from '../../../lib/scene-bounds'
+import { cutGroundCollider } from './ground-holes'
 import { createTerrainColliderGeometry } from './terrain-collider'
 
 const SKIPPED_MESH_NAMES = new Set(['cutout', 'collision-mesh'])
@@ -160,19 +163,28 @@ function collectLevelFallbackFloorGeometries(nodes: SceneNodes) {
 // player at the datum inside an excavation and bury them inside a hill. Derived
 // from the field rather than the rendered terrain mesh for the same
 // mount-timing reason as the flat slab.
+//
+// Either way the ground is cut open over what the house covers of its basement
+// (`coveredBelowGradeFootprints`, the rings the ground is drawn open over): a sheet
+// across the stairwell would hold the player at grade on the way down, with the
+// stair and the basement's floor below it. The house covers that part, so it is cut
+// whatever the view does with the ground; past it the ground is walked on as before.
 function createSiteGroundColliderGeometry(site: SiteNode, nodes: SceneNodes) {
   if (site.visible === false) return null
 
   const siteObject = sceneRegistry.nodes.get(site.id)
   if (!siteObject?.visible) return null
 
+  const covered = coveredBelowGradeFootprints(nodes)
+
   const field = terrainFieldOf(site)
   if (field) {
     const terrainGeometry = createTerrainColliderGeometry(field)
     if (terrainGeometry) {
+      const cut = cutGroundCollider(terrainGeometry, covered)
       siteObject.updateWorldMatrix(true, false)
-      terrainGeometry.applyMatrix4(siteObject.matrixWorld)
-      return terrainGeometry
+      cut.applyMatrix4(siteObject.matrixWorld)
+      return cut
     }
   }
 
@@ -194,8 +206,9 @@ function createSiteGroundColliderGeometry(site: SiteNode, nodes: SceneNodes) {
   geometry.applyMatrix4(
     new THREE.Matrix4().makeTranslation(centerX, -LEVEL_FALLBACK_FLOOR_THICKNESS / 2, centerZ),
   )
-  geometry.applyMatrix4(siteObject.matrixWorld)
-  return geometry
+  const cut = cutGroundCollider(geometry, covered)
+  cut.applyMatrix4(siteObject.matrixWorld)
+  return cut
 }
 
 function collectSiteGroundColliderGeometries(nodes: SceneNodes) {
@@ -281,6 +294,10 @@ function createDoorLeafColliderGeometry(root: THREE.Object3D, node: DoorNode) {
   const hasLeafContent = node.segments.some((segment) => segment.type !== 'empty')
   if (!hasLeafContent) return null
 
+  // A door built from a script opens by its model's `open` clip, which the mechanism runs through
+  // its own control: the native `operationState` below never moves for it, so open is read there.
+  if (node.source && nodeMechanism(node)?.isOn(node, useInteractive.getState())) return null
+
   const leafW = node.width - 2 * node.frameThickness
   const leafH = node.height - node.frameThickness
   if (leafW <= 0 || leafH <= 0) return null
@@ -457,7 +474,7 @@ export function buildFirstPersonColliderWorldFromRegistry(): FirstPersonCollider
   ;(bvhGeometry as any).computeBoundsTree = computeBoundsTree
   ;(bvhGeometry as any).disposeBoundsTree = disposeBoundsTree
   bvhGeometry.computeBoundsTree?.({
-    maxLeafSize: 12,
+    targetLeafSize: 12,
     strategy: 0,
   } as never)
   bvhGeometry.computeBoundingBox()