@pascal-app/editor 0.7.0 → 0.9.1

package/src/components/editor/selection-manager.tsx

@@ -6,14 +6,22 @@ import {
   type ColumnNode,
   emitter,
   type FenceNode,
+  getEffectiveRoofSurfaceMaterial,
+  getEffectiveSegmentSurfaceMaterial,
   getMaterialPresetByRef,
+  getRoofSegmentSurfaceY,
+  getSelectableKinds,
   type ItemNode,
+  isRegistrySelectable,
   type NodeEvent,
+  nodeRegistry,
   type RoofEvent,
   type RoofNode,
   type RoofSegmentEvent,
+  type RoofSegmentNode,
   resolveLevelId,
   resolveMaterial,
+  type ShelfNode,
   type SlabNode,
   type StairEvent,
   type StairNode,
@@ -21,9 +29,6 @@ import {
   type StairSurfaceMaterialRole,
   sceneRegistry,
   useScene,
-  type WallEvent,
-  type WallNode,
-  type WallSurfaceSide,
 } from '@pascal-app/core'
 
 import {
@@ -33,29 +38,30 @@ import {
   getRoofMaterialArray,
   getStairBodyMaterials,
   getStairRailingMaterial,
-  getVisibleWallMaterials,
   useViewer,
 } from '@pascal-app/viewer'
 import { useCallback, useEffect, useRef } from 'react'
-import { type BufferGeometry, Color, type Material, type Mesh, type Object3D } from 'three'
+import { type BufferGeometry, Color, type Material, type Mesh, type Object3D, Vector3 } from 'three'
 import {
   type ActivePaintMaterial,
+  buildRoofSegmentSurfaceMaterialPatch,
   buildRoofSurfaceMaterialPatch,
   buildSingleSurfaceMaterialPatch,
   buildStairSurfaceMaterialPatch,
-  buildWallSurfaceMaterialPatch,
   hasActivePaintMaterial,
   resolveActivePaintMaterialFromSelection,
 } from '../../lib/material-paint'
-import { sfxEmitter } from '../../lib/sfx-bus'
+import { emitDeleteSFX } from '../../lib/sfx-bus'
 import useEditor, {
   type MaterialTargetRole,
   type Phase,
   type StructureLayer,
 } from './../../store/use-editor'
-import { boxSelectHandled } from '../tools/select/box-select-tool'
+import { boxSelectHandled } from '../tools/select/box-select-state'
 
 const isNodeInCurrentLevel = (node: AnyNode): boolean => {
+  // Elevators are building-scoped, so they stay selectable across level filters.
+  if (node.type === 'elevator') return true
   const currentLevelId = useViewer.getState().selection.levelId
   if (!currentLevelId) return true // No level selected, allow all
   const nodeLevelId = resolveLevelId(node, useScene.getState().nodes)
@@ -68,6 +74,7 @@ type SelectableNodeType =
   | 'item'
   | 'column'
   | 'building'
+  | 'elevator'
   | 'zone'
   | 'slab'
   | 'ceiling'
@@ -118,33 +125,6 @@ export const resolveBuildingId = (
   return null
 }
 
-function resolveWallMaterialTarget(event: WallEvent): WallSurfaceSide | null {
-  const materialIndex = getIntersectionMaterialIndex(getEventObject(event), event.faceIndex)
-  if (materialIndex === 1) return 'interior'
-  if (materialIndex === 2) return 'exterior'
-
-  const normalZ = event.normal?.[2]
-  const localZ = event.localPosition[2]
-  const thickness = event.node.thickness ?? 0.1
-
-  if (
-    normalZ === undefined ||
-    Math.abs(normalZ) < 0.65 ||
-    Math.abs(localZ) < Math.max(thickness * 0.2, 0.01)
-  ) {
-    return null
-  }
-
-  const hitFace = localZ >= 0 ? 'front' : 'back'
-  const semantic = hitFace === 'front' ? event.node.frontSide : event.node.backSide
-
-  if (semantic === 'interior' || semantic === 'exterior') {
-    return semantic
-  }
-
-  return hitFace === 'front' ? 'interior' : 'exterior'
-}
-
 function resolveStairMaterialTarget(
   event: StairEvent | StairSegmentEvent,
 ): StairSurfaceMaterialRole | null {
@@ -226,6 +206,59 @@ function getRegisteredMesh(nodeId: string): Mesh | null {
   return object && (object as Mesh).isMesh ? (object as Mesh) : null
 }
 
+const roofSelectionWorldPoint = new Vector3()
+
+function resolveRoofSegmentSelectionTarget(event: NodeEvent): RoofSegmentNode | null {
+  const roof = event.node
+  if (roof.type !== 'roof') return null
+
+  roofSelectionWorldPoint.set(...event.position)
+  const nodes = useScene.getState().nodes
+  let firstSegment: RoofSegmentNode | null = null
+  let bestSegment: { node: RoofSegmentNode; score: number } | null = null
+
+  for (const childId of roof.children ?? []) {
+    const segment = nodes[childId as AnyNodeId] as RoofSegmentNode | undefined
+    if (segment?.type !== 'roof-segment') continue
+
+    const object = getRegisteredNodeObject(segment.id)
+    if (!object) continue
+
+    if (!firstSegment) firstSegment = segment
+
+    object.updateWorldMatrix(true, false)
+    const local = object.worldToLocal(roofSelectionWorldPoint.clone())
+    const overhang = segment.overhang ?? 0
+    const halfWidth = segment.width / 2 + overhang
+    const halfDepth = segment.depth / 2 + overhang
+
+    if (Math.abs(local.x) > halfWidth || Math.abs(local.z) > halfDepth) {
+      continue
+    }
+
+    const score = Math.abs(local.y - getRoofSegmentSurfaceY(segment, local.x, local.z))
+    if (!bestSegment || score < bestSegment.score) {
+      bestSegment = { node: segment, score }
+    }
+  }
+
+  return bestSegment?.node ?? firstSegment
+}
+
+function isInActiveRoofContext(
+  segment: RoofSegmentNode,
+  selectedIds: readonly string[],
+  nodes: Record<string, AnyNode>,
+): boolean {
+  if (!segment.parentId) return false
+  if (selectedIds.includes(segment.id) || selectedIds.includes(segment.parentId)) return true
+
+  return selectedIds.some((selectedId) => {
+    const selectedNode = nodes[selectedId]
+    return selectedNode?.type === 'roof-segment' && selectedNode.parentId === segment.parentId
+  })
+}
+
 function previewMeshMaterial(mesh: Mesh, material: Material | Material[]): PaintPreviewCleanup {
   const previousMaterial = mesh.material
   mesh.material = material
@@ -243,50 +276,82 @@ function previewCursor(cursor: string): PaintPreviewCleanup {
 }
 
 function getSingleSurfacePreviewMaterial(material: ActivePaintMaterial): Material | null {
+  const shading = useViewer.getState().shading
+
   if (material.materialPreset) {
-    return createMaterialFromPresetRef(material.materialPreset)
+    return createMaterialFromPresetRef(material.materialPreset, shading)
   }
 
   if (material.material) {
-    return createMaterial(material.material)
+    return createMaterial(material.material, shading)
   }
 
   return null
 }
 
-function applyWallPaintPreview(
-  node: WallNode,
-  role: WallSurfaceSide,
+function applyRoofPaintPreview(
+  node: RoofNode,
+  role: 'top' | 'edge' | 'wall',
   material: ActivePaintMaterial,
 ): PaintPreviewCleanup | null {
-  const mesh = getRegisteredMesh(node.id)
+  const root = getRegisteredNodeObject(node.id)
+  const mesh = root?.getObjectByName('merged-roof') as Mesh | undefined
   if (!mesh) return null
 
   const previewNode = {
     ...node,
-    ...buildWallSurfaceMaterialPatch(node, role, material.material, material.materialPreset),
+    ...buildRoofSurfaceMaterialPatch(node, role, material.material, material.materialPreset),
   }
+  const previewMaterial = getRoofMaterialArray(
+    previewNode,
+    useViewer.getState().shading,
+    useViewer.getState().textures,
+    useViewer.getState().colorPreset,
+    useViewer.getState().sceneTheme,
+  )
+  if (!previewMaterial) return null
 
-  return previewMeshMaterial(mesh, getVisibleWallMaterials(previewNode))
+  return previewMeshMaterial(mesh, previewMaterial)
 }
 
-function applyRoofPaintPreview(
-  node: RoofNode,
+function applyRoofSegmentPaintPreview(
+  node: RoofSegmentNode,
+  parent: RoofNode | null,
   role: 'top' | 'edge' | 'wall',
   material: ActivePaintMaterial,
 ): PaintPreviewCleanup | null {
-  const root = getRegisteredNodeObject(node.id)
-  const mesh = root?.getObjectByName('merged-roof') as Mesh | undefined
+  const mesh = getRegisteredMesh(node.id)
   if (!mesh) return null
 
-  const previewNode = {
+  // Synthesise the segment node as if the paint had committed, then build
+  // the same 4-slot array the renderer would. Mirrors getRoofMaterialArray
+  // layout (slot 0 ← edge, 1 ← wall, 2 ← wall, 3 ← top) so the preview
+  // material lands on the matching CSG groups.
+  const previewNode: RoofSegmentNode = {
     ...node,
-    ...buildRoofSurfaceMaterialPatch(node, role, material.material, material.materialPreset),
+    ...buildRoofSegmentSurfaceMaterialPatch(node, role, material.material, material.materialPreset),
   }
-  const previewMaterial = getRoofMaterialArray(previewNode)
-  if (!previewMaterial) return null
-
-  return previewMeshMaterial(mesh, previewMaterial)
+  const resolveSlot = (r: 'top' | 'edge' | 'wall'): Material | null => {
+    const parentSpec = parent ? getEffectiveRoofSurfaceMaterial(parent, r) : undefined
+    const spec = getEffectiveSegmentSurfaceMaterial(previewNode, r, parentSpec)
+    if (typeof spec.materialPreset === 'string') {
+      const resolved = createMaterialFromPresetRef(spec.materialPreset)
+      if (resolved) return resolved
+    }
+    if (spec.material !== undefined) return createMaterial(spec.material)
+    return null
+  }
+  const edge = resolveSlot('edge')
+  const wall = resolveSlot('wall')
+  const top = resolveSlot('top')
+  if (!(edge || wall || top)) return null
+  const fallback = parent ? getRoofMaterialArray(parent) : null
+  const fb = (n: number) => fallback?.[n] ?? null
+  // Per-role only, then the parent's themed slot — matches the renderer so the
+  // preview never bleeds a painted surface onto the segment's other surfaces.
+  const arr: Material[] = [edge ?? fb(0)!, wall ?? fb(1)!, wall ?? fb(2)!, top ?? fb(3)!]
+  if (arr.some((m) => !m)) return null
+  return previewMeshMaterial(mesh, arr)
 }
 
 function applyStairPaintPreview(
@@ -301,8 +366,9 @@ function applyStairPaintPreview(
     ...node,
     ...buildStairSurfaceMaterialPatch(node, role, material.material, material.materialPreset),
   }
-  const bodyMaterials = getStairBodyMaterials(previewNode)
-  const railingMaterial = getStairRailingMaterial(previewNode)
+  const shading = useViewer.getState().shading
+  const bodyMaterials = getStairBodyMaterials(previewNode, shading)
+  const railingMaterial = getStairRailingMaterial(previewNode, shading)
   const restores: PaintPreviewCleanup[] = []
 
   root.traverse((object) => {
@@ -335,13 +401,13 @@ function applyStairPaintPreview(
 }
 
 function applySingleSurfacePaintPreview(
-  node: FenceNode | ColumnNode | SlabNode | CeilingNode,
+  node: FenceNode | ColumnNode | SlabNode | CeilingNode | ShelfNode,
   material: ActivePaintMaterial,
 ): PaintPreviewCleanup | null {
   if (node.type === 'ceiling') {
     const root = getRegisteredMesh(node.id)
     const overlay = root?.getObjectByName('ceiling-grid') as Mesh | undefined
-    if (!root || !overlay) return null
+    if (!(root && overlay)) return null
 
     const previewColor =
       getMaterialPresetByRef(material.materialPreset)?.mapProperties.color ??
@@ -403,6 +469,25 @@ function applySingleSurfacePaintPreview(
     }
   }
 
+  if (node.type === 'shelf') {
+    // Shelf registers a `<group>` (not a Mesh) with `useRegistry`, so we walk
+    // the subtree and preview-swap every child mesh — same approach `column`
+    // uses. (The roof vents previously shared this arm; they now route through
+    // their `capabilities.paint` dispatcher.)
+    if (!registeredObject) return null
+    const restores: PaintPreviewCleanup[] = []
+    registeredObject.traverse((object) => {
+      if (!(object as Mesh).isMesh) return
+      restores.push(previewMeshMaterial(object as Mesh, previewMaterial))
+    })
+    if (restores.length === 0) return null
+    return () => {
+      for (let index = restores.length - 1; index >= 0; index -= 1) {
+        restores[index]?.()
+      }
+    }
+  }
+
   if (!mesh) return null
 
   if (node.type === 'slab') {
@@ -427,6 +512,11 @@ function applySingleSurfacePaintPreview(
   return previewMeshMaterial(mesh, previewMaterial)
 }
 
+// Chimney + dormer paint dispatch lives on their NodeDefinition's
+// `capabilities.paint` (see packages/nodes/src/{chimney,dormer}/
+// paint.ts). The generic registry-driven arm in this file consults
+// those entries — no per-kind helpers needed here.
+
 function setSelectedMaterialTargetForNode(node: AnyNode, role: MaterialTargetRole | null) {
   if (!role) {
     const currentTarget = useEditor.getState().selectedMaterialTarget
@@ -565,6 +655,7 @@ const SELECTION_STRATEGIES: Record<string, SelectionStrategy> = {
       'fence',
       'item',
       'column',
+      'elevator',
       'zone',
       'slab',
       'ceiling',
@@ -579,11 +670,18 @@ const SELECTION_STRATEGIES: Record<string, SelectionStrategy> = {
     handleSelect: (node, nativeEvent, modifierKeys) => {
       const { selection, setSelection } = useViewer.getState()
       const nodes = useScene.getState().nodes
-      const nodeLevelId = resolveLevelId(node, nodes)
-      const buildingId = resolveBuildingId(nodeLevelId, nodes)
+      const nodeLevelId = node.type === 'elevator' ? null : resolveLevelId(node, nodes)
+      const buildingId =
+        node.type === 'elevator' &&
+        node.parentId &&
+        nodes[node.parentId as AnyNodeId]?.type === 'building'
+          ? node.parentId
+          : nodeLevelId
+            ? resolveBuildingId(nodeLevelId, nodes)
+            : null
 
       const updates: any = {}
-      if (nodeLevelId !== 'default' && nodeLevelId !== selection.levelId) {
+      if (nodeLevelId && nodeLevelId !== 'default' && nodeLevelId !== selection.levelId) {
         updates.levelId = nodeLevelId
       }
       if (buildingId && buildingId !== selection.buildingId) {
@@ -619,6 +717,7 @@ const SELECTION_STRATEGIES: Record<string, SelectionStrategy> = {
         node.type === 'wall' ||
         node.type === 'fence' ||
         node.type === 'column' ||
+        node.type === 'elevator' ||
         node.type === 'slab' ||
         node.type === 'ceiling' ||
         node.type === 'roof' ||
@@ -636,6 +735,11 @@ const SELECTION_STRATEGIES: Record<string, SelectionStrategy> = {
       }
       if (node.type === 'window' || node.type === 'door') return true
 
+      // Registry-driven: any kind whose NodeDefinition declares the
+      // `selectable` capability is also selectable in structure phase. Phase 4
+      // makes this the only path and deletes the hardcoded chain above.
+      if (isRegistrySelectable(node.type)) return true
+
       return false
     },
   },
@@ -664,14 +768,43 @@ const SELECTION_STRATEGIES: Record<string, SelectionStrategy> = {
     },
     isValid: (node) => {
       if (!isNodeInCurrentLevel(node)) return false
-      if (node.type !== 'item') return false
-      const item = node as ItemNode
-      return item.asset.category !== 'door' && item.asset.category !== 'window'
+      // Item: door/window-category items belong to structure phase, not furnish.
+      if (node.type === 'item') {
+        const item = node as ItemNode
+        return item.asset.category !== 'door' && item.asset.category !== 'window'
+      }
+      // Registry-driven kinds with `category: 'furnish'` (shelf today,
+      // future furniture kinds): selectable in furnish phase if their
+      // definition declares the `selectable` capability. Without this
+      // branch, shelf clicks routed to furnish phase via getSelectionTarget
+      // would be rejected here — single-click selection broken.
+      const def = nodeRegistry.get(node.type)
+      if (def && def.category === 'furnish' && def.capabilities.selectable) return true
+      return false
     },
   },
 }
 
 const getSelectionTarget = (node: AnyNode): SelectionTarget | null => {
+  // Item is checked FIRST so its asset.category-driven routing (door/
+  // window items land in structure phase, everything else in furnish)
+  // beats the generic registry fallback below. Without this, registering
+  // `item` (Phase 5) made isRegistrySelectable('item') match the
+  // structure branch first, breaking single-click selection: first click
+  // switched the editor to structure phase, second click selected.
+  if (node.type === 'item') {
+    const item = node as ItemNode
+    if (item.asset.category === 'door' || item.asset.category === 'window') {
+      return {
+        phase: 'structure',
+        structureLayer: 'elements',
+      }
+    }
+    return {
+      phase: 'furnish',
+    }
+  }
+
   if (node.type === 'zone') {
     return {
       phase: 'structure',
@@ -683,6 +816,7 @@ const getSelectionTarget = (node: AnyNode): SelectionTarget | null => {
     node.type === 'wall' ||
     node.type === 'fence' ||
     node.type === 'column' ||
+    node.type === 'elevator' ||
     node.type === 'slab' ||
     node.type === 'ceiling' ||
     node.type === 'roof' ||
@@ -699,18 +833,16 @@ const getSelectionTarget = (node: AnyNode): SelectionTarget | null => {
     }
   }
 
-  if (node.type === 'item') {
-    const item = node as ItemNode
-    if (item.asset.category === 'door' || item.asset.category === 'window') {
-      return {
-        phase: 'structure',
-        structureLayer: 'elements',
-      }
-    }
-
-    return {
-      phase: 'furnish',
+  // Registry-driven kinds (Phase 5+): route by `def.category`. Built-ins
+  // above match before this fallback. Furnish-category kinds (shelf,
+  // item — already handled above) land on the furnish phase; structure-
+  // category kinds (everything else) on structure/elements.
+  const def = nodeRegistry.get(node.type)
+  if (def) {
+    if (def.category === 'furnish') {
+      return { phase: 'furnish' }
     }
+    return { phase: 'structure', structureLayer: 'elements' }
   }
 
   return null
@@ -762,45 +894,84 @@ export const SelectionManager = () => {
       })
 
     const getPaintInteraction = (event: NodeEvent): PaintInteraction | null => {
+      const eraser = useEditor.getState().paintEraser
       const activePaintMaterial = resolveActivePaintMaterial()
       const node = event.node
 
       if (!isNodeInCurrentLevel(node)) return null
 
-      if (node.type === 'wall') {
-        const role = resolveWallMaterialTarget(event as WallEvent)
-        const compatible = role !== null && hasActivePaintMaterial(activePaintMaterial)
+      // The eraser clears a surface back to its default by painting with an
+      // empty material — every `build*SurfaceMaterialPatch` interprets
+      // `undefined` material/preset as "reset this role". So a single spec
+      // with both fields undefined drives the same apply/preview paths as a
+      // real material; only the enabled-gate differs (no material required).
+      const paintEnabled = eraser || hasActivePaintMaterial(activePaintMaterial)
+      const paintSpec: ActivePaintMaterial = eraser
+        ? {
+            material: undefined,
+            materialPreset: undefined,
+            sourceTarget:
+              activePaintMaterial?.sourceTarget ?? useEditor.getState().activePaintTarget,
+          }
+        : (activePaintMaterial ?? {
+            material: undefined,
+            materialPreset: undefined,
+            sourceTarget: useEditor.getState().activePaintTarget,
+          })
+
+      // Registry-driven paint dispatch — kinds that declare
+      // `capabilities.paint` route hover / click / preview through
+      // their definition. Wall, chimney, and dormer use this; legacy
+      // roof / stair / single-surface arms below stay until they
+      // migrate too.
+      const paintCap = nodeRegistry.get(node.type)?.capabilities?.paint
+      if (paintCap) {
+        const materialIndex = getIntersectionMaterialIndex(getEventObject(event), event.faceIndex)
+        const role = paintCap.resolveRole({
+          node,
+          materialIndex: materialIndex ?? null,
+          normal: event.normal,
+          localPosition: event.localPosition as readonly [number, number, number] | undefined,
+          hitObjectName: event.nativeEvent.object?.name,
+        })
+        const compatible = role !== null && paintEnabled
         return {
-          key: `wall:${node.id}:${role ?? 'unsupported'}`,
+          key: `${node.type}:${node.id}:${role ?? 'unsupported'}:${eraser ? 'erase' : 'paint'}`,
           hoveredId: node.id as AnyNodeId,
-          hoverMode:
-            compatible && hasActivePaintMaterial(activePaintMaterial) && role
-              ? 'paint-ready'
-              : 'paint-disabled',
+          hoverMode: compatible ? 'paint-ready' : 'paint-disabled',
           apply:
-            compatible && hasActivePaintMaterial(activePaintMaterial)
+            compatible && role
               ? () => {
-                  useScene
-                    .getState()
-                    .updateNode(
-                      node.id as AnyNodeId,
-                      buildWallSurfaceMaterialPatch(
-                        node as WallNode,
-                        role!,
-                        activePaintMaterial.material,
-                        activePaintMaterial.materialPreset,
-                      ),
-                    )
+                  useScene.getState().updateNode(
+                    node.id as AnyNodeId,
+                    paintCap.buildPatch({
+                      node,
+                      role,
+                      material: paintSpec.material,
+                      materialPreset: paintSpec.materialPreset,
+                    }) as Partial<AnyNode>,
+                  )
                 }
               : null,
           preview:
-            compatible && hasActivePaintMaterial(activePaintMaterial) && role
-              ? () => applyWallPaintPreview(node as WallNode, role, activePaintMaterial)
+            compatible && role
+              ? () => {
+                  const root = getRegisteredNodeObject(node.id)
+                  if (!root) return null
+                  return paintCap.applyPreview({
+                    node,
+                    role,
+                    material: paintSpec.material,
+                    materialPreset: paintSpec.materialPreset,
+                    root,
+                  })
+                }
               : () => previewCursor('not-allowed'),
         }
       }
 
       if (node.type === 'roof' || node.type === 'roof-segment') {
+        const isSegmentHit = node.type === 'roof-segment'
         const roofNode =
           node.type === 'roof'
             ? node
@@ -810,33 +981,56 @@ export const SelectionManager = () => {
         if (!roofNode || roofNode.type !== 'roof') return null
 
         const role = resolveRoofMaterialTarget(event as RoofEvent | RoofSegmentEvent)
-        const compatible = role !== null && hasActivePaintMaterial(activePaintMaterial)
+        const compatible = role !== null && paintEnabled
+        // Painting directly on a segment (only possible in segment edit
+        // mode, where the per-segment mesh is visible) writes to the
+        // segment's own role-specific fields. Painting the merged shell
+        // — or a roof node directly — keeps fanning to the parent roof.
+        const segmentTarget = isSegmentHit ? (node as RoofSegmentNode) : null
         return {
-          key: `roof:${roofNode.id}:${role ?? 'unsupported'}`,
-          hoveredId: roofNode.id as AnyNodeId,
-          hoverMode:
-            compatible && hasActivePaintMaterial(activePaintMaterial) && role
-              ? 'paint-ready'
-              : 'paint-disabled',
+          key: `${segmentTarget ? 'roof-segment' : 'roof'}:${
+            segmentTarget ? segmentTarget.id : roofNode.id
+          }:${role ?? 'unsupported'}:${eraser ? 'erase' : 'paint'}`,
+          hoveredId: (segmentTarget ? segmentTarget.id : roofNode.id) as AnyNodeId,
+          hoverMode: compatible ? 'paint-ready' : 'paint-disabled',
           apply:
-            compatible && hasActivePaintMaterial(activePaintMaterial)
+            compatible && role
               ? () => {
-                  useScene
-                    .getState()
-                    .updateNode(
+                  const sceneState = useScene.getState()
+                  if (segmentTarget) {
+                    sceneState.updateNode(
+                      segmentTarget.id as AnyNodeId,
+                      buildRoofSegmentSurfaceMaterialPatch(
+                        segmentTarget,
+                        role,
+                        paintSpec.material,
+                        paintSpec.materialPreset,
+                      ),
+                    )
+                  } else {
+                    sceneState.updateNode(
                       roofNode.id as AnyNodeId,
                       buildRoofSurfaceMaterialPatch(
                         roofNode as RoofNode,
-                        role!,
-                        activePaintMaterial.material,
-                        activePaintMaterial.materialPreset,
+                        role,
+                        paintSpec.material,
+                        paintSpec.materialPreset,
                       ),
                     )
+                  }
                 }
               : null,
           preview:
-            compatible && hasActivePaintMaterial(activePaintMaterial) && role
-              ? () => applyRoofPaintPreview(roofNode as RoofNode, role, activePaintMaterial)
+            compatible && role
+              ? () =>
+                  segmentTarget
+                    ? applyRoofSegmentPaintPreview(
+                        segmentTarget,
+                        roofNode as RoofNode,
+                        role,
+                        paintSpec,
+                      )
+                    : applyRoofPaintPreview(roofNode as RoofNode, role, paintSpec)
               : () => previewCursor('not-allowed'),
         }
       }
@@ -851,16 +1045,13 @@ export const SelectionManager = () => {
         if (!stairNode || stairNode.type !== 'stair') return null
 
         const role = resolveStairMaterialTarget(event as StairEvent | StairSegmentEvent)
-        const compatible = role !== null && hasActivePaintMaterial(activePaintMaterial)
+        const compatible = role !== null && paintEnabled
         return {
-          key: `stair:${stairNode.id}:${role ?? 'unsupported'}`,
+          key: `stair:${stairNode.id}:${role ?? 'unsupported'}:${eraser ? 'erase' : 'paint'}`,
           hoveredId: stairNode.id as AnyNodeId,
-          hoverMode:
-            compatible && hasActivePaintMaterial(activePaintMaterial) && role
-              ? 'paint-ready'
-              : 'paint-disabled',
+          hoverMode: compatible ? 'paint-ready' : 'paint-disabled',
           apply:
-            compatible && hasActivePaintMaterial(activePaintMaterial)
+            compatible && role
               ? () => {
                   useScene
                     .getState()
@@ -868,30 +1059,36 @@ export const SelectionManager = () => {
                       stairNode.id as AnyNodeId,
                       buildStairSurfaceMaterialPatch(
                         stairNode as StairNode,
-                        role!,
-                        activePaintMaterial.material,
-                        activePaintMaterial.materialPreset,
+                        role,
+                        paintSpec.material,
+                        paintSpec.materialPreset,
                       ),
                     )
                 }
               : null,
           preview:
-            compatible && hasActivePaintMaterial(activePaintMaterial) && role
-              ? () => applyStairPaintPreview(stairNode as StairNode, role, activePaintMaterial)
+            compatible && role
+              ? () => applyStairPaintPreview(stairNode as StairNode, role, paintSpec)
               : () => previewCursor('not-allowed'),
         }
       }
 
+      // Registry-driven paint dispatch handled at the top of this
+      // function — kinds declaring `capabilities.paint` return there
+      // before any of the legacy roof / stair / single-surface arms
+      // below run.
+
       if (
         node.type === 'fence' ||
         node.type === 'column' ||
         node.type === 'slab' ||
-        node.type === 'ceiling'
+        node.type === 'ceiling' ||
+        node.type === 'shelf'
       ) {
-        const compatible = hasActivePaintMaterial(activePaintMaterial)
+        const compatible = paintEnabled
 
         return {
-          key: `${node.type}:${node.id}:surface`,
+          key: `${node.type}:${node.id}:surface:${eraser ? 'erase' : 'paint'}`,
           hoveredId: node.id as AnyNodeId,
           hoverMode: compatible ? 'paint-ready' : 'paint-disabled',
           apply: compatible
@@ -901,16 +1098,16 @@ export const SelectionManager = () => {
                   .updateNode(
                     node.id as AnyNodeId,
                     buildSingleSurfaceMaterialPatch<
-                      FenceNode | ColumnNode | SlabNode | CeilingNode
-                    >(activePaintMaterial.material, activePaintMaterial.materialPreset),
+                      FenceNode | ColumnNode | SlabNode | CeilingNode | ShelfNode
+                    >(paintSpec.material, paintSpec.materialPreset),
                   )
               }
             : null,
           preview: compatible
             ? () =>
                 applySingleSurfacePaintPreview(
-                  node as FenceNode | ColumnNode | SlabNode | CeilingNode,
-                  activePaintMaterial,
+                  node as FenceNode | ColumnNode | SlabNode | CeilingNode | ShelfNode,
+                  paintSpec,
                 )
             : () => previewCursor('not-allowed'),
         }
@@ -999,20 +1196,26 @@ export const SelectionManager = () => {
       'roof-segment',
       'stair',
       'stair-segment',
-      'spawn',
       'window',
       'door',
       'zone',
     ] as const
 
-    for (const type of allTypes) {
+    // Registry-driven kinds get the same subscriptions as the hardcoded list,
+    // so future built-in nodes don't need to edit allTypes per migration.
+    const registryKinds = getSelectableKinds().filter(
+      (k) => !(allTypes as readonly string[]).includes(k),
+    )
+    const subscribedKinds = [...(allTypes as readonly string[]), ...registryKinds]
+
+    for (const type of subscribedKinds) {
       emitter.on(`${type}:enter` as any, onEnter as any)
       emitter.on(`${type}:leave` as any, onLeave as any)
       emitter.on(`${type}:click` as any, onClick as any)
     }
 
     return () => {
-      for (const type of allTypes) {
+      for (const type of subscribedKinds) {
         emitter.off(`${type}:enter` as any, onEnter as any)
         emitter.off(`${type}:leave` as any, onLeave as any)
         emitter.off(`${type}:click` as any, onClick as any)
@@ -1059,6 +1262,16 @@ export const SelectionManager = () => {
       if (boxSelectHandled) return
 
       const node = event.node
+
+      // A ceiling is selectable only through its corner handles, never via
+      // the `ceiling-grid` body mesh. When the grid is revealed (ceiling
+      // selected, or an item placed beneath it) a top-down click hits the
+      // grid first; selecting the ceiling there both re-selects it as a
+      // no-op and stops propagation, blocking the hosted item below. By
+      // ignoring non-handle ceiling clicks (without stopping propagation)
+      // the click falls through to the item underneath.
+      if (node.type === 'ceiling' && !event.viaHandle) return
+
       let currentPhase = useEditor.getState().phase
       let currentStructureLayer = useEditor.getState().structureLayer
 
@@ -1092,8 +1305,14 @@ export const SelectionManager = () => {
 
         let nodeToSelect = node
         if (node.type === 'roof-segment' && node.parentId) {
-          const parentNode = useScene.getState().nodes[node.parentId as AnyNodeId]
-          if (parentNode && parentNode.type === 'roof') {
+          const nodes = useScene.getState().nodes
+          const parentNode = nodes[node.parentId as AnyNodeId]
+          const selectedIds = useViewer.getState().selection.selectedIds
+          if (
+            parentNode &&
+            parentNode.type === 'roof' &&
+            !isInActiveRoofContext(node, selectedIds, nodes)
+          ) {
             nodeToSelect = parentNode
           }
         }
@@ -1104,19 +1323,44 @@ export const SelectionManager = () => {
           }
         }
 
+        // Clicking any node (e.g. the slab surface outside a hole) exits slab
+        // hole-edit mode. The hole handles + hit mesh stopPropagation, so a
+        // click reaching here means the user clicked outside the hole.
+        if (useEditor.getState().editingHole) {
+          useEditor.getState().setEditingHole(null)
+        }
+
         activeStrategy.handleSelect(nodeToSelect, event.nativeEvent, modifierKeysRef.current)
 
         let nextMaterialTargetHandled = false
 
-        if (node.type === 'wall' && nodeToSelect.type === 'wall') {
-          setSelectedMaterialTargetForNode(
-            nodeToSelect,
-            resolveWallMaterialTarget(event as WallEvent),
-          )
-          nextMaterialTargetHandled = true
+        // Registry-driven paint-target resolve on click. Kinds with
+        // `capabilities.paint` route through this entry — wall,
+        // chimney, dormer use it today. The legacy stair / roof /
+        // single-surface arms below stay until they migrate too.
+        if (nodeToSelect.type === node.type) {
+          const paintCap = nodeRegistry.get(node.type)?.capabilities?.paint
+          if (paintCap) {
+            const materialIndex = getIntersectionMaterialIndex(
+              getEventObject(event),
+              event.faceIndex,
+            )
+            const role = paintCap.resolveRole({
+              node,
+              materialIndex: materialIndex ?? null,
+              normal: event.normal,
+              localPosition: event.localPosition as readonly [number, number, number] | undefined,
+              hitObjectName: event.nativeEvent.object?.name,
+            })
+            if (role) {
+              setSelectedMaterialTargetForNode(nodeToSelect, role as MaterialTargetRole)
+              nextMaterialTargetHandled = true
+            }
+          }
         }
 
         if (
+          !nextMaterialTargetHandled &&
           (node.type === 'stair' || node.type === 'stair-segment') &&
           nodeToSelect.type === 'stair'
         ) {
@@ -1128,6 +1372,7 @@ export const SelectionManager = () => {
         }
 
         if (
+          !nextMaterialTargetHandled &&
           (node.type === 'roof' || node.type === 'roof-segment') &&
           nodeToSelect.type === 'roof'
         ) {
@@ -1139,7 +1384,11 @@ export const SelectionManager = () => {
         }
 
         if (
-          (node.type === 'fence' || node.type === 'slab' || node.type === 'ceiling') &&
+          !nextMaterialTargetHandled &&
+          (node.type === 'fence' ||
+            node.type === 'slab' ||
+            node.type === 'ceiling' ||
+            node.type === 'shelf') &&
           nodeToSelect.type === node.type
         ) {
           setSelectedMaterialTargetForNode(nodeToSelect, 'surface')
@@ -1163,6 +1412,7 @@ export const SelectionManager = () => {
       'item',
       'column',
       'building',
+      'elevator',
       'zone',
       'slab',
       'ceiling',
@@ -1174,7 +1424,14 @@ export const SelectionManager = () => {
       'window',
       'door',
     ]
-    allTypes.forEach((type) => {
+    // Registry-driven kinds get the same subscriptions as the hardcoded list,
+    // so future built-in nodes don't need to edit allTypes per migration.
+    const registryKinds = getSelectableKinds().filter(
+      (k) => !(allTypes as readonly string[]).includes(k),
+    )
+    const subscribedKinds = [...(allTypes as readonly string[]), ...registryKinds]
+
+    subscribedKinds.forEach((type) => {
       emitter.on(`${type}:click` as any, onClick as any)
     })
 
@@ -1195,7 +1452,7 @@ export const SelectionManager = () => {
     emitter.on('grid:click', onGridClick)
 
     return () => {
-      allTypes.forEach((type) => {
+      subscribedKinds.forEach((type) => {
         emitter.off(`${type}:click` as any, onClick as any)
       })
       emitter.off('grid:click', onGridClick)
@@ -1242,7 +1499,11 @@ export const SelectionManager = () => {
     }
 
     const onDoubleClick = (event: NodeEvent) => {
-      const node = event.node
+      let node = event.node
+      if (node.type === 'roof') {
+        node = resolveRoofSegmentSelectionTarget(event) ?? node
+      }
+
       const currentPhase = useEditor.getState().phase
 
       let targetPhase: 'site' | 'structure' | 'furnish' | null = null
@@ -1259,6 +1520,7 @@ export const SelectionManager = () => {
         node.type === 'wall' ||
         node.type === 'fence' ||
         node.type === 'column' ||
+        node.type === 'elevator' ||
         node.type === 'slab' ||
         node.type === 'ceiling' ||
         node.type === 'roof' ||
@@ -1313,6 +1575,7 @@ export const SelectionManager = () => {
       'item',
       'column',
       'building',
+      'elevator',
       'slab',
       'ceiling',
       'roof',
@@ -1325,14 +1588,19 @@ export const SelectionManager = () => {
       'zone',
       'site',
     ]
-    allTypes.forEach((type) => {
+    const registryKinds = getSelectableKinds().filter(
+      (k) => !(allTypes as readonly string[]).includes(k),
+    )
+    const subscribedKinds = [...(allTypes as readonly string[]), ...registryKinds]
+
+    subscribedKinds.forEach((type) => {
       emitter.on(`${type}:enter` as any, onEnter as any)
       emitter.on(`${type}:leave` as any, onLeave as any)
       emitter.on(`${type}:double-click` as any, onDoubleClick as any)
     })
 
     return () => {
-      allTypes.forEach((type) => {
+      subscribedKinds.forEach((type) => {
         emitter.off(`${type}:enter` as any, onEnter as any)
         emitter.off(`${type}:leave` as any, onLeave as any)
         emitter.off(`${type}:double-click` as any, onDoubleClick as any)
@@ -1351,11 +1619,7 @@ export const SelectionManager = () => {
       event.stopPropagation()
 
       // Play appropriate SFX
-      if (node.type === 'item') {
-        sfxEmitter.emit('sfx:item-delete')
-      } else {
-        sfxEmitter.emit('sfx:structure-delete')
-      }
+      emitDeleteSFX(node.type)
 
       useScene.getState().deleteNode(node.id as AnyNodeId)
       if (node.parentId) useScene.getState().dirtyNodes.add(node.parentId as AnyNodeId)
@@ -1386,25 +1650,32 @@ export const SelectionManager = () => {
       'fence',
       'item',
       'column',
+      'elevator',
       'slab',
       'ceiling',
       'roof',
       'roof-segment',
       'stair',
       'stair-segment',
+      'spawn',
       'window',
       'door',
       'zone',
     ] as const
 
-    for (const type of allTypes) {
+    const registryKinds = getSelectableKinds().filter(
+      (k) => !(allTypes as readonly string[]).includes(k),
+    )
+    const subscribedKinds = [...(allTypes as readonly string[]), ...registryKinds]
+
+    for (const type of subscribedKinds) {
       emitter.on(`${type}:click` as any, onClick as any)
       emitter.on(`${type}:enter` as any, onEnter as any)
       emitter.on(`${type}:leave` as any, onLeave as any)
     }
 
     return () => {
-      for (const type of allTypes) {
+      for (const type of subscribedKinds) {
         emitter.off(`${type}:click` as any, onClick as any)
         emitter.off(`${type}:enter` as any, onEnter as any)
         emitter.off(`${type}:leave` as any, onLeave as any)
@@ -1636,6 +1907,7 @@ const EditorOutlinerSync = () => {
   const previewSelectedIds = useViewer((s) => s.previewSelectedIds)
   const hoveredId = useViewer((s) => s.hoveredId)
   const outliner = useViewer((s) => s.outliner)
+  const nodes = useScene((s) => s.nodes)
 
   useEffect(() => {
     let idsToHighlight: string[] = []
@@ -1672,16 +1944,21 @@ const EditorOutlinerSync = () => {
     // 2. Sync with the imperative outliner arrays (mutate in place to keep references)
     outliner.selectedObjects.length = 0
     for (const id of idsToHighlight) {
+      if (!nodes[id as AnyNodeId]) continue
       const obj = sceneRegistry.nodes.get(id)
       if (obj?.parent) outliner.selectedObjects.push(obj)
     }
 
     outliner.hoveredObjects.length = 0
     if (hoveredId) {
-      const obj = sceneRegistry.nodes.get(hoveredId)
-      if (obj?.parent) outliner.hoveredObjects.push(obj)
+      if (!nodes[hoveredId as AnyNodeId]) {
+        useViewer.setState({ hoveredId: null })
+      } else {
+        const obj = sceneRegistry.nodes.get(hoveredId)
+        if (obj?.parent) outliner.hoveredObjects.push(obj)
+      }
     }
-  }, [phase, previewSelectedIds, selection, hoveredId, outliner])
+  }, [phase, previewSelectedIds, selection, hoveredId, outliner, nodes])
 
   return null
 }