@pascal-app/editor 1.0.3 → 1.0.5

package/src/lib/ceiling-edit-session.ts

@@ -0,0 +1,206 @@
+import {
+  type AnyNode,
+  type AnyNodeId,
+  type BuildingNode,
+  type CeilingNode,
+  derivedFieldViolations,
+  emitter,
+  isDerivedNode,
+  type LevelNode,
+  resolveLevelId,
+  useScene,
+} from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import { useEffect } from 'react'
+import { create } from 'zustand'
+import { markToolCancelConsumed } from '../hooks/use-keyboard'
+import useEditor from '../store/use-editor'
+import useInteractionScope from '../store/use-interaction-scope'
+import { selectRoom } from './room-selection-commands'
+import { completeElementAction } from './room-zone-routing'
+
+/**
+ * The explicit "Edit ceiling" session: while it holds a ceiling, and only then,
+ * that ceiling shows its corner brackets, polygon editor and height handle.
+ *
+ * A tiny store rather than an interaction scope: a non-idle scope turns off
+ * selection picking and hides every overlay, while the session is a standing
+ * mode in which the rest of the scene must stay hoverable and clickable. The
+ * polygon drags inside it still run their own `reshaping` scope.
+ */
+export type CeilingEditSession = {
+  ceilingId: CeilingNode['id']
+  /** The room the ceiling belonged to at start; a polygon edit detaches the link. */
+  zoneId: string | null
+  levelId: string
+}
+
+export const useCeilingEditSession = create<{ session: CeilingEditSession | null }>(() => ({
+  session: null,
+}))
+
+/** The ceiling whose edit controls may show, or null outside a session. */
+export function useCeilingEditCeilingId(): string | null {
+  return useCeilingEditSession((state) => state.session?.ceilingId ?? null)
+}
+
+export function getCeilingEditSession(): CeilingEditSession | null {
+  return useCeilingEditSession.getState().session
+}
+
+type Nodes = Record<string, AnyNode>
+
+function resolveCeiling(nodes: Nodes, target: string): CeilingNode | null {
+  const node = nodes[target]
+  if (node?.type === 'ceiling') return node
+  if (node?.type !== 'zone') return null
+  const linked = Object.values(nodes).filter(
+    (candidate): candidate is CeilingNode =>
+      candidate.type === 'ceiling' && candidate.zoneId === target,
+  )
+  return (
+    linked.find((ceiling) => ceiling.parentId === node.parentId && ceiling.boundary === 'auto') ??
+    linked.find((ceiling) => ceiling.parentId === node.parentId) ??
+    linked[0] ??
+    null
+  )
+}
+
+let stopLifecycle: (() => void) | null = null
+
+/**
+ * Starts editing the ceiling `target` names: a ceiling id, or a room zone id
+ * (its linked ceiling). Selects the ceiling on its level, going inside the
+ * building first. Returns false when there is no such ceiling.
+ */
+export function startCeilingEdit(target: string): boolean {
+  const nodes = useScene.getState().nodes as Nodes
+  const ceiling = resolveCeiling(nodes, target)
+  if (!ceiling) return false
+  endCeilingEdit()
+
+  const levelId = resolveLevelId(ceiling, nodes)
+  const zone = ceiling.zoneId ? nodes[ceiling.zoneId] : nodes[target]
+  const zoneId = zone?.type === 'zone' ? zone.id : null
+  if (useEditor.getState().phase === 'site') useEditor.getState().setPhase('building')
+
+  useCeilingEditSession.setState({ session: { ceilingId: ceiling.id, zoneId, levelId } })
+  const level = nodes[levelId]
+  const selection = useViewer.getState().selection
+  useViewer.getState().setSelection({
+    ...(level?.parentId && level.parentId !== selection.buildingId
+      ? { buildingId: level.parentId as BuildingNode['id'] }
+      : {}),
+    ...(levelId !== selection.levelId ? { levelId: levelId as LevelNode['id'] } : {}),
+    selectedIds: [ceiling.id],
+  })
+  stopLifecycle = watchSession()
+  return true
+}
+
+/**
+ * The scene-graph entry: a plain tree click that left exactly this ceiling
+ * selected opens its session. Modifier multi-selection does not.
+ */
+export function startCeilingEditFromTreeSelection(nodeId: string): boolean {
+  const { selectedIds } = useViewer.getState().selection
+  if (selectedIds.length !== 1 || selectedIds[0] !== nodeId) return false
+  return startCeilingEdit(nodeId)
+}
+
+export function endCeilingEdit() {
+  stopLifecycle?.()
+  stopLifecycle = null
+  const session = getCeilingEditSession()
+  if (!session) return
+  useCeilingEditSession.setState({ session: null })
+  // The hole editor mounts only inside the session; a hole scope it leaves behind
+  // would keep selection picking off with no editor to end it.
+  useInteractionScope
+    .getState()
+    .endIf(
+      (scope) =>
+        scope.kind === 'reshaping' &&
+        scope.reshape === 'hole' &&
+        scope.nodeId === session.ceilingId,
+    )
+}
+
+/** Ends the session with the editor that owns it, so none outlives an unmount. */
+export function useCeilingEditSessionOwner() {
+  useEffect(() => endCeilingEdit, [])
+}
+
+/**
+ * Writes a ceiling's holes. Manual holes are authored data the derived-node
+ * guard allows on an auto ceiling, so this is a plain update that keeps the
+ * room link (only a polygon edit detaches); a write that would change a
+ * room-cut hole is refused (returns false).
+ */
+export function setCeilingHoles(
+  ceilingId: string,
+  patch: Pick<CeilingNode, 'holes'> & Partial<Pick<CeilingNode, 'holeMetadata'>>,
+): boolean {
+  const scene = useScene.getState()
+  const ceiling = scene.nodes[ceilingId as AnyNodeId]
+  if (ceiling?.type !== 'ceiling') return false
+  if (isDerivedNode(ceiling) && derivedFieldViolations(ceiling, patch).length > 0) return false
+  scene.updateNode(ceilingId as AnyNodeId, patch)
+  return true
+}
+
+/** Escape: leaves the session for the ceiling's room, or for nothing when it has none. */
+export function exitCeilingEditToRoom(): boolean {
+  const session = getCeilingEditSession()
+  if (!session) return false
+  endCeilingEdit()
+  const zone = session.zoneId ? useScene.getState().nodes[session.zoneId as AnyNodeId] : undefined
+  if (zone?.type !== 'zone') {
+    useViewer.getState().setSelection({ selectedIds: [] })
+    return true
+  }
+  const room = { levelId: session.levelId, zoneId: zone.id }
+  // A room the index no longer knows (its walls just opened) is still where the user came from.
+  if (!completeElementAction({ room, point: null })) selectRoom(room)
+  return true
+}
+
+function watchSession() {
+  const active = () => getCeilingEditSession()
+  const stopViewer = useViewer.subscribe((state) => {
+    const session = active()
+    if (!session) return
+    const { selectedIds, levelId } = state.selection
+    if (
+      levelId !== session.levelId ||
+      selectedIds.length !== 1 ||
+      selectedIds[0] !== session.ceilingId
+    )
+      endCeilingEdit()
+  })
+  const stopEditor = useEditor.subscribe((state, previous) => {
+    if (state.phase !== previous.phase) endCeilingEdit()
+  })
+  const stopScene = useScene.subscribe((state) => {
+    const session = active()
+    if (session && state.nodes[session.ceilingId as AnyNodeId]?.type !== 'ceiling') endCeilingEdit()
+  })
+  // A reshape in flight owns Escape (it cancels the drag); only an idle session exits.
+  const onToolCancel = () => {
+    if (
+      !active() ||
+      useEditor.getState().mode !== 'select' ||
+      useInteractionScope.getState().scope.kind !== 'idle'
+    )
+      return
+    exitCeilingEditToRoom()
+    markToolCancelConsumed()
+  }
+  emitter.on('tool:cancel', onToolCancel)
+  return () => {
+    stopViewer()
+    stopEditor()
+    stopScene()
+    emitter.off('tool:cancel', onToolCancel)
+  }
+}

package/src/lib/ceiling-region-session.test.ts

@@ -0,0 +1,179 @@
+import { afterAll, afterEach, beforeEach, expect, test } from 'bun:test'
+import {
+  type AnyNode,
+  type AnyNodeId,
+  area,
+  CeilingNode,
+  clearSceneHistory,
+  LevelNode,
+  useScene,
+  ZoneNode,
+} from '@pascal-app/core'
+import useEditor from '../store/use-editor'
+import {
+  describeCeilingRegionRoom,
+  floorRegionRoomGone,
+  moveFloorRegion,
+  PICK_MATERIAL_MESSAGE,
+  pressFloorRegion,
+  releaseFloorRegion,
+  useFloorRegionDraft,
+} from './floor-region-session'
+import type { FloorRegionPoint } from './floor-region-snap'
+import { paintRegionHoverHint, usePaintRegionMode } from './paint-region-mode'
+
+// Rectangle and Polygon on a ceiling: the floor's outline gesture, drawn on the
+// ceiling's underside, committing one region to the room (an automatic
+// ceiling) or to the ceiling (a manual one) in one undo step.
+
+const square = (x: number, z: number, size: number): [number, number][] => [
+  [x, z],
+  [x + size, z],
+  [x + size, z + size],
+  [x, z + size],
+]
+const OFF = { mode: 'off', step: 0.5 } as const
+const CLOSE = 0.2
+
+const level = LevelNode.parse({ id: 'level_ceiling_region' })
+const zone = ZoneNode.parse({
+  id: 'zone_ceiling_region',
+  name: 'Room',
+  parentId: level.id,
+  polygon: square(0, 0, 4),
+  floor: { regions: [{ id: 'rug', polygon: square(1, 1, 1), finish: 'library:tile' }] },
+})
+// A floor opening cut the room's ceiling in two; both parts are the room's.
+const west = CeilingNode.parse({
+  id: 'ceiling_west',
+  parentId: level.id,
+  polygon: [
+    [0, 0],
+    [2, 0],
+    [2, 4],
+    [0, 4],
+  ],
+  boundary: 'auto',
+  zoneId: zone.id,
+  height: 2.5,
+})
+const east = CeilingNode.parse({
+  ...west,
+  id: 'ceiling_east',
+  polygon: [
+    [2.5, 0],
+    [4, 0],
+    [4, 4],
+    [2.5, 4],
+  ],
+})
+const manual = CeilingNode.parse({
+  id: 'ceiling_manual',
+  parentId: level.id,
+  polygon: square(6, 0, 2),
+  height: 2.2,
+})
+const nodes = Object.fromEntries(
+  [level, zone, west, east, manual].map((node) => [node.id, node]),
+) as Record<string, AnyNode>
+
+const stubbed: string[] = []
+const before = useScene.getState()
+const node = <T extends AnyNode>(id: string) => useScene.getState().nodes[id as AnyNodeId] as T
+const history = () => useScene.temporal.getState().pastStates.length
+
+function drag(ceiling: CeilingNode, from: FloorRegionPoint, to: FloorRegionPoint) {
+  const room = describeCeilingRegionRoom(useScene.getState().nodes, ceiling)
+  pressFloorRegion('rectangle', room, from, OFF, CLOSE)
+  moveFloorRegion(to, OFF, CLOSE)
+  releaseFloorRegion(CLOSE)
+}
+
+beforeEach(() => {
+  globalThis.requestAnimationFrame ??= (callback) => {
+    callback(0)
+    return 0
+  }
+  globalThis.cancelAnimationFrame ??= () => {}
+  if (!globalThis.window) {
+    globalThis.window = new EventTarget() as Window & typeof globalThis
+    stubbed.push('window')
+  }
+  useScene.setState({ nodes, materials: {}, readOnly: false })
+  useScene.temporal.getState().resume()
+  clearSceneHistory()
+  useEditor.setState({
+    mode: 'material-paint',
+    activePaintMaterial: { materialPreset: 'library:blue', sourceTarget: 'ceiling' } as never,
+  })
+  usePaintRegionMode.getState().setMode('rectangle')
+  useFloorRegionDraft.setState({ draft: null, hover: null })
+})
+afterEach(() => {
+  useScene.setState(before)
+  usePaintRegionMode.getState().setMode('surface')
+  useFloorRegionDraft.setState({ draft: null, hover: null })
+  useEditor.setState({ mode: 'select', activePaintMaterial: null })
+})
+afterAll(async () => {
+  await new Promise((resolve) => setTimeout(resolve, 50))
+  for (const key of stubbed.splice(0)) delete (globalThis as Record<string, unknown>)[key]
+})
+
+test('an automatic ceiling draws on every part of its room, at the plane it draws at', () => {
+  const room = describeCeilingRegionRoom(nodes, west)
+  expect(room).toMatchObject({ zoneId: zone.id, ceilingId: west.id, levelId: level.id })
+  expect(room.elevation).toBeCloseTo(2.49)
+  expect(area(room.clear)).toBeCloseTo(8 + 6)
+  expect(describeCeilingRegionRoom(nodes, manual)).toMatchObject({ zoneId: manual.id })
+})
+
+test('a rectangle on a room ceiling paints one room region, clipped to the ceiling', () => {
+  drag(west, [1, 1], [3, 3])
+  const regions = node<ZoneNode>(zone.id).ceiling?.regions ?? []
+  expect(regions).toHaveLength(1)
+  expect(regions[0]!.finish).toBe('library:blue')
+  // Across the opening gap: 1 × 2 on the west part, 0.5 × 2 on the east part.
+  expect(area([{ outer: regions[0]!.polygon, holes: [] }])).toBeGreaterThan(2.9)
+  expect(history()).toBe(1)
+  // The floor is untouched.
+  expect(node<ZoneNode>(zone.id).floor).toEqual(zone.floor)
+  expect(useFloorRegionDraft.getState().draft).toBeNull()
+})
+
+test('a polygon on a manual ceiling paints the ceiling itself', () => {
+  usePaintRegionMode.getState().setMode('polygon')
+  const room = describeCeilingRegionRoom(useScene.getState().nodes, manual)
+  for (const point of [
+    [6.2, 0.2],
+    [7.5, 0.2],
+    [7.5, 1.5],
+    [6.2, 0.2],
+  ] as FloorRegionPoint[]) {
+    pressFloorRegion('polygon', room, point, OFF, CLOSE)
+    releaseFloorRegion(CLOSE)
+  }
+  expect(node<CeilingNode>(manual.id).regions).toHaveLength(1)
+  expect(node<ZoneNode>(zone.id).ceiling).toBeUndefined()
+  expect(history()).toBe(1)
+})
+
+test('outside the ceiling, or with nothing to paint with, nothing is written', () => {
+  drag(manual, [10, 10], [12, 12])
+  expect(node<CeilingNode>(manual.id).regions).toBeUndefined()
+  useEditor.setState({ activePaintMaterial: null })
+  drag(manual, [6.5, 0.5], [7.5, 1.5])
+  expect(node<CeilingNode>(manual.id).regions).toBeUndefined()
+  expect(usePaintRegionMode.getState().notice).toBe(PICK_MATERIAL_MESSAGE)
+  expect(history()).toBe(0)
+})
+
+test('a ceiling draft ends when its ceiling goes; the hints name ceilings', () => {
+  const room = describeCeilingRegionRoom(nodes, manual)
+  pressFloorRegion('rectangle', room, [6.5, 0.5], OFF, CLOSE)
+  const { [manual.id]: _, ...rest } = nodes
+  expect(floorRegionRoomGone(rest)).toBe(true)
+  expect(floorRegionRoomGone(nodes)).toBe(false)
+  expect(paintRegionHoverHint('polygon')).toBe('Hover a floor or ceiling')
+  expect(paintRegionHoverHint('rectangle')).toBe('Hover a wall, floor or ceiling')
+})

package/src/lib/continuation.test.ts

@@ -1,5 +1,10 @@
 import { describe, expect, test } from 'bun:test'
-import { CONTINUATION_PROFILES, continuationContextOf, nextContinuation } from './continuation'
+import {
+  CONTINUATION_PROFILES,
+  continuationContextOf,
+  keyCyclableContinuationContext,
+  nextContinuation,
+} from './continuation'
 
 describe('canopy continuation', () => {
   test('maps the canopy tool to its own single and continuous profile', () => {
@@ -9,3 +14,16 @@ describe('canopy continuation', () => {
     expect(nextContinuation('canopy', 'continuous')).toBe('single')
   })
 })
+
+describe('wall drawing mode', () => {
+  test('is picked in the Build panel, never cycled by C or a HUD chip', () => {
+    expect(CONTINUATION_PROFILES.wall.options).toEqual(['room', 'single', 'rectangle'])
+    expect(keyCyclableContinuationContext('wall')).toBeNull()
+  })
+
+  test('other contexts still cycle from the keyboard', () => {
+    expect(keyCyclableContinuationContext('fence')).toBe('fence')
+    expect(keyCyclableContinuationContext('point')).toBe('point')
+    expect(keyCyclableContinuationContext(null)).toBeNull()
+  })
+})

package/src/lib/continuation.ts

@@ -8,26 +8,37 @@ export const CONTINUATION_PROFILES: Record<
     default: ContinuationMode
     labels: Record<string, string>
     icons: Record<string, string>
+    /**
+     * Picked once from the Build panel before drawing (`wall-draw-variant.ts`),
+     * never cycled by C or a HUD chip mid-draw.
+     */
+    chosenInPanel?: boolean
   }
 > = {
+  // The wall tool's drawing mode: a chain that closes into a room ('room', the
+  // Build panel's Polygon), one wall per two clicks ('single', Walls), or a
+  // two-corner box of four walls ('rectangle', Rectangle).
   wall: {
-    options: ['room', 'single'],
+    options: ['room', 'single', 'rectangle'],
     default: 'room',
-    labels: { room: 'Room (auto-close)', single: 'Single wall' },
-    icons: { room: 'lucide:square', single: 'lucide:minus' },
+    labels: { room: 'Polygon room', single: 'Walls', rectangle: 'Rectangle room' },
+    icons: { room: 'lucide:pentagon', single: 'lucide:minus', rectangle: 'lucide:square' },
+    chosenInPanel: true,
   },
   fence: {
-    options: ['single', 'continuous', 'curved'],
+    options: ['single', 'continuous', 'curved', 'freehand'],
     default: 'continuous',
     labels: {
       continuous: 'Continuous',
       single: 'Single fence',
       curved: 'Curved fence',
+      freehand: 'Freehand fence',
     },
     icons: {
       continuous: 'lucide:waypoints',
       single: 'lucide:minus',
       curved: 'lucide:spline',
+      freehand: 'lucide:scribble',
     },
   },
   point: {
@@ -62,6 +73,16 @@ export function nextContinuation(
   return profile.options[(index + 1) % profile.options.length] ?? profile.default
 }
 
+/**
+ * The context C and the HUD chip may cycle — null when there is none, or when
+ * its mode is chosen in the Build panel instead.
+ */
+export function keyCyclableContinuationContext(
+  context: ContinuationContext | null,
+): ContinuationContext | null {
+  return context && !CONTINUATION_PROFILES[context].chosenInPanel ? context : null
+}
+
 export function continuationContextOf(kind: string): ContinuationContext | null {
   if (kind === 'wall') return 'wall'
   if (kind === 'fence') return 'fence'

package/src/lib/direct-manipulation.ts

@@ -107,6 +107,7 @@ export function resolveDirectManipulationNode(
 ): AnyNode {
   const target = nodes[resolveSelectionProxyId(node, nodes)] ?? node
   const parentFrame = nodeRegistry.get(target.type)?.capabilities?.movable?.parentFrame
+  if (parentFrame?.independent) return target
   const parent = parentFrame?.resolveParent(target, nodes as Readonly<Record<string, AnyNode>>)
   return parent && canDirectRotateNode(parent) ? parent : target
 }
@@ -116,6 +117,7 @@ export function resolveMoveActionNode(
   nodes: Readonly<Record<string, AnyNode | undefined>>,
 ): AnyNode {
   const parentFrame = nodeRegistry.get(node.type)?.capabilities?.movable?.parentFrame
+  if (parentFrame?.independent) return node
   const parent = parentFrame?.resolveParent(node, nodes as Readonly<Record<string, AnyNode>>)
   return parent && (parent.type === node.type || canDirectRotateNode(parent)) ? parent : node
 }

package/src/lib/door-interaction.ts

@@ -86,3 +86,17 @@ export function closeDoorOpenState(doorId: AnyNodeId, options?: DoorOpenAnimatio
   const currentSwingAngle = getDisplayedDoorValue(doorId, 'swingAngle', node.swingAngle)
   startDoorOpenAnimation(doorId, 'swingAngle', currentSwingAngle, 0, options)
 }
+
+export function openDoorOpenState(doorId: AnyNodeId, options?: DoorOpenAnimationOptions) {
+  const node = useScene.getState().nodes[doorId]
+  if (node?.type !== 'door' || node.openingKind === 'opening') return
+
+  if (isOperationDoorType(node.doorType)) {
+    const currentOpenAmount = getDisplayedDoorValue(doorId, 'operationState', node.operationState)
+    startDoorOpenAnimation(doorId, 'operationState', currentOpenAmount, 1, options)
+    return
+  }
+
+  const currentSwingAngle = getDisplayedDoorValue(doorId, 'swingAngle', node.swingAngle)
+  startDoorOpenAnimation(doorId, 'swingAngle', currentSwingAngle, DOOR_SWING_OPEN_ANGLE, options)
+}

package/src/lib/download-project-file.ts

@@ -0,0 +1,17 @@
+import { getProjectFileSink, type ProjectFileSink } from '@pascal-app/core'
+
+/** Persist before reporting a successful download; a failed save is shown by the export UI. */
+export async function downloadProjectFile(
+  blob: Blob,
+  name: string,
+  sink: ProjectFileSink | null = getProjectFileSink(),
+) {
+  await sink?.({ blob, name })
+  if (typeof document === 'undefined') return
+  const url = URL.createObjectURL(blob)
+  const anchor = document.createElement('a')
+  anchor.href = url
+  anchor.download = name
+  anchor.click()
+  setTimeout(() => URL.revokeObjectURL(url), 0)
+}

package/src/lib/editor-level-display.test.ts

@@ -0,0 +1,96 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import { BuildingNode, LevelNode, useScene } from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import useEditor, { type CaptureMode } from '../store/use-editor'
+import { showsWholeBuilding } from './editor-level-display'
+
+const building = BuildingNode.parse({ id: 'building_capture', children: [] })
+const levels = [0, 1, 2].map((level) =>
+  LevelNode.parse({ id: `level_capture_${level}`, level, parentId: building.id }),
+)
+const [ground, first, second] = levels.map((level) => level.id) as [
+  LevelNode['id'],
+  LevelNode['id'],
+  LevelNode['id'],
+]
+
+const wholeBuilding = () => {
+  const state = useEditor.getState()
+  return showsWholeBuilding({
+    isPreviewMode: state.isPreviewMode,
+    isFirstPersonMode: state.isFirstPersonMode,
+    captureMode: state.captureMode,
+    captureLevelId: state.captureLevelId,
+  })
+}
+const activeLevel = () => useViewer.getState().selection.levelId
+
+beforeEach(() => {
+  useScene.setState({
+    nodes: Object.fromEntries(
+      [{ ...building, children: levels.map((level) => level.id) }, ...levels].map((node) => [
+        node.id,
+        node,
+      ]),
+    ),
+    rootNodeIds: [building.id],
+  } as never)
+  useViewer.getState().setSelection({ buildingId: building.id, levelId: second })
+})
+afterEach(() => useEditor.getState().setCaptureMode(false))
+
+describe('capture level picker', () => {
+  test('editing hides the levels above; capture opens on the whole building', () => {
+    expect(wholeBuilding()).toBe(false)
+    useEditor.getState().setCaptureMode(true)
+    expect(useEditor.getState().captureLevelId).toBeNull()
+    expect(wholeBuilding()).toBe(true)
+    expect(activeLevel()).toBe(second)
+  })
+
+  test('picking a level shows it and the levels below, as while editing', () => {
+    useEditor.getState().setCaptureMode(true)
+    useEditor.getState().setCaptureLevel(first)
+    expect(wholeBuilding()).toBe(false)
+    expect(activeLevel()).toBe(first)
+    useEditor.getState().setCaptureLevel(null)
+    expect(wholeBuilding()).toBe(true)
+  })
+
+  test("leaving capture restores the editor's active level and the editing rule", () => {
+    useEditor.getState().setCaptureMode(true)
+    useEditor.getState().setCaptureLevel(ground)
+    useEditor.getState().setCaptureMode(false)
+    expect(activeLevel()).toBe(second)
+    expect(useEditor.getState().captureLevelId).toBeNull()
+    expect(wholeBuilding()).toBe(false)
+    // The next capture opens on the whole building again.
+    useEditor.getState().setCaptureMode({ mode: 'standard', crop: 'area' })
+    expect(wholeBuilding()).toBe(true)
+  })
+
+  test('a level picked outside capture is ignored', () => {
+    useEditor.getState().setCaptureLevel(ground)
+    expect(activeLevel()).toBe(second)
+    expect(useEditor.getState().captureLevelId).toBeNull()
+  })
+
+  test('preset captures and the walkthrough keep their own rules', () => {
+    const preset: CaptureMode = { mode: 'preset', isolated: [] }
+    const base = { isPreviewMode: false, isFirstPersonMode: false, captureLevelId: null }
+    expect(showsWholeBuilding({ ...base, captureMode: preset })).toBe(false)
+    expect(showsWholeBuilding({ ...base, captureMode: { mode: 'idle' } })).toBe(false)
+    expect(
+      showsWholeBuilding({ ...base, isFirstPersonMode: true, captureMode: { mode: 'idle' } }),
+    ).toBe(true)
+    // A walk capture on a picked level still shows only that level and below.
+    expect(
+      showsWholeBuilding({
+        ...base,
+        isFirstPersonMode: true,
+        captureMode: { mode: 'standard' },
+        captureLevelId: first,
+      }),
+    ).toBe(false)
+  })
+})

package/src/lib/editor-level-display.ts

@@ -0,0 +1,55 @@
+import { useViewer } from '@pascal-app/viewer'
+import { useEffect } from 'react'
+import useEditor, { type CaptureMode } from '../store/use-editor'
+import { useBelowGrade, useGroundWindowBox } from './below-grade'
+
+/**
+ * Whether the editor shows every level. Preview and the walkthrough show the
+ * whole building; a scene capture shows what its level picker says (the
+ * whole building, or a level and the ones below it). A preset capture frames
+ * its isolated item and keeps the editing rule.
+ */
+export function showsWholeBuilding(state: {
+  isPreviewMode: boolean
+  isFirstPersonMode: boolean
+  captureMode: CaptureMode
+  captureLevelId: string | null
+}): boolean {
+  if (state.captureMode.mode === 'standard') return state.captureLevelId === null
+  return state.isPreviewMode || state.isFirstPersonMode
+}
+
+/**
+ * The editor's one level display: stacked, with every level above the
+ * selected one hidden — the selected level and the ones below stay, so the
+ * storey being worked on is never covered. There is no Stack / Exploded /
+ * Solo choice while editing; a mode left over from the viewer (or persisted
+ * by an older build) is set back to stacked, and kept there.
+ *
+ * The walkthrough shows the whole building, so the upper levels come back
+ * while it is on; Preview hands the display to the viewer's own floor rule
+ * (`useViewerFloorDisplay`). A level below grade is marked as shown, and its
+ * ground veiled, except on the site, where the ground is what is being worked on.
+ */
+export function useEditorLevelDisplay(showWholeBuilding: boolean) {
+  const sitePhase = useEditor((state) => state.phase === 'site')
+  useBelowGrade(!(showWholeBuilding || sitePhase))
+  // The ground window (a hillside in the eye's way) follows the shown level, and the whole
+  // building while it stands whole — except on the site, where the ground is the work.
+  useGroundWindowBox(!sitePhase)
+  useEffect(() => {
+    if (showWholeBuilding) return
+    const keepStacked = (mode: string) => {
+      if (mode !== 'stacked') useViewer.getState().setLevelMode('stacked')
+    }
+    useViewer.setState({ hideLevelsAboveSelection: true })
+    keepStacked(useViewer.getState().levelMode)
+    const unsubscribe = useViewer.subscribe((state, previous) => {
+      if (state.levelMode !== previous.levelMode) keepStacked(state.levelMode)
+    })
+    return () => {
+      unsubscribe()
+      useViewer.setState({ hideLevelsAboveSelection: false })
+    }
+  }, [showWholeBuilding])
+}