nodes: add modular cabinets and wall trim controls

apps/editor/lib/bootstrap.ts

@@ -1,13 +1,14 @@
 import {
   type AnyNodeDefinition,
   discoverPlugins,
+  extendPluginDiscovery,
   loadPlugin,
   nodeRegistry,
   registerNode,
-  setPluginDiscovery,
 } from '@pascal-app/core'
+import { registerEditorHostPanel } from '@pascal-app/editor'
 import { builtinPlugin } from '@pascal-app/nodes'
-import { treesPlugin } from '@pascal-app/plugin-trees'
+import { treesHostPanel, treesPlugin } from '@pascal-app/plugin-trees'
 
 // Idempotency guards: HMR can reload this module, but `registerNode`
 // throws on duplicate kinds. Flags live in the module closure so they
@@ -79,10 +80,11 @@ export async function loadExternalPlugins(): Promise<void> {
   }
 }
 
-// Register the first-party example plugin (trees node + presets rail panel)
-// through the same discovery hook a third-party pack would use. Must be set
-// before `loadExternalPlugins()` reads it below.
-setPluginDiscovery(async () => [treesPlugin])
+// Register the first-party example node plugin alongside any host-provided
+// discovery source instead of replacing it. Its Nature rail panel is host UI,
+// so it is registered separately from the core plugin manifest.
+extendPluginDiscovery(async () => [treesPlugin])
+registerEditorHostPanel(treesHostPanel)
 
 loadBuiltinsSync()
 void loadExternalPlugins()

apps/editor/package.json

@@ -4,7 +4,7 @@
   "type": "module",
   "private": true,
   "scripts": {
-    "dev": "dotenv -e ../../.env.local -- next dev --port 3002",
+    "dev": "dotenv -e ../../.env.local -- next dev --port ${PORT:-3002}",
     "build": "dotenv -e ../../.env.local -- next build",
     "start": "next start",
     "lint": "biome lint",

packages/core/src/events/bus.ts

@@ -4,6 +4,8 @@ import type { Object3D } from 'three'
 import type {
   BoxVentNode,
   BuildingNode,
+  CabinetModuleNode,
+  CabinetNode,
   CeilingNode,
   ChimneyNode,
   ColumnNode,
@@ -89,6 +91,8 @@ export type FenceEvent = NodeEvent<FenceNode>
 export type ItemEvent = NodeEvent<ItemNode>
 export type SiteEvent = NodeEvent<SiteNode>
 export type BuildingEvent = NodeEvent<BuildingNode>
+export type CabinetEvent = NodeEvent<CabinetNode>
+export type CabinetModuleEvent = NodeEvent<CabinetModuleNode>
 export type LevelEvent = NodeEvent<LevelNode>
 export type ZoneEvent = NodeEvent<ZoneNode>
 export type ShelfEvent = NodeEvent<ShelfNode>
@@ -251,9 +255,20 @@ type RoomPresetEvents = {
   'room-preset:create': RoomPresetCreateEvent
 }
 
+type SelectionEvents = {
+  /**
+   * "Reveal this node" intent — the editor's node action menu emits it with the
+   * selected node; whoever owns the node's catalog/panel (host browser, a
+   * plugin's presets panel) listens and reveals it.
+   */
+  'selection:find-node': AnyNode
+}
+
 type EditorEvents = GridEvents &
   NodeEvents<'wall', WallEvent> &
   NodeEvents<'fence', FenceEvent> &
+  NodeEvents<'cabinet', CabinetEvent> &
+  NodeEvents<'cabinet-module', CabinetModuleEvent> &
   NodeEvents<'item', ItemEvent> &
   NodeEvents<'site', SiteEvent> &
   NodeEvents<'building', BuildingEvent> &
@@ -301,6 +316,7 @@ type EditorEvents = GridEvents &
   ThumbnailEvents &
   SnapshotEvents &
   AIChatEvents &
-  RoomPresetEvents
+  RoomPresetEvents &
+  SelectionEvents
 
 export const emitter = mitt<EditorEvents>()

packages/core/src/hooks/spatial-grid/floor-placed-elevation.test.ts

@@ -3,6 +3,7 @@ import { z } from 'zod'
 import { nodeRegistry, registerNode } from '../../registry'
 import type { AnyNodeDefinition } from '../../registry/types'
 import type { AnyNode, SlabNode } from '../../schema'
+import useScene from '../../store/use-scene'
 import { getFloorPlacedElevation, getFloorStackedPosition } from './floor-placed-elevation'
 import { spatialGridManager } from './spatial-grid-manager'
 
@@ -86,6 +87,7 @@ describe('floor-placed elevation resolver', () => {
   beforeEach(() => {
     nodeRegistry._reset()
     spatialGridManager.clear()
+    useScene.setState({ nodes: {} })
   })
 
   test('returns 0 without a floorPlaced capability', () => {
@@ -113,6 +115,118 @@ describe('floor-placed elevation resolver', () => {
     ).toBe(0)
   })
 
+  test('canPlaceOnFloorFootprints accepts an L-shaped draft in the open corner gap', () => {
+    const baseAsset = (makeFloorNode() as { asset: Record<string, unknown> }).asset
+    registerNode(
+      makeDefinition('item', {
+        floorPlaced: {
+          footprint: (node) => ({
+            dimensions: (node as { asset: { dimensions: [number, number, number] } }).asset
+              .dimensions,
+            rotation: [0, (node as { rotation: [number, number, number] }).rotation[1] ?? 0, 0],
+          }),
+          collides: true,
+        },
+      }),
+    )
+
+    const level = makeLevel()
+    const blocker = makeFloorNode({
+      id: 'item_blocker',
+      position: [0.85, 0, 0.85],
+      asset: {
+        ...baseAsset,
+        id: 'asset_blocker',
+        name: 'Blocker',
+        src: 'asset:blocker',
+        dimensions: [0.3, 1, 0.3],
+      } as AnyNode extends { asset: infer T } ? T : never,
+    })
+    useScene.setState({ nodes: nodesFor(level, blocker) })
+
+    const coarse = spatialGridManager.canPlaceOnFloor(LEVEL_ID, [0.5, 0, 0.5], [1, 1, 1], [0, 0, 0])
+    const precise = spatialGridManager.canPlaceOnFloorFootprints(LEVEL_ID, [
+      { position: [0.2, 0, 0.5], dimensions: [0.4, 1, 1], rotation: [0, 0, 0] },
+      { position: [0.8, 0, 0.2], dimensions: [0.4, 1, 0.4], rotation: [0, 0, 0] },
+    ])
+
+    expect(coarse.valid).toBe(false)
+    expect(coarse.conflictIds).toEqual(['item_blocker'])
+    expect(precise.valid).toBe(true)
+    expect(precise.conflictIds).toEqual([])
+  })
+
+  test('canPlaceOnFloorFootprints rejects overlapping draft footprints', () => {
+    useScene.setState({ nodes: nodesFor(makeLevel()) })
+
+    const result = spatialGridManager.canPlaceOnFloorFootprints(LEVEL_ID, [
+      { position: [0, 0, 0], dimensions: [1, 1, 1], rotation: [0, 0, 0] },
+      { position: [0.25, 0, 0], dimensions: [1, 1, 1], rotation: [0, 0, 0] },
+    ])
+
+    expect(result.valid).toBe(false)
+    expect(result.conflictIds).toEqual([])
+  })
+
+  test('canPlaceOnFloorFootprints ignores descendants of an ignored composite node', () => {
+    registerNode(
+      makeDefinition('cabinet', {
+        floorPlaced: {
+          footprint: () => ({
+            dimensions: [1, 1, 1],
+            rotation: [0, 0, 0],
+          }),
+          collides: true,
+        },
+      }),
+    )
+    registerNode(
+      makeDefinition('cabinet-module', {
+        floorPlaced: {
+          footprint: () => ({
+            dimensions: [1, 1, 1],
+            rotation: [0, 0, 0],
+          }),
+          collides: true,
+        },
+      }),
+    )
+
+    const level = makeLevel()
+    const run = {
+      id: 'cabinet_run',
+      type: 'cabinet',
+      object: 'node',
+      parentId: LEVEL_ID,
+      visible: true,
+      metadata: {},
+      children: ['cabinet-module_child'],
+      position: [0, 0, 0],
+      rotation: 0,
+    } as unknown as AnyNode
+    const module = {
+      id: 'cabinet-module_child',
+      type: 'cabinet-module',
+      object: 'node',
+      parentId: run.id,
+      visible: true,
+      metadata: {},
+      children: [],
+      position: [0, 0, 0],
+      rotation: 0,
+    } as unknown as AnyNode
+    useScene.setState({ nodes: nodesFor(level, run, module) })
+
+    const result = spatialGridManager.canPlaceOnFloorFootprints(
+      LEVEL_ID,
+      [{ position: [0, 0, 0], dimensions: [1, 1, 1], rotation: [0, 0, 0] }],
+      [run.id],
+    )
+
+    expect(result.valid).toBe(true)
+    expect(result.conflictIds).toEqual([])
+  })
+
   test('returns 0 when applies returns false', () => {
     registerNode(
       makeDefinition('item', {

packages/core/src/hooks/spatial-grid/spatial-grid-manager.ts

@@ -163,6 +163,28 @@ function resolveNodeLevelId(node: AnyNode, nodes: Record<string, AnyNode>): stri
   return 'default'
 }
 
+function expandIgnoredNodeIds(
+  ignoreIds: readonly string[] | undefined,
+  nodes: Record<string, AnyNode>,
+): Set<string> {
+  const ignored = new Set(ignoreIds ?? [])
+  const queue = [...ignored]
+
+  while (queue.length > 0) {
+    const id = queue.pop()!
+    const node = nodes[id]
+    const children = (node as { children?: unknown } | undefined)?.children
+    if (!Array.isArray(children)) continue
+    for (const childId of children) {
+      if (typeof childId !== 'string' || ignored.has(childId)) continue
+      ignored.add(childId)
+      queue.push(childId)
+    }
+  }
+
+  return ignored
+}
+
 /**
  * Test if two line segments (a1->a2) and (b1->b2) intersect.
  */
@@ -704,16 +726,43 @@ export class SpatialGridManager {
     dimensions: [number, number, number],
     rotation: [number, number, number],
     ignoreIds?: string[],
+  ) {
+    return this.canPlaceOnFloorFootprints(levelId, [{ position, dimensions, rotation }], ignoreIds)
+  }
+
+  canPlaceOnFloorFootprints(
+    levelId: string,
+    footprints: readonly {
+      position: [number, number, number]
+      dimensions: [number, number, number]
+      rotation: [number, number, number]
+    }[],
+    ignoreIds?: string[],
   ) {
     const nodes = useScene.getState().nodes
-    const ignoreSet = new Set(ignoreIds ?? [])
-    const draftBounds = footprintBoundsXZ(position, dimensions, rotation[1])
+    const ignoreSet = expandIgnoredNodeIds(ignoreIds, nodes)
+    const draftBounds = footprints.map((footprint) =>
+      footprintBoundsXZ(footprint.position, footprint.dimensions, footprint.rotation[1] ?? 0),
+    )
+    for (let i = 0; i < draftBounds.length; i += 1) {
+      const a = draftBounds[i]!
+      for (let j = i + 1; j < draftBounds.length; j += 1) {
+        const b = draftBounds[j]!
+        if (
+          intervalsOverlap(a.minX, a.maxX, b.minX, b.maxX) &&
+          intervalsOverlap(a.minZ, a.maxZ, b.minZ, b.maxZ)
+        ) {
+          return { valid: false, conflictIds: [] }
+        }
+      }
+    }
 
     // A floor placement conflicts with any other COLLIDING floor-resting node,
     // not just items — every kind whose `floorPlaced.collides` is set (item /
-    // shelf / column) contributes its footprint(s) as an obstacle. Each
-    // candidate's XZ extent is read from the same declarative footprint the
-    // elevation + sync paths use, so adding a colliding kind needs no change here.
+    // shelf / column / cabinet / stair) contributes its footprint(s) as an
+    // obstacle. Each candidate's XZ extent is read from the same declarative
+    // footprint the elevation + sync paths use, so adding a colliding kind
+    // needs no change here.
     const conflicts: string[] = []
     for (const node of Object.values(nodes)) {
       if (ignoreSet.has(node.id)) continue
@@ -733,8 +782,11 @@ export class SpatialGridManager {
           fpRotation,
         )
         if (
-          intervalsOverlap(draftBounds.minX, draftBounds.maxX, bounds.minX, bounds.maxX) &&
-          intervalsOverlap(draftBounds.minZ, draftBounds.maxZ, bounds.minZ, bounds.maxZ)
+          draftBounds.some(
+            (draft) =>
+              intervalsOverlap(draft.minX, draft.maxX, bounds.minX, bounds.maxX) &&
+              intervalsOverlap(draft.minZ, draft.maxZ, bounds.minZ, bounds.maxZ),
+          )
         ) {
           conflicts.push(node.id)
           break

packages/core/src/index.ts

@@ -1,6 +1,8 @@
 export type {
   BoxVentEvent,
   BuildingEvent,
+  CabinetEvent,
+  CabinetModuleEvent,
   CameraControlEvent,
   CameraControlFitSceneEvent,
   CeilingEvent,
@@ -72,6 +74,7 @@ export {
   polygonsOverlap,
   segmentsIntersect,
 } from './lib/polygon-relations'
+export { resolveSelectionProxyId, selectionProxyIdFromMetadata } from './lib/selection-proxy'
 export { getRenderableSlabPolygon } from './lib/slab-polygon'
 export {
   deriveSlotId,
@@ -132,11 +135,13 @@ export type {
 export * from './registry'
 export * from './schema'
 export * from './services'
+export { isMovable, movePlanToward, moveToward, resolveMovable } from './services/movement'
 export {
   getSceneHistoryPauseDepth,
   pauseSceneHistory,
   resetSceneHistoryPauseDepth,
   resumeSceneHistory,
+  runAsSingleSceneHistoryStep,
 } from './store/history-control'
 export {
   type ControlValue,

packages/core/src/lib/selection-proxy.ts

@@ -0,0 +1,16 @@
+import type { AnyNode, AnyNodeId } from '../schema/types'
+
+export function selectionProxyIdFromMetadata(metadata: unknown): AnyNodeId | null {
+  if (!metadata || typeof metadata !== 'object' || Array.isArray(metadata)) return null
+  const value = (metadata as Record<string, unknown>).nodeSelectionProxyId
+  return typeof value === 'string' ? (value as AnyNodeId) : null
+}
+
+export function resolveSelectionProxyId(
+  node: AnyNode,
+  nodes: Readonly<Record<string, AnyNode | undefined>>,
+): AnyNodeId {
+  const proxyId = selectionProxyIdFromMetadata((node as { metadata?: unknown }).metadata)
+  if (!proxyId || !nodes[proxyId]) return node.id as AnyNodeId
+  return proxyId
+}

packages/core/src/registry/handles.ts

@@ -100,9 +100,11 @@ export type Cursor = 'ew-resize' | 'ns-resize' | 'move' | 'grab' | 'grabbing'
 export type HandleDecoration<N> = {
   kind: 'ring'
   /** Node-local radius of the ring (XZ plane). */
-  radius: (node: N) => number
+  radius: (node: N, sceneApi: SceneApi) => number
   /** Node-local Y of the ring. Defaults to 0. */
   y?: (node: N) => number
+  /** Node-local center of the ring. Defaults to the node origin. */
+  center?: (node: N, sceneApi: SceneApi) => readonly [number, number, number]
 }
 
 /**
@@ -127,6 +129,16 @@ export type LinearResizeHandle<N> = {
   anchor: HandleAnchor
   currentValue: (node: N) => number
   apply: (node: N, newValue: number, sceneApi: SceneApi) => Partial<N>
+  /** Optional live-scene visibility gate for context-dependent arrows. */
+  visible?: (node: N, sceneApi: SceneApi) => boolean
+  /**
+   * Optional committed-write hook. The generic handle renderer previews the
+   * selected node with the `apply` patch during drag; on release it normally
+   * writes that patch back to the same node. Composite nodes can override the
+   * final write here to fan the resize out to siblings / parents while keeping
+   * the handle UI generic.
+   */
+  commit?: (node: N, patch: Partial<N>, sceneApi: SceneApi) => void
   /**
    * Optional per-tick hook fired while this handle is being dragged, with the
    * live (in-progress, override-merged) node. A pure side-channel for transient