@pascal-app/editor 1.0.3 → 1.0.5

package/src/lib/below-grade.test.tsx

@@ -0,0 +1,171 @@
+import { afterEach, beforeEach, expect, test } from 'bun:test'
+import {
+  type AnyNode,
+  type AnyNodeId,
+  BuildingNode,
+  type LevelNode,
+  LevelNode as LevelSchema,
+  SlabNode,
+  useScene,
+} from '@pascal-app/core'
+import { buildGroundLevelChanges } from '@pascal-app/core/building'
+import { useViewer } from '@pascal-app/viewer'
+import { act, create } from '@react-three/test-renderer'
+import useEditor from '../store/use-editor'
+import villaAurelia from './__fixtures__/owner-villa-aurelia-basement.json'
+import {
+  belowGradeShown,
+  followBelowGrade,
+  followGroundWindowBox,
+  gradeStandingShown,
+  groundWindowBoxShown,
+} from './below-grade'
+import { useEditorLevelDisplay } from './editor-level-display'
+
+// The owner's villa (13 Oct), trimmed: its Lower Ground lies 3.35 m under the lawn.
+const villa = villaAurelia.nodes as unknown as Record<AnyNodeId, AnyNode>
+const lowerGround = 'level_68jf2zqaukfjof3m' as LevelNode['id']
+const pianoNobile = 'level_ztimtvrgdzzd6c9f' as LevelNode['id']
+
+const shown = (levelId: LevelNode['id'], hideLevelsAboveSelection = true) => ({
+  hideLevelsAboveSelection,
+  selection: { levelId },
+})
+
+let previous: {
+  viewer: ReturnType<typeof useViewer.getState>
+  scene: ReturnType<typeof useScene.getState>
+  editor: ReturnType<typeof useEditor.getState>
+}
+beforeEach(() => {
+  previous = {
+    viewer: useViewer.getState(),
+    scene: useScene.getState(),
+    editor: useEditor.getState(),
+  }
+  useScene.setState({ nodes: villa } as never)
+})
+afterEach(() => {
+  useViewer.setState(previous.viewer, true)
+  useScene.setState(previous.scene, true)
+  useEditor.setState(previous.editor, true)
+})
+
+test('the ground window’s box is the shown level’s while its upper storeys are hidden and the building’s while it stands, follows the display, and closes when it stops', () => {
+  const levelBox = groundWindowBoxShown(shown(lowerGround), villa)
+  const buildingBox = groundWindowBoxShown(shown(lowerGround, false), villa)
+  expect(levelBox).not.toBeNull()
+  expect(buildingBox).not.toBeNull()
+  // The building wraps the level: no wider claim than that is this test's to make.
+  expect(buildingBox?.min[1]).toBeLessThanOrEqual(levelBox?.min[1] ?? 0)
+  expect(buildingBox?.max[1]).toBeGreaterThan(levelBox?.max[1] ?? 0)
+
+  useViewer.setState({ hideLevelsAboveSelection: true })
+  useViewer.getState().setSelection({ levelId: lowerGround })
+  const stop = followGroundWindowBox()
+  expect(useViewer.getState().groundWindowBox).not.toBeNull()
+  stop()
+  expect(useViewer.getState().groundWindowBox).toBeNull()
+})
+
+test('the flag follows the level shown (below grade with the storeys above it hidden; never a level at grade, never while the whole building stands), and clears when it stops', () => {
+  useViewer.setState({ hideLevelsAboveSelection: true })
+  useViewer.getState().setSelection({ levelId: pianoNobile })
+  const stop = followBelowGrade()
+  expect(useViewer.getState().belowGrade).toBe(false)
+  expect(belowGradeShown(shown(pianoNobile), villa)).toBe(false)
+
+  useViewer.getState().setSelection({ levelId: lowerGround })
+  expect(useViewer.getState().belowGrade).toBe(true)
+  expect(useViewer.getState().gradeStanding).toBe('below-grade')
+  expect(gradeStandingShown(shown(lowerGround), villa)).toBe('below-grade')
+  useViewer.setState({ hideLevelsAboveSelection: false })
+  expect(useViewer.getState().belowGrade).toBe(false)
+  expect(belowGradeShown(shown(lowerGround, false), villa)).toBe(false)
+  useViewer.setState({ hideLevelsAboveSelection: true })
+  expect(useViewer.getState().belowGrade).toBe(true)
+
+  stop()
+  expect(useViewer.getState().belowGrade).toBe(false)
+  expect(useViewer.getState().gradeStanding).toBe('at-grade')
+})
+
+test("the editor's level display marks it, except on the site, where the ground is the work", async () => {
+  useViewer.getState().setSelection({ levelId: lowerGround })
+  useEditor.setState({ phase: 'site' })
+  function LevelDisplay() {
+    useEditorLevelDisplay(false)
+    return null
+  }
+  const renderer = await create(<LevelDisplay />)
+  try {
+    expect(useViewer.getState().hideLevelsAboveSelection).toBe(true)
+    expect(useViewer.getState().belowGrade).toBe(false)
+    expect(useViewer.getState().groundWindowBox).toBeNull()
+
+    await act(async () => useEditor.setState({ phase: 'building' }))
+    expect(useViewer.getState().belowGrade).toBe(true)
+    expect(useViewer.getState().groundWindowBox).not.toBeNull()
+  } finally {
+    await renderer.unmount()
+  }
+  expect(useViewer.getState().belowGrade).toBe(false)
+  expect(useViewer.getState().groundWindowBox).toBeNull()
+})
+
+// The owner's mansion (15 Oct): two basements, the stack standing Lower Ground at grade.
+test('with the ground line set on a mansion, the flag follows the level shown: -1, then -2, then the ground floor', () => {
+  const plate = (id: string, size: number) =>
+    SlabNode.parse({
+      id: `slab_${id}`,
+      parentId: id,
+      elevation: 0.2,
+      polygon: [
+        [0, 0],
+        [size, 0],
+        [size, size],
+        [0, size],
+      ],
+    })
+  const level = (id: string, index: number, baseElevation: number, height: number) =>
+    LevelSchema.parse({
+      id,
+      parentId: 'building_mansion',
+      level: index,
+      baseElevation,
+      height,
+      children: [`slab_${id}`],
+    })
+  const levels = [
+    level('level_basement_2', -2, -3.4, 3.4),
+    level('level_lower_ground', -1, 0, 3.4),
+    level('level_reception', 0, 0, 4),
+  ]
+  const mansion = Object.fromEntries(
+    [
+      BuildingNode.parse({ id: 'building_mansion', children: levels.map((entry) => entry.id) }),
+      ...levels,
+      plate('level_basement_2', 14),
+      plate('level_lower_ground', 8),
+      plate('level_reception', 10),
+    ].map((node) => [node.id, node as AnyNode]),
+  ) as Record<AnyNodeId, AnyNode>
+  const lower = 'level_lower_ground' as LevelNode['id']
+  const deep = 'level_basement_2' as LevelNode['id']
+  const reception = 'level_reception' as LevelNode['id']
+  // "Set as ground floor" on the reception seats the stack: both basements are below grade.
+  const built = buildGroundLevelChanges({ nodes: mansion, levelId: reception })
+  const seated: Record<string, AnyNode> = { ...mansion }
+  for (const { id, data } of built?.update ?? []) seated[id] = { ...seated[id], ...data } as AnyNode
+  useScene.setState({ nodes: seated as Record<AnyNodeId, AnyNode> } as never)
+  useViewer.setState({ hideLevelsAboveSelection: true })
+  const stop = followBelowGrade()
+  const flag = () => useViewer.getState().gradeStanding
+  useViewer.getState().setSelection({ levelId: lower })
+  expect(flag()).toBe('below-grade')
+  useViewer.getState().setSelection({ levelId: deep })
+  expect(flag()).toBe('below-grade')
+  useViewer.getState().setSelection({ levelId: reception })
+  expect(flag()).toBe('at-grade')
+  stop()
+})

package/src/lib/below-grade.ts

@@ -0,0 +1,133 @@
+import {
+  type AnyNode,
+  type AnyNodeId,
+  buildingGroundBox,
+  type GroundBox,
+  type LevelGradeStanding,
+  levelGradeStanding,
+  levelGroundBox,
+  useScene,
+} from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import { useEffect } from 'react'
+
+type LevelDisplay = {
+  hideLevelsAboveSelection: boolean
+  selection: { levelId: string | null; buildingId?: string | null }
+}
+
+/**
+ * The shown level's standing against the ground: the storeys above the selected level are
+ * hidden and that level's floor lies under the ground — all of it, or the part of it a
+ * hillside stands over — which is then veiled over it.
+ */
+export function gradeStandingShown(
+  viewer: LevelDisplay,
+  nodes: Record<AnyNodeId, AnyNode>,
+): LevelGradeStanding {
+  const { levelId } = viewer.selection
+  if (!viewer.hideLevelsAboveSelection || levelId === null) return 'at-grade'
+  return levelGradeStanding(nodes, levelId)
+}
+
+/** Whether the level shown lies below grade, on all of its footprint or part of it. */
+export function belowGradeShown(viewer: LevelDisplay, nodes: Record<AnyNodeId, AnyNode>): boolean {
+  return gradeStandingShown(viewer, nodes) !== 'at-grade'
+}
+
+/**
+ * Keeps the viewer's `belowGrade` and `gradeStanding` on the shown level while the
+ * selection, the level display and the scene change. The returned function stops, and the
+ * ground stands solid again.
+ */
+export function followBelowGrade(): () => void {
+  const update = () => {
+    const gradeStanding = gradeStandingShown(useViewer.getState(), useScene.getState().nodes)
+    const viewer = useViewer.getState()
+    if (
+      viewer.gradeStanding !== gradeStanding ||
+      viewer.belowGrade !== (gradeStanding !== 'at-grade')
+    )
+      useViewer.setState({ gradeStanding, belowGrade: gradeStanding !== 'at-grade' })
+  }
+  update()
+  // The flag itself is watched too: the other host's level display, handing over, resets it.
+  const stopViewer = useViewer.subscribe((state, previous) => {
+    if (
+      state.selection.levelId !== previous.selection.levelId ||
+      state.hideLevelsAboveSelection !== previous.hideLevelsAboveSelection ||
+      state.belowGrade !== previous.belowGrade ||
+      state.gradeStanding !== previous.gradeStanding
+    )
+      update()
+  })
+  const stopScene = useScene.subscribe((state, previous) => {
+    if (state.nodes !== previous.nodes) update()
+  })
+  return () => {
+    stopViewer()
+    stopScene()
+    useViewer.setState({ belowGrade: false, gradeStanding: 'at-grade' })
+  }
+}
+
+/** A host's level display marks a level below grade as shown while `active`. */
+export function useBelowGrade(active: boolean) {
+  useEffect(() => (active ? followBelowGrade() : undefined), [active])
+}
+
+/**
+ * The box the ground window opens for: the shown level while the editor's level display
+ * hides what is above it, the whole building when it stands whole (Preview).
+ */
+export function groundWindowBoxShown(
+  viewer: LevelDisplay,
+  nodes: Record<AnyNodeId, AnyNode>,
+): GroundBox | null {
+  const { levelId, buildingId } = viewer.selection
+  if (viewer.hideLevelsAboveSelection && levelId !== null) return levelGroundBox(nodes, levelId)
+  return buildingGroundBox(nodes, buildingId ?? null)
+}
+
+function sameBox(a: GroundBox | null, b: GroundBox | null): boolean {
+  if (a === null || b === null) return a === b
+  return (
+    a.min.every((value, axis) => value === b.min[axis]) &&
+    a.max.every((value, axis) => value === b.max[axis])
+  )
+}
+
+/**
+ * Keeps the viewer's `groundWindowBox` on {@link groundWindowBoxShown} while the selection,
+ * the level display and the scene change. The returned function stops, and the window closes.
+ */
+export function followGroundWindowBox(): () => void {
+  const update = () => {
+    const box = groundWindowBoxShown(useViewer.getState(), useScene.getState().nodes)
+    if (!sameBox(useViewer.getState().groundWindowBox, box))
+      useViewer.setState({ groundWindowBox: box })
+  }
+  update()
+  const stopViewer = useViewer.subscribe((state, previous) => {
+    if (
+      state.selection.levelId !== previous.selection.levelId ||
+      state.selection.buildingId !== previous.selection.buildingId ||
+      state.hideLevelsAboveSelection !== previous.hideLevelsAboveSelection ||
+      state.groundWindowBox !== previous.groundWindowBox
+    )
+      update()
+  })
+  const stopScene = useScene.subscribe((state, previous) => {
+    if (state.nodes !== previous.nodes) update()
+  })
+  return () => {
+    stopViewer()
+    stopScene()
+    useViewer.setState({ groundWindowBox: null })
+  }
+}
+
+/** The ground window follows the shown level or building while `active` (not on the site). */
+export function useGroundWindowBox(active: boolean) {
+  useEffect(() => (active ? followGroundWindowBox() : undefined), [active])
+}

package/src/lib/camera-facing.test.ts

@@ -0,0 +1,24 @@
+import { afterEach, expect, test } from 'bun:test'
+import { cameraPoseStore, publishCameraPose } from '../store/camera-pose-store'
+import { cameraFacingYaw } from './camera-facing'
+
+afterEach(() => cameraPoseStore.setState({ pose: null }))
+
+function viewFrom(x: number, z: number) {
+  publishCameraPose({ position: [x, 8, z], target: [0, 0, 0], projection: 'perspective' })
+}
+
+test('a new item turns its front toward the camera, in quarter turns', () => {
+  viewFrom(0, 10)
+  expect(cameraFacingYaw()).toBe(0)
+  viewFrom(10, 2)
+  expect(cameraFacingYaw()).toBeCloseTo(Math.PI / 2)
+  viewFrom(-1, -10)
+  expect(cameraFacingYaw()).toBeCloseTo(Math.PI)
+  viewFrom(-10, -3)
+  expect(cameraFacingYaw()).toBeCloseTo((3 * Math.PI) / 2)
+})
+
+test('before any view is published the item keeps its authored front', () => {
+  expect(cameraFacingYaw()).toBe(0)
+})

package/src/lib/camera-facing.ts

@@ -0,0 +1,24 @@
+import { cameraPoseStore } from '../store/camera-pose-store'
+import useEditor from '../store/use-editor'
+import { getActiveBuildingPose } from './world-grid-snap'
+
+const QUARTER_TURN = Math.PI / 2
+
+/**
+ * The yaw, local to the active building and snapped to 90°, that turns a node's
+ * front (local +Z) toward the camera — the view a placement starts from. Falls
+ * back to the synced plan azimuth when the camera looks straight down, and to 0
+ * before any view has been published.
+ */
+export function cameraFacingYaw(): number {
+  const pose = cameraPoseStore.getState().pose
+  let azimuth = useEditor.getState().navigationSyncPose?.azimuth ?? 0
+  if (pose) {
+    const dx = pose.position[0] - pose.target[0]
+    const dz = pose.position[2] - pose.target[2]
+    if (Math.hypot(dx, dz) > 1e-6) azimuth = Math.atan2(dx, dz)
+  }
+  const local = azimuth - (getActiveBuildingPose()?.rotationY ?? 0)
+  const quarter = (((Math.round(local / QUARTER_TURN) % 4) + 4) % 4) as 0 | 1 | 2 | 3
+  return quarter * QUARTER_TURN
+}

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

@@ -0,0 +1,321 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import {
+  type AnyNode,
+  type AnyNodeId,
+  BuildingNode,
+  CeilingNode,
+  emitter,
+  LevelNode,
+  SiteNode,
+  useScene,
+  ZoneNode,
+} from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import { create } from '@react-three/test-renderer'
+import { createElement } from 'react'
+import { cancelActiveTool } from '../hooks/use-keyboard'
+import useEditor from '../store/use-editor'
+import useInteractionScope from '../store/use-interaction-scope'
+import {
+  endCeilingEdit,
+  getCeilingEditSession,
+  setCeilingHoles,
+  startCeilingEdit,
+  startCeilingEditFromTreeSelection,
+  useCeilingEditSessionOwner,
+} from './ceiling-edit-session'
+import { boundaryReshapeScope, holeEditScope } from './interaction/scope'
+
+const square: [number, number][] = [
+  [0, 0],
+  [4, 0],
+  [4, 4],
+  [0, 4],
+]
+const site = SiteNode.parse({ id: 'site_ceiling_edit', children: ['building_ceiling_edit'] })
+const building = BuildingNode.parse({
+  id: 'building_ceiling_edit',
+  parentId: site.id,
+  children: ['level_ceiling_edit_0', 'level_ceiling_edit_1'],
+})
+const level = LevelNode.parse({ id: 'level_ceiling_edit_0', parentId: building.id, level: 0 })
+const upper = LevelNode.parse({ id: 'level_ceiling_edit_1', parentId: building.id, level: 1 })
+const zone = ZoneNode.parse({
+  id: 'zone_ceiling_edit',
+  parentId: level.id,
+  name: 'Kitchen',
+  polygon: square,
+  spaceRole: 'room',
+})
+const ceiling = CeilingNode.parse({
+  id: 'ceiling_linked',
+  parentId: level.id,
+  polygon: square,
+  boundary: 'auto',
+  zoneId: zone.id,
+})
+const manual = CeilingNode.parse({
+  id: 'ceiling_manual',
+  parentId: level.id,
+  polygon: square.map(([x, z]) => [x + 10, z] as [number, number]),
+})
+const roomHole: [number, number][] = [
+  [1, 1],
+  [2, 1],
+  [2, 2],
+  [1, 2],
+]
+const cutHole: [number, number][] = [
+  [2.5, 2.5],
+  [3, 2.5],
+  [3, 3],
+  [2.5, 3],
+]
+const holed = CeilingNode.parse({
+  id: 'ceiling_holed',
+  parentId: upper.id,
+  polygon: square,
+  boundary: 'auto',
+  zoneId: 'zone_ceiling_edit_upper',
+  holes: [roomHole],
+  holeMetadata: [{ source: 'room' }],
+})
+
+const snapshots = {
+  scene: useScene.getState(),
+  viewer: useViewer.getState(),
+  editor: useEditor.getState(),
+  scope: useInteractionScope.getState(),
+  raf: globalThis.requestAnimationFrame,
+  cancelRaf: globalThis.cancelAnimationFrame,
+}
+
+beforeEach(() => {
+  // Scene updates schedule a dirty-flush frame.
+  globalThis.requestAnimationFrame = () => 0
+  globalThis.cancelAnimationFrame = () => {}
+  const nodes = Object.fromEntries(
+    [site, building, level, upper, zone, ceiling, manual, holed].map((node) => [node.id, node]),
+  ) as Record<AnyNodeId, AnyNode>
+  useScene.setState({ nodes, rootNodeIds: [site.id] })
+  useViewer.setState({
+    hoveredId: null,
+    selection: { buildingId: building.id, levelId: level.id, zoneId: null, selectedIds: [] },
+  })
+  useEditor.setState({ phase: 'building', mode: 'select', room: null, hoveredRoom: null })
+  useInteractionScope.setState({ scope: { kind: 'idle' } })
+})
+
+afterEach(() => {
+  endCeilingEdit()
+  useScene.setState(snapshots.scene)
+  useViewer.setState(snapshots.viewer)
+  useEditor.setState(snapshots.editor)
+  useInteractionScope.setState(snapshots.scope)
+  globalThis.requestAnimationFrame = snapshots.raf
+  globalThis.cancelAnimationFrame = snapshots.cancelRaf
+})
+
+const selectedIds = () => useViewer.getState().selection.selectedIds
+
+describe('starting a session', () => {
+  test('the pill API opens the room ceiling from its zone id and selects it', () => {
+    expect(startCeilingEdit(zone.id)).toBe(true)
+    expect(getCeilingEditSession()).toEqual({
+      ceilingId: ceiling.id,
+      zoneId: zone.id,
+      levelId: level.id,
+    })
+    expect(selectedIds()).toEqual([ceiling.id])
+  })
+
+  test('a ceiling id opens that ceiling; an unknown target or a room without one does nothing', () => {
+    expect(startCeilingEdit(manual.id)).toBe(true)
+    expect(getCeilingEditSession()).toEqual({
+      ceilingId: manual.id,
+      zoneId: null,
+      levelId: level.id,
+    })
+    expect(startCeilingEdit('ceiling_missing')).toBe(false)
+    useScene.getState().deleteNode(ceiling.id as AnyNodeId)
+    endCeilingEdit()
+    expect(startCeilingEdit(zone.id)).toBe(false)
+    expect(getCeilingEditSession()).toBeNull()
+  })
+
+  test('the pill switches to the ceiling level and goes inside the building', () => {
+    useViewer.setState({
+      selection: { buildingId: building.id, levelId: upper.id, zoneId: null, selectedIds: [] },
+    })
+    useEditor.setState({ phase: 'site' })
+    expect(startCeilingEdit(zone.id)).toBe(true)
+    expect(useEditor.getState().phase).toBe('building')
+    expect(useViewer.getState().selection.levelId).toBe(level.id)
+    expect(getCeilingEditSession()?.ceilingId).toBe(ceiling.id)
+  })
+
+  test('a scene-graph selection of exactly the ceiling opens it; a multi-selection does not', () => {
+    useViewer.getState().setSelection({ selectedIds: [ceiling.id, manual.id] })
+    expect(startCeilingEditFromTreeSelection(ceiling.id)).toBe(false)
+    expect(getCeilingEditSession()).toBeNull()
+    useViewer.getState().setSelection({ selectedIds: [ceiling.id] })
+    expect(startCeilingEditFromTreeSelection(ceiling.id)).toBe(true)
+    expect(getCeilingEditSession()?.ceilingId).toBe(ceiling.id)
+  })
+
+  test('a canvas selection (drill-down or Alt-click) selects the ceiling without a session', () => {
+    useViewer.getState().setSelection({ selectedIds: [ceiling.id] })
+    expect(getCeilingEditSession()).toBeNull()
+  })
+})
+
+describe('ending a session', () => {
+  test('Escape returns to the ceiling room', () => {
+    startCeilingEdit(ceiling.id)
+    expect(cancelActiveTool()).toBe(true)
+    expect(getCeilingEditSession()).toBeNull()
+    expect(useEditor.getState().room).toEqual({ levelId: level.id, zoneId: zone.id })
+    expect(selectedIds()).toEqual([])
+    expect(useEditor.getState().mode).toBe('select')
+  })
+
+  test('Escape returns to the room even after a polygon edit detached the link', () => {
+    startCeilingEdit(ceiling.id)
+    useScene.getState().detachDerivedNode(ceiling.id as AnyNodeId, {
+      polygon: square.map(([x, z]) => [x, z + 0.5] as [number, number]),
+    })
+    const detached = useScene.getState().nodes[ceiling.id as AnyNodeId] as CeilingNode
+    expect(detached.boundary).toBeUndefined()
+    expect(detached.zoneId).toBeUndefined()
+    expect(getCeilingEditSession()?.ceilingId).toBe(ceiling.id)
+    cancelActiveTool()
+    expect(useEditor.getState().room).toEqual({ levelId: level.id, zoneId: zone.id })
+  })
+
+  test('Escape on a ceiling with no room clears the selection', () => {
+    startCeilingEdit(manual.id)
+    expect(cancelActiveTool()).toBe(true)
+    expect(getCeilingEditSession()).toBeNull()
+    expect(useEditor.getState().room).toBeNull()
+    expect(selectedIds()).toEqual([])
+  })
+
+  test('Escape during an in-flight reshape is left to the reshape', () => {
+    startCeilingEdit(ceiling.id)
+    useInteractionScope.getState().begin(boundaryReshapeScope(ceiling.id))
+    emitter.emit('tool:cancel')
+    expect(getCeilingEditSession()?.ceilingId).toBe(ceiling.id)
+  })
+
+  test('deselection, another selection, a level change, a phase change and deletion end it', () => {
+    const ends: Array<() => void> = [
+      () => useViewer.getState().setSelection({ selectedIds: [] }),
+      () => useViewer.getState().setSelection({ selectedIds: [manual.id] }),
+      () => useViewer.getState().setSelection({ selectedIds: [ceiling.id, manual.id] }),
+      () => useViewer.getState().setSelection({ levelId: upper.id }),
+      () => useEditor.getState().setPhase('site'),
+      () => useScene.getState().deleteNode(ceiling.id as AnyNodeId),
+    ]
+    for (const end of ends) {
+      useEditor.setState({ phase: 'building' })
+      useViewer.setState({
+        selection: { buildingId: building.id, levelId: level.id, zoneId: null, selectedIds: [] },
+      })
+      if (!useScene.getState().nodes[ceiling.id as AnyNodeId])
+        useScene.setState({ nodes: { ...useScene.getState().nodes, [ceiling.id]: ceiling } })
+      expect(startCeilingEdit(ceiling.id)).toBe(true)
+      end()
+      expect(getCeilingEditSession()).toBeNull()
+    }
+  })
+
+  test('height and material edits keep the session and the auto boundary', () => {
+    startCeilingEdit(ceiling.id)
+    useScene.getState().updateNode(ceiling.id as AnyNodeId, { height: 2.4, materialPreset: 'x' })
+    const edited = useScene.getState().nodes[ceiling.id as AnyNodeId] as CeilingNode
+    expect(edited.boundary).toBe('auto')
+    expect(edited.zoneId).toBe(zone.id)
+    expect(getCeilingEditSession()?.ceilingId).toBe(ceiling.id)
+  })
+
+  test('an ended session stops listening', () => {
+    startCeilingEdit(ceiling.id)
+    endCeilingEdit()
+    useViewer.getState().setSelection({ selectedIds: [ceiling.id] })
+    expect(cancelActiveTool()).toBe(false)
+    expect(useEditor.getState().room).toBeNull()
+  })
+})
+
+describe('session ownership', () => {
+  test('unmounting the editor that owns the session ends it', async () => {
+    const renderer = await create(
+      createElement(function Owner() {
+        useCeilingEditSessionOwner()
+        return null
+      }),
+    )
+    startCeilingEdit(ceiling.id)
+    expect(getCeilingEditSession()?.ceilingId).toBe(ceiling.id)
+    await renderer.unmount()
+    expect(getCeilingEditSession()).toBeNull()
+    useViewer.getState().setSelection({ selectedIds: [ceiling.id] })
+    expect(cancelActiveTool()).toBe(false)
+  })
+
+  test("ending the session ends its hole edit, not another node's", () => {
+    startCeilingEdit(ceiling.id)
+    useInteractionScope.getState().begin(holeEditScope({ nodeId: ceiling.id, holeIndex: 0 }))
+    endCeilingEdit()
+    expect(useInteractionScope.getState().scope.kind).toBe('idle')
+
+    startCeilingEdit(ceiling.id)
+    useInteractionScope.getState().begin(holeEditScope({ nodeId: 'slab_other', holeIndex: 0 }))
+    endCeilingEdit()
+    expect(useInteractionScope.getState().scope).toMatchObject({
+      reshape: 'hole',
+      nodeId: 'slab_other',
+    })
+  })
+})
+
+describe('hole edits', () => {
+  const node = (id: string) => useScene.getState().nodes[id as AnyNodeId] as CeilingNode
+
+  test('a manual hole on an auto ceiling keeps the room link (only polygon edits detach)', () => {
+    startCeilingEdit(ceiling.id)
+    const before = node(ceiling.id)
+    expect(
+      setCeilingHoles(ceiling.id, { holes: [cutHole], holeMetadata: [{ source: 'manual' }] }),
+    ).toBe(true)
+    expect(node(ceiling.id).holes).toEqual([cutHole])
+    expect(node(ceiling.id).boundary).toBe(before.boundary)
+    expect(node(ceiling.id).zoneId).toBe(before.zoneId)
+    expect(getCeilingEditSession()?.ceilingId).toBe(ceiling.id)
+    // Deleting it again is a plain update too.
+    expect(setCeilingHoles(ceiling.id, { holes: [], holeMetadata: [] })).toBe(true)
+    expect(node(ceiling.id).zoneId).toBe(before.zoneId)
+  })
+
+  test('room-cut holes stay protected: a write that changes one is refused', () => {
+    const moved = roomHole.map(([x, z]) => [x + 0.5, z] as [number, number])
+    expect(setCeilingHoles(holed.id, { holes: [moved] })).toBe(false)
+    expect(setCeilingHoles(holed.id, { holes: [], holeMetadata: [] })).toBe(false)
+    expect(node(holed.id)).toEqual(holed)
+
+    expect(
+      setCeilingHoles(holed.id, {
+        holes: [roomHole, cutHole],
+        holeMetadata: [{ source: 'room' }, { source: 'manual' }],
+      }),
+    ).toBe(true)
+    expect(node(holed.id).holes).toEqual([roomHole, cutHole])
+    expect(node(holed.id).boundary).toBe(holed.boundary)
+  })
+
+  test('a manual ceiling takes a plain update; a non-ceiling is refused', () => {
+    expect(setCeilingHoles(manual.id, { holes: [cutHole] })).toBe(true)
+    expect(node(manual.id).holes).toEqual([cutHole])
+    expect(setCeilingHoles(zone.id, { holes: [cutHole] })).toBe(false)
+  })
+})