@pascal-app/editor 1.0.3 → 1.0.4

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/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/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,48 @@
+import { useViewer } from '@pascal-app/viewer'
+import { useEffect } from 'react'
+import type { CaptureMode } from '../store/use-editor'
+
+/**
+ * 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`).
+ */
+export function useEditorLevelDisplay(showWholeBuilding: boolean) {
+  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])
+}

package/src/lib/editor-views.ts

@@ -0,0 +1,144 @@
+import type { IconRef, LazyComponent } from '@pascal-app/core'
+import useEditor from '../store/use-editor'
+import { VIEW_2D, VIEW_3D } from '../store/view-layout'
+
+/**
+ * A view fills a pane of the stage, beside or instead of the 3D scene and the
+ * 2D plan. Hosts and plugins register views the way they register rail panels;
+ * a plugin registers as many as it needs, each tagged with its `pluginId`.
+ */
+export type EditorHostView = {
+  id: string
+  label: string
+  icon: IconRef
+  component: LazyComponent
+  /** The view exists in a project only while this plugin is installed there. */
+  pluginId?: string
+  /** Workspaces the view is offered in. Default `['edit']`, like panels. */
+  workspaces?: readonly string[]
+  description?: string
+  /** Shown in the view bar until the user unpins it. Default false: the "More views" menu only. */
+  defaultPinned?: boolean
+}
+
+/** A view as the stage needs it. The scene views have no component: the stage owns their canvases. */
+export type EditorViewDescriptor = Omit<EditorHostView, 'component'> & {
+  component?: LazyComponent
+  /** 3D and 2D: the views the level selector, tool dock and scene overlays belong to. */
+  scene?: boolean
+}
+
+export const SCENE_VIEWS: readonly EditorViewDescriptor[] = [
+  {
+    id: VIEW_3D,
+    label: '3D',
+    icon: { kind: 'url', src: '/icons/building.webp' },
+    scene: true,
+    defaultPinned: true,
+  },
+  {
+    id: VIEW_2D,
+    label: '2D',
+    icon: { kind: 'url', src: '/icons/blueprint.webp' },
+    scene: true,
+    defaultPinned: true,
+  },
+]
+
+export function isSceneView(viewId: string): boolean {
+  return viewId === VIEW_3D || viewId === VIEW_2D
+}
+
+function isDevMode(): boolean {
+  if (typeof process !== 'undefined' && process.env?.NODE_ENV) {
+    return process.env.NODE_ENV !== 'production'
+  }
+  return false
+}
+
+class EditorHostViewRegistryImpl {
+  private readonly views = new Map<string, EditorHostView>()
+  private readonly listeners = new Set<() => void>()
+  private cached: EditorHostView[] = []
+
+  subscribe = (onChange: () => void): (() => void) => {
+    this.listeners.add(onChange)
+    return () => {
+      this.listeners.delete(onChange)
+    }
+  }
+
+  getSnapshot = (): EditorHostView[] => this.cached
+
+  reset(): void {
+    this.views.clear()
+    this.emit()
+  }
+
+  registerView(view: EditorHostView): void {
+    if (typeof view.id !== 'string' || view.id.length === 0) {
+      throw new Error('[editor:host-views] view id must be a non-empty string')
+    }
+    if (isSceneView(view.id)) {
+      throw new Error(`[editor:host-views] "${view.id}" is a built-in view`)
+    }
+    if (this.views.has(view.id)) {
+      if (isDevMode()) {
+        console.warn(`[editor:host-views] re-registering view "${view.id}" (HMR)`)
+      } else {
+        throw new Error(`[editor:host-views] duplicate view id: "${view.id}" already registered`)
+      }
+    }
+    this.views.set(view.id, view)
+    this.emit()
+  }
+
+  private emit(): void {
+    this.cached = Array.from(this.views.values())
+    for (const listener of this.listeners) listener()
+  }
+}
+
+export const editorHostViewRegistry = new EditorHostViewRegistryImpl()
+
+export function registerEditorHostView(view: EditorHostView): void {
+  editorHostViewRegistry.registerView(view)
+}
+
+/**
+ * Show a view: focus it if it is on screen, else put it in the focused pane —
+ * or, with `beside`, split and open it next to what is there.
+ */
+export function openEditorView(viewId: string, options?: { beside?: boolean }): void {
+  useEditor.getState().showView(viewId, options)
+}
+
+/**
+ * The views a project can show in a workspace: the scene views, then every
+ * registered view offered there whose plugin (if any) is installed.
+ */
+export function availableViews({
+  registered,
+  workspaceMode,
+  installedPlugins,
+}: {
+  registered: readonly EditorViewDescriptor[]
+  workspaceMode: string
+  installedPlugins: readonly string[]
+}): EditorViewDescriptor[] {
+  return [
+    ...SCENE_VIEWS,
+    ...registered.filter(
+      (view) =>
+        (view.workspaces ?? ['edit']).includes(workspaceMode) &&
+        (!view.pluginId || installedPlugins.includes(view.pluginId)),
+    ),
+  ]
+}
+
+export function isViewPinned(
+  view: EditorViewDescriptor,
+  pinnedViews: Readonly<Record<string, boolean>>,
+): boolean {
+  return pinnedViews[view.id] ?? view.defaultPinned ?? false
+}

package/src/lib/export-geometry-wait.test.ts

@@ -0,0 +1,90 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import {
+  type AnyNode,
+  type AnyNodeDefinition,
+  DoorNode,
+  nodeRegistry,
+  registerNode,
+  sceneRegistry,
+} from '@pascal-app/core'
+import * as THREE from 'three'
+import { nodesAwaitingExportGeometry, waitForExportGeometry } from './glb-export'
+
+const node = (id: string, type: string, fields: Record<string, unknown> = {}) =>
+  ({
+    object: 'node',
+    id,
+    type,
+    parentId: 'level_a',
+    visible: true,
+    metadata: {},
+    ...fields,
+  }) as unknown as AnyNode
+
+const definition = (kind: string, extra: Record<string, unknown> = {}) =>
+  ({
+    kind,
+    schemaVersion: 1,
+    schema: DoorNode,
+    category: 'utility',
+    defaults: () => ({}) as never,
+    capabilities: {},
+    bake: 'replace',
+    ...extra,
+  }) as AnyNodeDefinition
+
+let restoreRegistry: () => void
+
+beforeEach(() => {
+  restoreRegistry = nodeRegistry._snapshot()
+  registerNode(definition('test:plant'))
+  registerNode(definition('test:baked', { bakeGeometry: () => new THREE.Group() }))
+})
+
+afterEach(() => {
+  restoreRegistry()
+  sceneRegistry.clear()
+})
+
+// Live objects as the editor registers them: still empty, i.e. the export
+// geometry has not mounted.
+function mount(ids: string[]) {
+  for (const id of ids) sceneRegistry.nodes.set(id, new THREE.Group())
+}
+
+describe('waitForExportGeometry', () => {
+  const nodes: Record<string, AnyNode> = {
+    level_a: node('level_a', 'level', { parentId: null }),
+    plant_a: node('plant_a', 'test:plant'),
+    plant_hidden: node('plant_hidden', 'test:plant', { visible: false }),
+    baked_a: node('baked_a', 'test:baked'),
+  }
+
+  test('waits only for included collective kinds that mount their own geometry', () => {
+    mount(['plant_a', 'plant_hidden', 'baked_a'])
+    expect(nodesAwaitingExportGeometry(nodes)).toEqual(['plant_a'])
+    expect(nodesAwaitingExportGeometry(nodes, { onlyVisible: false })).toEqual([
+      'plant_a',
+      'plant_hidden',
+    ])
+    expect(nodesAwaitingExportGeometry(nodes, { excludedNodeTypes: ['test:plant'] })).toEqual([])
+    sceneRegistry.nodes.get('plant_a')!.add(new THREE.Mesh())
+    expect(nodesAwaitingExportGeometry(nodes)).toEqual([])
+  })
+
+  test('times out on its own timer when geometry never mounts and frames never run', async () => {
+    mount(['plant_a'])
+    const started = Date.now()
+    await waitForExportGeometry(nodes, {}, 300)
+    const elapsed = Date.now() - started
+    expect(elapsed).toBeGreaterThanOrEqual(280)
+    expect(elapsed).toBeLessThan(1500)
+  })
+
+  test('returns as soon as nothing is pending', async () => {
+    mount(['plant_a', 'baked_a'])
+    const started = Date.now()
+    await waitForExportGeometry(nodes, { excludedNodeTypes: ['test:plant'] }, 5_000)
+    expect(Date.now() - started).toBeLessThan(1_000)
+  })
+})

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

@@ -0,0 +1,153 @@
+import {
+  type AnyNode,
+  area,
+  emitter,
+  type FloorOpeningNode,
+  intersection,
+  openingsForSurface,
+  removeFloorOpening,
+  structureChangeBatch,
+  useScene,
+} from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import { create } from 'zustand'
+import { markToolCancelConsumed } from '../hooks/use-keyboard'
+import useEditor from '../store/use-editor'
+import { cancelOpeningDraft } from './floor-opening-draft'
+import { completeElementAction } from './room-zone-routing'
+
+// "Edit floor": the room's floor openings, outlined in 3D and on the plan,
+// each a click away, with "Cut opening" to draw another. Like "Edit ceiling"
+// it is a standing mode rather than an interaction scope, so the scene stays
+// clickable; it ends with Done or Escape (back to the room), when the room is
+// deselected, or when another room is picked.
+
+export type FloorEditSession = { zoneId: string; levelId: string }
+
+export const useFloorEditSession = create<{ session: FloorEditSession | null }>(() => ({
+  session: null,
+}))
+
+type Nodes = Readonly<Record<string, AnyNode>>
+
+/**
+ * The openings through one surface of a room: those whose cut reaches that
+ * surface on the room's level (a floor opening here, a ceiling opening from
+ * the storey below) and overlap the room's outline.
+ */
+export function roomSurfaceOpenings(
+  nodes: Nodes,
+  zoneId: string,
+  surface: 'floor' | 'ceiling',
+): FloorOpeningNode[] {
+  const zone = nodes[zoneId]
+  if (zone?.type !== 'zone' || !zone.parentId) return []
+  const outline = { outer: zone.polygon, holes: zone.holes ?? [] }
+  const mezzanine = zone.floor?.support === 'open'
+  return openingsForSurface(nodes, zone.parentId, surface).filter((opening) =>
+    mezzanine
+      ? opening.hostZoneId === zoneId
+      : !opening.hostZoneId && area(intersection(opening.polygon, outline)) > 1e-6,
+  )
+}
+
+let stop: (() => void) | null = null
+
+export function startFloorEdit(zoneId: string): boolean {
+  const zone =
+    useScene.getState().nodes[zoneId as keyof ReturnType<typeof useScene.getState>['nodes']]
+  if (zone?.type !== 'zone' || !zone.parentId) return false
+  endFloorEdit()
+  useFloorEditSession.setState({ session: { zoneId, levelId: zone.parentId } })
+  stop = watch(zoneId)
+  return true
+}
+
+export function endFloorEdit() {
+  stop?.()
+  stop = null
+  if (useFloorEditSession.getState().session) useFloorEditSession.setState({ session: null })
+}
+
+/** Done / Escape: ends the session on the room it edited. */
+export function finishFloorEdit() {
+  const session = useFloorEditSession.getState().session
+  if (!session) return false
+  endFloorEdit()
+  completeElementAction({ room: session, point: null })
+  return true
+}
+
+function watch(zoneId: string) {
+  const stopEditor = useEditor.subscribe((state) => {
+    if (state.room?.zoneId !== zoneId && !openingSelectedIn(zoneId)) endFloorEdit()
+  })
+  const stopScene = useScene.subscribe((state) => {
+    if (state.nodes[zoneId as keyof typeof state.nodes]?.type !== 'zone') endFloorEdit()
+  })
+  const onToolCancel = () => {
+    if (useViewer.getState().selection.selectedIds.length) return
+    if (finishFloorEdit()) markToolCancelConsumed()
+  }
+  emitter.on('tool:cancel', onToolCancel)
+  return () => {
+    stopEditor()
+    stopScene()
+    emitter.off('tool:cancel', onToolCancel)
+  }
+}
+
+function openingSelectedIn(zoneId: string) {
+  const nodes = useScene.getState().nodes as Nodes
+  const [id] = useViewer.getState().selection.selectedIds
+  return (
+    !!id &&
+    nodes[id]?.type === 'floor-opening' &&
+    roomSurfaceOpenings(nodes, zoneId, 'floor').some((opening) => opening.id === id)
+  )
+}
+
+/** The room an opening belongs to: the selected room, else the room it overlaps most. */
+export function openingRoom(nodes: Nodes, opening: FloorOpeningNode): string | null {
+  if (opening.hostZoneId) return opening.hostZoneId
+  const selected = useEditor.getState().room
+  if (selected && selected.levelId === opening.parentId) return selected.zoneId
+  let best: { id: string; overlap: number } | null = null
+  for (const node of Object.values(nodes)) {
+    if (node.type !== 'zone' || node.parentId !== opening.parentId || node.spaceRole !== 'room')
+      continue
+    const overlap = area(
+      intersection(opening.polygon, { outer: node.polygon, holes: node.holes ?? [] }),
+    )
+    if (overlap > (best?.overlap ?? 1e-6)) best = { id: node.id, overlap }
+  }
+  return best?.id ?? null
+}
+
+/** Deletes an opening (one undo step) and lands on its room. */
+export function deleteFloorOpening(openingId: string) {
+  const nodes = useScene.getState().nodes as Nodes
+  const opening = nodes[openingId]
+  if (opening?.type !== 'floor-opening' || useScene.getState().readOnly) return false
+  if (opening.source === 'stair' || opening.source === 'elevator') return false
+  const zoneId = openingRoom(nodes, opening)
+  cancelOpeningDraft()
+  const plan = removeFloorOpening(nodes, openingId)
+  useScene.getState().applyNodeChanges(structureChangeBatch(plan.changes))
+  useViewer.getState().setSelection({ selectedIds: [] })
+  if (zoneId && opening.parentId)
+    completeElementAction({ room: { levelId: opening.parentId, zoneId }, point: null })
+  return true
+}
+
+/** Done in the opening's panel: back to its room. */
+export function finishFloorOpening(openingId: string) {
+  const nodes = useScene.getState().nodes as Nodes
+  const opening = nodes[openingId]
+  if (opening?.type !== 'floor-opening') return false
+  const zoneId = openingRoom(nodes, opening)
+  useViewer.getState().setSelection({ selectedIds: [] })
+  if (zoneId && opening.parentId)
+    completeElementAction({ room: { levelId: opening.parentId, zoneId }, point: null })
+  return true
+}