@pascal-app/editor 1.0.1 → 1.0.4

package/src/lib/spatial-pointer-input.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, test } from 'bun:test'
+import { Ray, Vector3 } from 'three'
+import { getSpatialPointerId, SpatialPointerInput } from './spatial-pointer-input'
+
+describe('SpatialPointerInput', () => {
+  test('recognizes current and legacy XR native event shapes', () => {
+    const source = {}
+    expect(getSpatialPointerId({ inputSource: source })).toBe(source)
+    expect(getSpatialPointerId({ pointerState: { inputSource: source } })).toBe(source)
+    expect(getSpatialPointerId({ pointerType: 'mouse' })).toBeNull()
+  })
+
+  test('keeps move and release bound to the pointer that captured a handle', () => {
+    const input = new SpatialPointerInput()
+    const moves: Ray[] = []
+    let releases = 0
+    input.capture(42, {
+      onMove: (ray) => moves.push(ray.clone()),
+      onRelease: () => releases++,
+      onCancel: () => undefined,
+    })
+    const ray = new Ray(new Vector3(1, 2, 3), new Vector3(0, 1, 0))
+    expect(input.move(7, ray)).toBe(false)
+    expect(input.move(42, ray)).toBe(true)
+    expect(input.release(7)).toBe(false)
+    expect(input.release(42)).toBe(true)
+    expect(moves).toHaveLength(1)
+    expect(moves[0]?.origin.toArray()).toEqual([1, 2, 3])
+    expect(releases).toBe(1)
+    expect(input.move(42, ray)).toBe(false)
+  })
+
+  test('cancels a captured handle without releasing it', () => {
+    const input = new SpatialPointerInput()
+    let cancels = 0
+    let releases = 0
+
+    input.capture(9, {
+      onMove: () => undefined,
+      onRelease: () => releases++,
+      onCancel: () => cancels++,
+    })
+
+    expect(input.cancel(9)).toBe(true)
+    expect(cancels).toBe(1)
+    expect(releases).toBe(0)
+  })
+
+  test('cleans up a replaced capture without letting its stale disposer clear the replacement', () => {
+    const input = new SpatialPointerInput()
+    const ray = new Ray(new Vector3(), new Vector3(0, 0, -1))
+    let replacements = 0
+    let replacementMoves = 0
+
+    const disposeOriginal = input.capture(12, {
+      onMove: () => undefined,
+      onRelease: () => undefined,
+      onCancel: () => undefined,
+      onReplace: () => replacements++,
+    })
+    input.capture(12, {
+      onMove: () => replacementMoves++,
+      onRelease: () => undefined,
+      onCancel: () => undefined,
+    })
+
+    expect(replacements).toBe(1)
+    disposeOriginal()
+    expect(input.move(12, ray)).toBe(true)
+    expect(replacementMoves).toBe(1)
+  })
+})

package/src/lib/spatial-pointer-input.ts

@@ -0,0 +1,62 @@
+import type { Ray } from 'three'
+
+type SpatialPointerCapture = {
+  onMove: (ray: Ray) => void
+  onRelease: () => void
+  onCancel: () => void
+  onReplace?: () => void
+}
+
+export type SpatialPointerId = object | number | string
+
+export function getSpatialPointerId(nativeEvent: unknown): SpatialPointerId | null {
+  if (!nativeEvent || typeof nativeEvent !== 'object') return null
+  const event = nativeEvent as {
+    inputSource?: object
+    pointerState?: { inputSource?: object }
+  }
+  return event.inputSource ?? event.pointerState?.inputSource ?? null
+}
+
+export class SpatialPointerInput {
+  private readonly captures = new Map<SpatialPointerId, SpatialPointerCapture>()
+
+  capture(pointerId: SpatialPointerId, capture: SpatialPointerCapture): () => void {
+    const previous = this.captures.get(pointerId)
+    if (previous && previous !== capture) {
+      this.captures.delete(pointerId)
+      ;(previous.onReplace ?? previous.onCancel)()
+    }
+    this.captures.set(pointerId, capture)
+    return () => {
+      if (this.captures.get(pointerId) === capture) {
+        this.captures.delete(pointerId)
+      }
+    }
+  }
+
+  move(pointerId: SpatialPointerId, ray: Ray): boolean {
+    const capture = this.captures.get(pointerId)
+    if (!capture) return false
+    capture.onMove(ray)
+    return true
+  }
+
+  release(pointerId: SpatialPointerId): boolean {
+    const capture = this.captures.get(pointerId)
+    if (!capture) return false
+    this.captures.delete(pointerId)
+    capture.onRelease()
+    return true
+  }
+
+  cancel(pointerId: SpatialPointerId): boolean {
+    const capture = this.captures.get(pointerId)
+    if (!capture) return false
+    this.captures.delete(pointerId)
+    capture.onCancel()
+    return true
+  }
+}
+
+export const spatialPointerInput = new SpatialPointerInput()

package/src/lib/spatial-snap.test.ts

@@ -0,0 +1,47 @@
+import { test } from 'bun:test'
+import assert from 'node:assert/strict'
+import { snapLocalXZInWorld } from '@pascal-app/core'
+import { Group, Vector3 } from 'three'
+
+const close = (a: number, b: number) => assert.ok(Math.abs(a - b) < 1e-8)
+
+test('free placement stays under the same hit through God-mode zoom and rotation', () => {
+  const pose = { position: [5, 0, -3] as [number, number, number], rotationY: 0.7 }
+  const world = new Group()
+  const building = new Group()
+  building.position.fromArray(pose.position)
+  building.rotation.y = pose.rotationY
+  world.add(building)
+  for (const scale of [0.01, 0.1, 1, 4]) {
+    world.scale.setScalar(scale)
+    world.position.set(8, 1, -4)
+    world.rotation.y = 1.2
+    world.updateWorldMatrix(true, true)
+    const hit = building.localToWorld(new Vector3(2, 0, -6))
+    const local = building.worldToLocal(hit.clone())
+    const snapped = snapLocalXZInWorld([local.x, local.z], pose, (value) => value)
+    const placed = building.localToWorld(new Vector3(snapped[0], 0, snapped[1]))
+    close(placed.distanceTo(hit), 0)
+  }
+})
+
+test('grid snapping still uses model units and the item footprint', () => {
+  const dimensions: number[] = []
+  const result = snapLocalXZInWorld([1.23, -2.16], null, (value, axis) => {
+    dimensions.push([1.8, 0.6][axis]!)
+    return Math.round(value / 0.1) * 0.1
+  })
+  close(result[0], 1.2)
+  close(result[1], -2.2)
+  assert.deepEqual(dimensions, [1.8, 0.6])
+})
+
+test('rotated buildings snap in model-world axes then return building-local coordinates', () => {
+  const result = snapLocalXZInWorld(
+    [1.2, 2.3],
+    { position: [10, 0, 20], rotationY: Math.PI / 2 },
+    Math.round,
+  )
+  close(result[0], 1)
+  close(result[1], 2)
+})

package/src/lib/terrace-draft.test.ts

@@ -0,0 +1,145 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import {
+  type AnyNode,
+  BuildingNode,
+  clearSceneHistory,
+  createZone,
+  generateId,
+  initSpaceDetectionSync,
+  LevelNode,
+  useScene,
+  type ZoneNode,
+} from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import useEditor from '../store/use-editor'
+import useInteractionScope from '../store/use-interaction-scope'
+import {
+  moveFloorRegion,
+  pressFloorRegion,
+  releaseFloorRegion,
+  useFloorRegionDraft,
+} from './floor-region-session'
+import type { FloorRegionPoint, FloorRegionSnapSettings } from './floor-region-snap'
+import { liveGestureKinds } from './gesture-lifecycle'
+import { applyRoomPlan } from './room-structure-commands'
+import {
+  cancelTerraceDraft,
+  planTerrace,
+  startTerraceDraft,
+  useTerraceDraft,
+} from './terrace-draft'
+
+const LEVEL = 'level_terrace'
+const OFF: FloorRegionSnapSettings = { mode: 'off', step: 0.5 }
+let stop = () => {}
+const nodes = () => useScene.getState().nodes as Record<string, AnyNode>
+const history = () => useScene.temporal.getState().pastStates.length
+const zones = () =>
+  Object.values(nodes()).filter((n): n is ZoneNode => n.type === 'zone' && n.spaceRole === 'room')
+
+function box(from: FloorRegionPoint, to: FloorRegionPoint) {
+  const host = useTerraceDraft.getState().host!
+  pressFloorRegion('rectangle', host, from, OFF, 0.2)
+  moveFloorRegion(to, OFF, 0.2)
+  releaseFloorRegion(0.2)
+}
+
+beforeEach(() => {
+  globalThis.requestAnimationFrame ??= (callback) => {
+    callback(0)
+    return 0
+  }
+  globalThis.cancelAnimationFrame ??= () => {}
+  useInteractionScope.getState().end()
+  const building = BuildingNode.parse({ id: 'building_terrace', children: [LEVEL] })
+  const level = LevelNode.parse({ id: LEVEL, parentId: building.id })
+  useScene.setState({
+    nodes: { [building.id]: building, [level.id]: level },
+    rootNodeIds: [building.id],
+    dirtyNodes: new Set(),
+    materials: {},
+    collections: {},
+    readOnly: false,
+  })
+  useScene.temporal.getState().resume()
+  stop = initSpaceDetectionSync(useScene, { getState: () => ({ spaces: {}, setSpaces: () => {} }) })
+  applyRoomPlan(
+    createZone(nodes(), {
+      levelId: LEVEL,
+      polygon: [
+        [0, 0],
+        [6, 0],
+        [6, 5],
+        [0, 5],
+      ],
+      enclose: true,
+      name: 'Living room',
+      mintId: generateId,
+    }),
+  )
+  useViewer.getState().setSelection({ buildingId: building.id, levelId: LEVEL, selectedIds: [] })
+  useEditor.setState({ phase: 'building', mode: 'select', room: null })
+  useFloorRegionDraft.setState({ draft: null, hover: null })
+  clearSceneHistory()
+})
+afterEach(() => {
+  cancelTerraceDraft()
+  stop()
+  stop = () => {}
+})
+
+describe('terrace tool', () => {
+  test('a terrace is an outdoor room: separators where no wall runs, no ceiling', () => {
+    const walls = Object.values(nodes()).filter((n) => n.type === 'wall').length
+    const result = planTerrace(nodes(), LEVEL, [
+      [6, 0],
+      [10, 0],
+      [10, 5],
+      [6, 5],
+    ])
+    expect('plan' in result).toBe(true)
+    if (!('plan' in result)) return
+    applyRoomPlan(result.plan)
+    const terrace = nodes()[result.plan.zoneId] as ZoneNode
+    expect(terrace).toMatchObject({ name: 'Terrace', spaceRole: 'room', hasCeiling: false })
+    expect(Object.values(nodes()).filter((n) => n.type === 'wall')).toHaveLength(walls)
+    // Three new sides are separators; the fourth is the house wall it shares.
+    expect(Object.values(nodes()).filter((n) => n.type === 'separator')).toHaveLength(3)
+    expect(
+      Object.values(nodes()).some((n) => n.type === 'ceiling' && n.zoneId === terrace.id),
+    ).toBe(false)
+  })
+
+  test('refuses an outline over a room', () => {
+    expect(
+      planTerrace(nodes(), LEVEL, [
+        [4, 1],
+        [8, 1],
+        [8, 3],
+        [4, 3],
+      ]),
+    ).toEqual({ message: 'The terrace overlaps Living room.' })
+  })
+
+  test('draws like the room tools: each outline one undo step, the tool stays armed', () => {
+    expect(startTerraceDraft(LEVEL)).toBe(true)
+    expect(liveGestureKinds()).toEqual(['terrace-draft'])
+    box([7, 0], [11, 4])
+    expect(
+      zones()
+        .map((zone) => zone.name)
+        .sort(),
+    ).toEqual(['Living room', 'Terrace'])
+    expect(history()).toBe(1)
+    expect(useTerraceDraft.getState().host).not.toBeNull()
+    // An outline over the house is refused in place; nothing is written.
+    box([2, 2], [4, 4])
+    expect(useFloorRegionDraft.getState().draft).toMatchObject({
+      refusal: 'The terrace overlaps Living room.',
+    })
+    expect(history()).toBe(1)
+    cancelTerraceDraft()
+    expect(useTerraceDraft.getState().host).toBeNull()
+    expect(useInteractionScope.getState().scope.kind).toBe('idle')
+  })
+})

package/src/lib/terrace-draft.ts

@@ -0,0 +1,213 @@
+import {
+  type AnyNode,
+  type AnyNodeId,
+  area,
+  createZone,
+  generateId,
+  type MultiPolygon,
+  type StructurePlan,
+  type ToolHint,
+  useScene,
+} from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import { create } from 'zustand'
+import useEditor from '../store/use-editor'
+import { CROSSING_MESSAGE, floorRegionSelfIntersects } from './floor-region-geometry'
+import {
+  cancelFloorRegion,
+  type FloorDraftCommit,
+  type FloorDraftPurpose,
+  type FloorRegionRoom,
+  useFloorRegionDraft,
+} from './floor-region-session'
+import { type FloorRegionPoint, floorRegionSnapTargets } from './floor-region-snap'
+import { beginGesture, type GestureHandle } from './gesture-lifecycle'
+import { applyRoomPlan } from './room-structure-commands'
+import { sfxEmitter } from './sfx-bus'
+
+// "Terrace" (Build panel → Outdoor): draws an outdoor room on the level's
+// ground, rectangle or polygon, snapped to the rooms already there and the
+// grid. The terrace is a room like any other — bounded by separators (and by
+// the walls it shares), no walls of its own and no ceiling — so it gets
+// everything rooms have: finish paint, height arrows, Divide, Move, Delete.
+// The tool is one lifecycle gesture from `startTerraceDraft` until cancelled;
+// each outline commits as one undo step and the tool stays armed, like the
+// room tools.
+
+export const TERRACE_DRAFT_HANDLE = 'terrace-draft'
+export const TERRACE_NAME = 'Terrace'
+export const TERRACE_TOO_SMALL_MESSAGE = 'Too small for a terrace.'
+export const TERRACE_FAILED_MESSAGE = "Can't place a terrace here."
+
+export type TerraceShape = 'rectangle' | 'polygon'
+
+export const useTerraceDraft = create<{
+  host: FloorRegionRoom | null
+  shape: TerraceShape
+}>(() => ({ host: null, shape: 'rectangle' }))
+
+/** How far the terrace tool reaches from the origin when the site has no outline. */
+const OPEN_GROUND = 500
+
+/**
+ * Why a terrace outline cannot be built, or its plan: an outdoor room of the
+ * outline, closed with separators where no wall runs, without a ceiling.
+ * Core refuses an outline over a room (the same rule MCP's outdoor
+ * `create_room` follows) and names the room.
+ */
+export function planTerrace(
+  nodes: Record<string, AnyNode>,
+  levelId: string,
+  polygon: readonly FloorRegionPoint[],
+): { plan: StructurePlan & { zoneId: string } } | { message: string } {
+  const outline = polygon.map(([x, z]): [number, number] => [x, z])
+  if (floorRegionSelfIntersects(outline)) return { message: CROSSING_MESSAGE }
+  if (area([{ outer: outline, holes: [] }]) < 1) return { message: TERRACE_TOO_SMALL_MESSAGE }
+  try {
+    const plan = createZone(nodes, {
+      levelId,
+      polygon: outline,
+      name: TERRACE_NAME,
+      enclose: false,
+      intent: { hasCeiling: false },
+      mintId: generateId,
+    })
+    const conflict = plan.conflicts?.[0]
+    return conflict ? { message: conflict.message || TERRACE_FAILED_MESSAGE } : { plan }
+  } catch {
+    return { message: TERRACE_FAILED_MESSAGE }
+  }
+}
+
+let tool: GestureHandle | null = null
+
+function reset() {
+  if (useTerraceDraft.getState().host) useTerraceDraft.setState({ host: null })
+  const { draft } = useFloorRegionDraft.getState()
+  if (draft?.room.purpose === TERRACE) useFloorRegionDraft.setState({ draft: null, hover: null })
+}
+
+function commitTerrace(
+  host: FloorRegionRoom,
+  polygon: readonly FloorRegionPoint[],
+): FloorDraftCommit {
+  const result = planTerrace(useScene.getState().nodes, host.levelId, polygon)
+  if ('message' in result) return { ok: false, message: result.message }
+  applyRoomPlan(result.plan)
+  sfxEmitter.emit('sfx:structure-build')
+  // The rooms (and this terrace) now snap the next outline.
+  useTerraceDraft.setState({ host: describeTerraceHost(useScene.getState().nodes, host.levelId) })
+  return { ok: true }
+}
+
+function beginTool(host: FloorRegionRoom) {
+  const handle = beginGesture({
+    kind: 'terrace-draft',
+    scope: { kind: 'handle-drag', nodeId: host.levelId, handle: TERRACE_DRAFT_HANDLE },
+    stale: () =>
+      useScene.getState().readOnly || !useScene.getState().nodes[host.levelId as AnyNodeId],
+    onCancel: () => {
+      if (tool === handle) tool = null
+      reset()
+    },
+  })
+  tool = handle
+  useTerraceDraft.setState({ host })
+  return handle
+}
+
+const TERRACE: FloorDraftPurpose = {
+  persistent: true,
+  own: (room) => (tool?.active ? tool : beginTool(room)),
+  commit: (room, polygon) => {
+    const current = useTerraceDraft.getState().host ?? room
+    return commitTerrace(current, polygon)
+  },
+  fill: '#818cf8',
+}
+
+/** The level's ground as a draft room: the site (or open ground), snapping to the rooms on it. */
+export function describeTerraceHost(
+  nodes: Record<string, AnyNode>,
+  levelId: string,
+): FloorRegionRoom | null {
+  const level = nodes[levelId]
+  if (level?.type !== 'level') return null
+  const site = Object.values(nodes).find((node) => node.type === 'site')
+  const outline =
+    site?.type === 'site' && site.polygon?.points?.length && site.polygon.points.length >= 3
+      ? site.polygon.points.map(([x, z]): [number, number] => [x, z])
+      : ([
+          [-OPEN_GROUND, -OPEN_GROUND],
+          [OPEN_GROUND, -OPEN_GROUND],
+          [OPEN_GROUND, OPEN_GROUND],
+          [-OPEN_GROUND, OPEN_GROUND],
+        ] as [number, number][])
+  const clear: MultiPolygon = [{ outer: outline, holes: [] }]
+  const rooms = Object.values(nodes).flatMap((node) =>
+    node.type === 'zone' && node.parentId === levelId && node.spaceRole === 'room'
+      ? [node.polygon]
+      : [],
+  )
+  return {
+    zoneId: '',
+    levelId,
+    clear,
+    elevation: 0,
+    angle: 0,
+    targets: floorRegionSnapTargets([], rooms),
+    purpose: TERRACE,
+  }
+}
+
+/** Arms the terrace tool on the current level (select mode, so nothing else draws). */
+export function startTerraceDraft(levelId = useViewer.getState().selection.levelId): boolean {
+  if (!levelId || useScene.getState().readOnly) return false
+  const host = describeTerraceHost(useScene.getState().nodes, levelId)
+  if (!host) return false
+  cancelTerraceDraft()
+  cancelFloorRegion()
+  const editor = useEditor.getState()
+  if (editor.phase === 'site') editor.setPhase('building')
+  if (editor.mode !== 'select') editor.setMode('select')
+  if (editor.room) editor.clearRoom()
+  useViewer.getState().setSelection({ selectedIds: [] })
+  beginTool(host)
+  return true
+}
+
+export function cancelTerraceDraft() {
+  const current = tool
+  tool = null
+  if (current?.active) current.cancel()
+  else reset()
+}
+
+export function terraceDraftActive() {
+  return !!useTerraceDraft.getState().host
+}
+
+export function setTerraceShape(shape: TerraceShape) {
+  if (useTerraceDraft.getState().shape === shape) return
+  const { draft } = useFloorRegionDraft.getState()
+  if (draft?.room.purpose === TERRACE) useFloorRegionDraft.setState({ draft: null })
+  useTerraceDraft.setState({ shape })
+}
+
+export function toggleTerraceShape() {
+  setTerraceShape(useTerraceDraft.getState().shape === 'rectangle' ? 'polygon' : 'rectangle')
+}
+
+/** The HUD's shape chip (T). */
+export const TERRACE_SHAPE_HINT: ToolHint = {
+  key: 'T',
+  label: 'Shape',
+  chip: {
+    subscribe: (onChange) => useTerraceDraft.subscribe(onChange),
+    value: () => useTerraceDraft.getState().shape,
+    cycle: toggleTerraceShape,
+    labels: { rectangle: 'Shape: Rectangle', polygon: 'Shape: Polygon' },
+    icons: { rectangle: 'lucide:square', polygon: 'lucide:pentagon' },
+    tooltip: 'Outline shape — click or press T to switch',
+  },
+}

package/src/lib/terrain-panel-model.ts

@@ -0,0 +1,117 @@
+'use client'
+
+import { type SiteNode, type TerrainVerb, useScene } from '@pascal-app/core'
+import useEditor from '../store/use-editor'
+import type { PanelRow } from './panel-rows'
+import { brushRadiusRange, flattenSite, resetSiteTerrain } from './terrain-sculpt'
+
+const TERRAIN_VERBS: TerrainVerb[] = ['raise', 'lower', 'flatten', 'smooth']
+
+export function useTerrainPanelRows(): PanelRow[] {
+  const verb = useEditor((state) => state.terrainVerb)
+  const setVerb = useEditor((state) => state.setTerrainVerb)
+  const brush = useEditor((state) => state.terrainBrush)
+  const setBrush = useEditor((state) => state.setTerrainBrush)
+  const flattenTarget = useEditor((state) => state.terrainFlattenTarget)
+  const setFlattenTarget = useEditor((state) => state.setTerrainFlattenTarget)
+  const sampling = useEditor((state) => state.terrainSampling)
+  const setSampling = useEditor((state) => state.setTerrainSampling)
+  const site = useScene((state) => {
+    const root = state.rootNodeIds[0]
+    const node = root ? state.nodes[root] : undefined
+    return node?.type === 'site' ? (node as SiteNode) : null
+  })
+  const [minRadius, maxRadius] = brushRadiusRange(site)
+  const verbIndex = TERRAIN_VERBS.indexOf(verb)
+  const cycleVerb = (direction: -1 | 1) => {
+    const next =
+      TERRAIN_VERBS[(verbIndex + direction + TERRAIN_VERBS.length) % TERRAIN_VERBS.length]
+    if (next) setVerb(next)
+  }
+
+  const rows: PanelRow[] = [
+    {
+      id: 'terrain-verb',
+      kind: 'cycle',
+      label: 'Brush',
+      next: () => cycleVerb(1),
+      previous: () => cycleVerb(-1),
+      value: verb.charAt(0).toUpperCase() + verb.slice(1),
+    },
+    {
+      id: 'terrain-radius',
+      kind: 'stepper',
+      label: 'Size',
+      max: maxRadius,
+      min: minRadius,
+      onChange: (radius) => setBrush({ radius }),
+      step: 0.5,
+      unit: 'm',
+      value: Math.max(minRadius, Math.min(maxRadius, brush.radius)),
+    },
+    {
+      id: 'terrain-strength',
+      kind: 'stepper',
+      label: 'Strength',
+      max: 1,
+      min: 0.05,
+      onChange: (strength) => setBrush({ strength }),
+      step: 0.05,
+      value: brush.strength,
+    },
+    {
+      id: 'terrain-softness',
+      kind: 'stepper',
+      label: 'Softness',
+      max: 1,
+      min: 0,
+      onChange: (falloff) => setBrush({ falloff }),
+      step: 0.05,
+      value: brush.falloff,
+    },
+    {
+      id: 'terrain-shape',
+      kind: 'choice',
+      label: 'Shape',
+      onSelect: () => setBrush({ shape: brush.shape === 'round' ? 'square' : 'round' }),
+      value: brush.shape === 'round' ? 'Round' : 'Square',
+    },
+    ...(verb === 'flatten'
+      ? ([
+          {
+            id: 'terrain-target',
+            kind: 'stepper',
+            label: 'Target',
+            max: 50,
+            min: -50,
+            onChange: setFlattenTarget,
+            step: 0.1,
+            unit: 'm',
+            value: flattenTarget ?? 0,
+          },
+          {
+            id: 'terrain-sampling',
+            kind: 'choice',
+            label: 'Pick height',
+            onSelect: () => setSampling(!sampling),
+            value: sampling ? 'Armed' : 'Off',
+          },
+        ] satisfies PanelRow[])
+      : []),
+    {
+      id: 'terrain-level-lot',
+      kind: 'choice',
+      label: 'Whole lot',
+      onSelect: site ? () => flattenSite(site, flattenTarget ?? 0) : undefined,
+      value: 'Level',
+    },
+    {
+      id: 'terrain-clear',
+      kind: 'choice',
+      label: 'Terrain',
+      onSelect: site?.terrain ? () => resetSiteTerrain(site) : undefined,
+      value: site?.terrain ? 'Clear' : 'Empty',
+    },
+  ]
+  return rows
+}

package/src/lib/tool-cursor-icon.test.ts

@@ -0,0 +1,16 @@
+import { expect, test } from 'bun:test'
+import { wallCursorIcon } from './tool-cursor-icon'
+import { getWallDrawVariantInfo, WALL_DRAW_VARIANTS } from './wall-draw-variant'
+
+test('the wall cursor bubble shows the Rooms tile icon of the variant in hand', () => {
+  for (const variant of WALL_DRAW_VARIANTS) {
+    expect(wallCursorIcon(variant.mode)).toEqual({
+      label: getWallDrawVariantInfo(variant.id).title,
+      iconSrc: variant.iconSrc,
+    })
+  }
+  expect(
+    new Set(WALL_DRAW_VARIANTS.map((variant) => wallCursorIcon(variant.mode).iconSrc)).size,
+  ).toBe(3)
+  expect(getWallDrawVariantInfo('walls').iconSrc).toBe('/icons/wall.webp')
+})

package/src/lib/tool-cursor-icon.ts

@@ -0,0 +1,11 @@
+import type { ContinuationMode } from './continuation'
+import { getWallDrawVariantInfo, wallDrawVariantOf } from './wall-draw-variant'
+
+/**
+ * The cursor bubble's icon for the wall tool: the Rooms variant in hand
+ * (Rectangle / Polygon / Walls), the same art as the Build panel tile.
+ */
+export function wallCursorIcon(mode: ContinuationMode): { label: string; iconSrc: string } {
+  const variant = getWallDrawVariantInfo(wallDrawVariantOf(mode))
+  return { label: variant.title, iconSrc: variant.iconSrc }
+}