@pascal-app/editor 1.0.4 → 1.0.6

package/src/components/editor/first-person/ground-holes.test.ts

@@ -0,0 +1,128 @@
+import { describe, expect, test } from 'bun:test'
+import {
+  BoxGeometry,
+  BufferAttribute,
+  BufferGeometry,
+  Mesh,
+  MeshBasicMaterial,
+  Raycaster,
+  Vector3,
+} from 'three'
+import { cutGroundCollider } from './ground-holes'
+
+/** A 10 × 10 m square on the plane y = 0.1 x (two triangles, facing up), plan 0..10 × 0..10. */
+function slopedSquare(flip = false) {
+  const corner = (x: number, z: number): [number, number, number] => [x, 0.1 * x, z]
+  const up = [
+    corner(0, 0),
+    corner(0, 10),
+    corner(10, 0),
+    corner(10, 0),
+    corner(0, 10),
+    corner(10, 10),
+  ]
+  const vertices = flip ? [...up].reverse() : up
+  const geometry = new BufferGeometry()
+  geometry.setAttribute('position', new BufferAttribute(new Float32Array(vertices.flat()), 3))
+  const slope = new Vector3(-0.1, 1, 0).normalize()
+  const normal = flip ? slope.clone().negate() : slope
+  geometry.setAttribute(
+    'normal',
+    new BufferAttribute(
+      new Float32Array(vertices.flatMap(() => [normal.x, normal.y, normal.z])),
+      3,
+    ),
+  )
+  return geometry
+}
+
+const HOLE: Array<[number, number]> = [
+  [3, 3],
+  [7, 3],
+  [7, 6],
+  [3, 6],
+]
+
+/** The up (1) or down (-1) facing of every triangle of a non-indexed geometry. */
+function triangles(geometry: BufferGeometry) {
+  const position = geometry.getAttribute('position')
+  const out: Array<{ facing: number }> = []
+  for (let i = 0; i < position.count; i += 3) {
+    const [a, b, c] = [0, 1, 2].map(
+      (k) => new Vector3(position.getX(i + k), position.getY(i + k), position.getZ(i + k)),
+    ) as [Vector3, Vector3, Vector3]
+    const normal = b.clone().sub(a).cross(c.clone().sub(a))
+    out.push({ facing: Math.sign(normal.y) })
+  }
+  return out
+}
+
+function hitUnder(geometry: BufferGeometry, x: number, z: number): number | null {
+  const mesh = new Mesh(geometry, new MeshBasicMaterial())
+  mesh.updateMatrixWorld(true)
+  const raycaster = new Raycaster()
+  raycaster.set(new Vector3(x, 50, z), new Vector3(0, -1, 0))
+  return raycaster.intersectObject(mesh, false)[0]?.point.y ?? null
+}
+
+describe('cutGroundCollider', () => {
+  test('without holes the geometry is returned as it is', () => {
+    const geometry = slopedSquare()
+    expect(cutGroundCollider(geometry, [])).toBe(geometry)
+  })
+
+  test('the ground is gone over the hole and is the same surface everywhere else', () => {
+    const cut = cutGroundCollider(slopedSquare(), [HOLE])
+    expect(hitUnder(cut, 5, 4)).toBeNull()
+    expect(hitUnder(cut, 3.2, 3.2)).toBeNull()
+    expect(hitUnder(cut, 6.8, 5.8)).toBeNull()
+    // Past the rim, on the slope the uncut triangle had: y = 0.1 x.
+    for (const [x, z] of [
+      [2.8, 4],
+      [7.2, 4],
+      [5, 2.8],
+      [5, 6.2],
+      [1, 1],
+      [9, 9],
+    ] as const)
+      expect(hitUnder(cut, x, z)).toBeCloseTo(0.1 * x, 5)
+  })
+
+  test('what is left has the area of the ground less the hole, and faces as the ground did', () => {
+    for (const flip of [false, true]) {
+      const cut = cutGroundCollider(slopedSquare(flip), [HOLE])
+      const pieces = triangles(cut)
+      // The slope stretches the surface, so compare in plan: 100 - 12 m².
+      const position = cut.getAttribute('position')
+      let plan = 0
+      for (let i = 0; i < position.count; i += 3) {
+        const [a, b, c] = [0, 1, 2].map((k) => [position.getX(i + k), position.getZ(i + k)]) as [
+          [number, number],
+          [number, number],
+          [number, number],
+        ]
+        plan += Math.abs((b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0])) / 2
+      }
+      expect(plan).toBeCloseTo(100 - 12, 3)
+      for (const piece of pieces) expect(piece.facing).toBe(flip ? -1 : 1)
+    }
+  })
+
+  test('the normals follow the ground and stay unit length', () => {
+    const cut = cutGroundCollider(slopedSquare(), [HOLE])
+    const normal = cut.getAttribute('normal')
+    for (let i = 0; i < normal.count; i += 1) {
+      expect(Math.hypot(normal.getX(i), normal.getY(i), normal.getZ(i))).toBeCloseTo(1, 5)
+      expect(normal.getX(i)).toBeCloseTo(-0.1 / Math.hypot(0.1, 1), 5)
+    }
+  })
+
+  test('a triangle wholly inside the hole is dropped, vertical faces are kept', () => {
+    const box = new BoxGeometry(2, 2, 2).toNonIndexed()
+    box.translate(5, 0, 4.5)
+    const before = box.getAttribute('position').count
+    const cut = cutGroundCollider(box, [HOLE])
+    // Top and bottom faces lie wholly inside the hole and go; the four sides (no plan area) stay.
+    expect(cut.getAttribute('position').count).toBe(before - 12)
+  })
+})

package/src/components/editor/first-person/ground-holes.ts

@@ -0,0 +1,130 @@
+/**
+ * Holes in the site ground's collision geometry.
+ *
+ * The walkthrough stands on one merged BVH mesh, and the site's ground (a flat slab, or the terrain)
+ * is a sheet across the whole lot. Where the house stands over a basement the ground is drawn open
+ * (`coveredBelowGradeFootprints`), but the sheet under the stairwell stayed: the player descending
+ * the stair met it at grade and could go no deeper. Cutting the collider by the same rings the
+ * ground is drawn open over lets the player follow the building's floors and stairs there.
+ *
+ * Every triangle that reaches a hole is cut against it in plan; the pieces keep the source
+ * triangle's plane (height and normal interpolated from its corners) and its facing, so the cut
+ * surface is exactly the one the uncut triangle was.
+ */
+
+import { difference, type Ring, union } from '@pascal-app/core'
+import { BufferAttribute, BufferGeometry, ShapeUtils, Vector2 } from 'three'
+
+/** Triangles flatter than this in plan (m²) are vertical faces: they hold nothing up. */
+const MIN_PLAN_AREA = 1e-9
+
+type Corner = { x: number; y: number; z: number; nx: number; ny: number; nz: number }
+
+/** Twice the signed plan area of `a b c` (x right, z down). */
+function orient(a: [number, number], b: [number, number], c: [number, number]): number {
+  return (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0])
+}
+
+/**
+ * `geometry` (non-indexed, `position` and `normal`, in the frame the rings are in) without the part
+ * of it that lies over `holes`. A triangle the clip fails on is kept whole: the ground closed is
+ * the safe side. The geometry is returned as it is when there are no holes.
+ */
+export function cutGroundCollider(
+  geometry: BufferGeometry,
+  holes: readonly Ring[],
+): BufferGeometry {
+  if (holes.length === 0) return geometry
+  const cutouts = union(holes)
+  if (cutouts.length === 0) return geometry
+  const boxes = cutouts.map(({ outer }) => ({
+    minX: Math.min(...outer.map(([x]) => x)),
+    maxX: Math.max(...outer.map(([x]) => x)),
+    minZ: Math.min(...outer.map(([, z]) => z)),
+    maxZ: Math.max(...outer.map(([, z]) => z)),
+  }))
+
+  const position = geometry.getAttribute('position')
+  const normal = geometry.getAttribute('normal')
+  const positions: number[] = []
+  const normals: number[] = []
+  const push = (corner: Corner) => {
+    positions.push(corner.x, corner.y, corner.z)
+    normals.push(corner.nx, corner.ny, corner.nz)
+  }
+
+  for (let i = 0; i + 2 < position.count; i += 3) {
+    const corners: Corner[] = [0, 1, 2].map((k) => ({
+      x: position.getX(i + k),
+      y: position.getY(i + k),
+      z: position.getZ(i + k),
+      nx: normal.getX(i + k),
+      ny: normal.getY(i + k),
+      nz: normal.getZ(i + k),
+    }))
+    const [a, b, c] = corners as [Corner, Corner, Corner]
+    const minX = Math.min(a.x, b.x, c.x)
+    const maxX = Math.max(a.x, b.x, c.x)
+    const minZ = Math.min(a.z, b.z, c.z)
+    const maxZ = Math.max(a.z, b.z, c.z)
+    const reached = boxes.some(
+      (box) => box.maxX > minX && box.minX < maxX && box.maxZ > minZ && box.minZ < maxZ,
+    )
+    const plan: [[number, number], [number, number], [number, number]] = [
+      [a.x, a.z],
+      [b.x, b.z],
+      [c.x, c.z],
+    ]
+    const determinant = orient(plan[0], plan[1], plan[2])
+    if (!reached || Math.abs(determinant) < MIN_PLAN_AREA) {
+      corners.forEach(push)
+      continue
+    }
+
+    let pieces: ReturnType<typeof difference>
+    try {
+      pieces = difference(plan, cutouts, { throwOnError: true })
+    } catch {
+      corners.forEach(push)
+      continue
+    }
+
+    const at = (x: number, z: number): Corner => {
+      const wa = ((b.z - c.z) * (x - c.x) + (c.x - b.x) * (z - c.z)) / determinant
+      const wb = ((c.z - a.z) * (x - c.x) + (a.x - c.x) * (z - c.z)) / determinant
+      const wc = 1 - wa - wb
+      const nx = a.nx * wa + b.nx * wb + c.nx * wc
+      const ny = a.ny * wa + b.ny * wb + c.ny * wc
+      const nz = a.nz * wa + b.nz * wb + c.nz * wc
+      const length = Math.hypot(nx, ny, nz) || 1
+      return {
+        x,
+        y: a.y * wa + b.y * wb + c.y * wc,
+        z,
+        nx: nx / length,
+        ny: ny / length,
+        nz: nz / length,
+      }
+    }
+
+    for (const piece of pieces) {
+      const rings = [piece.outer, ...piece.holes]
+      const points = rings.flat()
+      const contour = piece.outer.map(([x, z]) => new Vector2(x, z))
+      const voids = piece.holes.map((ring) => ring.map(([x, z]) => new Vector2(x, z)))
+      for (const [p, q, r] of ShapeUtils.triangulateShape(contour, voids)) {
+        const corner = [p, q, r].map((index) => points[index as number] as [number, number])
+        const swap =
+          Math.sign(orient(corner[0]!, corner[1]!, corner[2]!)) !== Math.sign(determinant)
+        const ordered = swap ? [corner[0]!, corner[2]!, corner[1]!] : corner
+        for (const [x, z] of ordered) push(at(x, z))
+      }
+    }
+  }
+
+  const cut = new BufferGeometry()
+  cut.setAttribute('position', new BufferAttribute(new Float32Array(positions), 3))
+  cut.setAttribute('normal', new BufferAttribute(new Float32Array(normals), 3))
+  geometry.dispose()
+  return cut
+}

package/src/components/editor/first-person/mechanism-targets.test.ts

@@ -1,14 +1,21 @@
-import { afterEach, describe, expect, test } from 'bun:test'
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
 import {
   type AnyNode,
   type AnyNodeId,
+  nodeRegistry,
   registerNode,
   sceneRegistry,
   useInteractive,
   useScene,
 } from '@pascal-app/core'
 import { Object3D } from 'three'
-import { mechanismHudInteract, mechanismTargetIds } from './mechanism-targets'
+import {
+  hasNativeLeaf,
+  mechanismHudInteract,
+  mechanismTargetIds,
+  nativeOpeningIds,
+  watchScriptedDoors,
+} from './mechanism-targets'
 
 const switchMechanism = {
   has: (node: AnyNode) => (node as unknown as { joints: number }).joints > 0,
@@ -73,3 +80,83 @@ describe('walkthrough mechanism targets', () => {
     expect(mechanismHudInteract(mount(registerKind({}), 'plain_hud'))).toBeNull()
   })
 })
+
+// A door or window built from a script has no native leaf or sash: the walkthrough's own door and
+// window targets only start a native swing on it, which draws nothing. Its `open` clip runs
+// through its mechanism, as an authored object's does.
+describe('walkthrough doors and windows', () => {
+  const script = { source: { kind: 'script', script: 'b'.repeat(64), artifact: 'a'.repeat(64) } }
+
+  test('the doors and windows it swings itself are the ones with a native leaf', () => {
+    const native = mount('door', 'door_native')
+    const scripted = mount('door', 'door_scripted', script)
+    mount('window', 'window_native')
+    mount('window', 'window_scripted', script)
+
+    expect(nativeOpeningIds().sort()).toEqual(['door_native', 'window_native'] as AnyNodeId[])
+    expect(hasNativeLeaf(native)).toBe(true)
+    expect(hasNativeLeaf(scripted)).toBe(false)
+    expect(hasNativeLeaf(undefined)).toBe(true)
+  })
+})
+
+// The walkthrough's collider world is rebuilt when a native door's tween ends. A door built from a
+// script opens by a clip that no tween system reports: its collider follows its mechanism, so
+// the world has to be rebuilt when that flips.
+describe('walkthrough scripted doors', () => {
+  const mechanism = {
+    verb: 'open',
+    has: (node: AnyNode) => Boolean((node as unknown as { source?: unknown }).source),
+    isOn: (node: AnyNode, state: ReturnType<typeof useInteractive.getState>) =>
+      Boolean(state.items[node.id as AnyNodeId]?.controlValues[0]),
+    set: () => {},
+  }
+  let restoreRegistry = () => {}
+
+  beforeEach(() => {
+    restoreRegistry = nodeRegistry._snapshot()
+    registerNode({
+      kind: 'door',
+      schemaVersion: 1,
+      category: 'structure',
+      defaults: () => ({}),
+      capabilities: { mechanism },
+    } as never)
+  })
+
+  afterEach(() => {
+    useInteractive.setState({ items: {} } as never)
+    restoreRegistry()
+  })
+
+  test('a rebuild is asked for when a scripted door opens or closes, and for nothing else', () => {
+    mount('door', 'door_scripted_watch', { source: { kind: 'script' } })
+    mount('door', 'door_native_watch')
+    let rebuilds = 0
+    const stop = watchScriptedDoors(() => rebuilds++)
+    const setControls = (scripted: boolean, native: boolean) =>
+      useInteractive.setState({
+        items: {
+          door_scripted_watch: { controlValues: [scripted] },
+          door_native_watch: { controlValues: [native] },
+        },
+      } as never)
+    try {
+      // its model initialising the item closed is not a change
+      setControls(false, false)
+      expect(rebuilds).toBe(0)
+      setControls(true, false)
+      expect(rebuilds).toBe(1)
+      // the same state again, and a native door's control, are not its business
+      setControls(true, false)
+      setControls(true, true)
+      expect(rebuilds).toBe(1)
+      setControls(false, true)
+      expect(rebuilds).toBe(2)
+    } finally {
+      stop()
+    }
+    setControls(true, true)
+    expect(rebuilds).toBe(2)
+  })
+})

package/src/components/editor/first-person/mechanism-targets.ts

@@ -1,6 +1,7 @@
 import {
   type AnyNode,
   type AnyNodeId,
+  isScriptedNode,
   nodeMechanism,
   nodeRegistry,
   sceneRegistry,
@@ -9,6 +10,27 @@ import {
 } from '@pascal-app/core'
 import type { WalkthroughInteract } from '../../../store/use-first-person-hud'
 
+/**
+ * Whether the walkthrough swings this door or window itself, through the native `operationState`
+ * its door and window systems draw. One built from a script has no native leaf or sash: a swing
+ * would draw nothing, so its clips run through its mechanism, as an authored object's do.
+ */
+export function hasNativeLeaf(node: AnyNode | undefined): boolean {
+  return !isScriptedNode(node)
+}
+
+/** Mounted doors and windows the walkthrough's own door and window targets cover. */
+export function nativeOpeningIds(): AnyNodeId[] {
+  const nodes = useScene.getState().nodes
+  const ids: AnyNodeId[] = []
+  for (const kind of ['door', 'window'] as const) {
+    for (const id of sceneRegistry.byType[kind] ?? []) {
+      if (hasNativeLeaf(nodes[id as AnyNodeId])) ids.push(id as AnyNodeId)
+    }
+  }
+  return ids
+}
+
 /**
  * Mounted nodes the walkthrough runs through `capabilities.mechanism`, any kind
  * included. `covered` holds the nodes a finer target already tested (procedural
@@ -34,3 +56,33 @@ export function mechanismHudInteract(node: AnyNode): WalkthroughInteract {
   const verb = mechanism.verb === 'open' ? (on ? 'close' : 'open') : on ? 'turn off' : 'turn on'
   return { label: node.name ?? 'item', verb }
 }
+
+/** Ids of the mounted doors built from a script that are open, by their mechanism. */
+function openScriptedDoors(): string {
+  const nodes = useScene.getState().nodes
+  const state = useInteractive.getState()
+  const open: string[] = []
+  for (const id of sceneRegistry.byType.door ?? []) {
+    const node = nodes[id as AnyNodeId]
+    if (isScriptedNode(node) && nodeMechanism(node)?.isOn(node, state)) open.push(id)
+  }
+  return open.sort().join(',')
+}
+
+/**
+ * Calls `onChange` when a mounted door built from a script opens or closes. The walkthrough's
+ * collider follows the door's mechanism, and its model's clip is moved by no tween system that
+ * would report the end, as a native door's does: without this the world keeps the leaf that was
+ * there when it was last built. It fires at the toggle: the doorway is passable as the leaves
+ * start to move, and solid again as they start to close.
+ */
+export function watchScriptedDoors(onChange: () => void): () => void {
+  let known = openScriptedDoors()
+  return useInteractive.subscribe((state, previous) => {
+    if (state.items === previous.items) return
+    const next = openScriptedDoors()
+    if (next === known) return
+    known = next
+    onChange()
+  })
+}

package/src/components/editor/first-person-controls.tsx

@@ -81,6 +81,7 @@ import {
   isOperationDoorType,
   toggleDoorOpenState,
 } from '../../lib/door-interaction'
+import { isTypingTarget } from '../../lib/typing-target'
 import {
   closeWindowOpenState,
   getDisplayedWindowValue,
@@ -97,7 +98,13 @@ import {
   type FirstPersonColliderWorld,
   type FirstPersonSpawn,
 } from './first-person/build-collider-world'
-import { mechanismHudInteract, mechanismTargetIds } from './first-person/mechanism-targets'
+import {
+  hasNativeLeaf,
+  mechanismHudInteract,
+  mechanismTargetIds,
+  nativeOpeningIds,
+  watchScriptedDoors,
+} from './first-person/mechanism-targets'
 
 const CAMERA_EYE_OFFSET = 0.45
 const LOOK_SENSITIVITY = 0.002
@@ -515,7 +522,7 @@ function createElevatorColliderMesh(
   ;(bvhGeometry as any).computeBoundsTree = computeBoundsTree
   ;(bvhGeometry as any).disposeBoundsTree = disposeBoundsTree
   bvhGeometry.computeBoundsTree?.({
-    maxLeafSize: 12,
+    targetLeafSize: 12,
     strategy: 0,
   } as never)
   bvhGeometry.computeBoundingBox()
@@ -838,6 +845,7 @@ export const FirstPersonControls = () => {
       const node = nodes[doorId as AnyNodeId]
       if (node?.type !== 'door') continue
       if (node.openingKind === 'opening') continue
+      if (!hasNativeLeaf(node)) continue
       if (node.segments.every((segment) => segment.type === 'empty')) continue
 
       const object = sceneRegistry.nodes.get(doorId)
@@ -936,6 +944,7 @@ export const FirstPersonControls = () => {
       const node = nodes[windowId as AnyNodeId]
       if (node?.type !== 'window') continue
       if (node.openingKind === 'opening') continue
+      if (!hasNativeLeaf(node)) continue
       if (!isOperableWindowType(node.windowType)) continue
 
       const object = sceneRegistry.nodes.get(windowId)
@@ -1082,9 +1091,9 @@ export const FirstPersonControls = () => {
         closestDistance = hit.distance
       }
     }
-    // Doors and windows have their own walkthrough targets (resolveInteractable*Id).
-    for (const rawId of sceneRegistry.byType.door ?? []) covered.add(rawId)
-    for (const rawId of sceneRegistry.byType.window ?? []) covered.add(rawId)
+    // Doors and windows have their own walkthrough targets (resolveInteractable*Id), except those
+    // built from a script: their clips run through the mechanism target below.
+    for (const id of nativeOpeningIds()) covered.add(id)
     for (const id of mechanismTargetIds(covered)) {
       const object = sceneRegistry.nodes.get(id)
       const hit = object && proceduralInteractionRaycaster.intersectObject(object, true)[0]
@@ -1298,9 +1307,12 @@ export const FirstPersonControls = () => {
     if (isDroneMode) return
     emitter.on('door:animation-completed', rebuildColliderWorld)
     emitter.on('window:animation-completed', rebuildColliderWorld)
+    // A door built from a script opens by its model's clip, which reports no animation end.
+    const stopWatching = watchScriptedDoors(rebuildColliderWorld)
     return () => {
       emitter.off('door:animation-completed', rebuildColliderWorld)
       emitter.off('window:animation-completed', rebuildColliderWorld)
+      stopWatching()
     }
   }, [isDroneMode, rebuildColliderWorld])
 
@@ -1456,9 +1468,7 @@ export const FirstPersonControls = () => {
     const canvas = gl.domElement
 
     const applyMovementKey = (event: KeyboardEvent, active: boolean) => {
-      if (event.target instanceof HTMLInputElement || event.target instanceof HTMLTextAreaElement) {
-        return false
-      }
+      if (isTypingTarget(event.target)) return false
 
       const movement = getMovementInputForKey(event.code, active)
       if (!movement) return false
@@ -1473,9 +1483,7 @@ export const FirstPersonControls = () => {
       const handledMovement = applyMovementKey(event, true)
       if (handledMovement) return
 
-      if (event.target instanceof HTMLInputElement || event.target instanceof HTMLTextAreaElement) {
-        return
-      }
+      if (isTypingTarget(event.target)) return
 
       if (event.code === 'ControlLeft' || event.code === 'ControlRight') {
         // While paused (P), crouch is frozen as-is — ⌃⇧⌘4 (clipboard

package/src/components/editor/floor-aware-camera-controls.test.ts

@@ -2,11 +2,13 @@ import { afterAll, beforeAll, expect, test } from 'bun:test'
 import { CameraControlsImpl } from '@react-three/drei'
 import * as THREE from 'three'
 import {
+  diveFloorY,
   LOOK_UP_PITCH_GAIN,
   LOOK_UP_PUSH_HALF_ANGLE,
   MAX_ORBIT_POLAR_ANGLE,
   ORBIT_FLOOR_CLEARANCE,
   ORBIT_TARGET_HEIGHT,
+  orbitFloorMinY,
 } from '../../lib/orbit-floor-clearance'
 import { FloorAwareCameraControls } from './floor-aware-camera-controls'
 
@@ -440,3 +442,25 @@ test('once the user moves the camera, a written low pose eases up to the clearan
   }
   expect(controls.camera.position.y).toBeCloseTo(0.05 + GROUND_MIN_Y, 4)
 })
+
+test('with the dive on the eye goes under the ground and stops at the dive floor', () => {
+  const controls = groundFloorControls()
+  const diveFloor = diveFloorY(-0.05, null)
+  controls.floorMinY = orbitFloorMinY(0, diveFloor)
+  // The dive turns the surface off: the ground and the floor would hold the eye over them.
+  controls.floorSurface = null
+  const { distance } = controls
+  orbitTo(controls, 100)
+  // The pivot is at the ground's level: 10° past the horizon the eye is about a metre under it.
+  expect(controls.camera.position.y).toBeCloseTo(distance * Math.cos(degrees(100)), 6)
+  expect(controls.camera.position.y).toBeLessThan(0)
+  orbitTo(controls, 150)
+  expect(controls.camera.position.y).toBeCloseTo(diveFloor + ORBIT_FLOOR_CLEARANCE, 6)
+})
+
+test('without the dive the same orbit stays over the ground floor', () => {
+  const controls = groundFloorControls()
+  controls.floorSurface = { revision: 0, topAt: () => 0 }
+  orbitTo(controls, 100)
+  expect(controls.camera.position.y).toBeGreaterThanOrEqual(GROUND_MIN_Y - 1e-6)
+})

package/src/components/editor/floorplan-mode-coordinator.tsx

@@ -59,7 +59,7 @@ export function FloorplanModeCoordinator() {
       <span>{notice.message}</span>
       {notice.kind === 'switch-to-expert' ? (
         <button
-          className="shrink-0 rounded-md bg-cyan-500/15 px-2.5 py-1 font-medium text-cyan-400 hover:bg-cyan-500/25"
+          className="shrink-0 rounded-md bg-cyan-500/15 px-2.5 py-1 font-medium text-cyan-700 dark:text-cyan-400 hover:bg-cyan-500/25"
           onClick={() => {
             setFloorplanMode('expert')
             dismissNotice()
@@ -71,7 +71,7 @@ export function FloorplanModeCoordinator() {
       ) : null}
       <button
         aria-label="Dismiss"
-        className="shrink-0 rounded p-1 text-muted-foreground hover:bg-white/10 hover:text-foreground"
+        className="shrink-0 rounded p-1 text-muted-foreground hover:bg-black/6 dark:hover:bg-white/10 hover:text-foreground"
         onClick={dismissNotice}
         type="button"
       >