@pascal-app/editor 1.0.3 → 1.0.5

package/src/lib/scene.test.ts

@@ -1,9 +1,8 @@
 import { beforeEach, describe, expect, test } from 'bun:test'
-import { nodeRegistry, registerNode, useScene } from '@pascal-app/core'
+import { useScene } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
-import { z } from 'zod'
 import useEditor from '../store/use-editor'
-import { normalizeSceneGraphNodes, syncEditorSelectionFromCurrentScene } from './scene'
+import { syncEditorSelectionFromCurrentScene } from './scene'
 
 const building = {
   children: ['level_scene-root'],
@@ -59,41 +58,30 @@ describe('scene selection synchronization', () => {
       buildingId: building.id,
       levelId: level.id,
     })
-    expect(useEditor.getState().phase).toBe('structure')
+    expect(useEditor.getState().phase).toBe('building')
   })
-})
 
-describe('scene graph normalization', () => {
-  test('materializes registered schema defaults before the graph reaches renderers', () => {
-    const restoreRegistry = nodeRegistry._snapshot()
-    try {
-      registerNode({
-        kind: 'test-scene-normalization',
-        schema: z.object({
-          id: z.string(),
-          position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
-          rotation: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
-          type: z.literal('test-scene-normalization'),
-        }),
-        schemaVersion: 1,
-      } as never)
+  test('opening another project disarms the tool the last one left armed', () => {
+    // This runs on every scene load, so a mid-session project switch reads the
+    // live state of the project the user just left. A project always opens in
+    // select mode — the first click on the new scene selects, it does not build.
+    useScene.setState({
+      nodes: {
+        [building.id]: building,
+        [level.id]: level,
+        [wall.id]: wall,
+      },
+      rootNodeIds: [building.id],
+    } as never)
+    useEditor.getState().setPhase('building')
+    useEditor.getState().armToolMode({ mode: 'build', tool: 'wall' })
+
+    syncEditorSelectionFromCurrentScene()
 
-      expect(
-        normalizeSceneGraphNodes({
-          test: { id: 'test', type: 'test-scene-normalization' },
-          unknown: { id: 'unknown', type: 'unknown-kind', custom: true },
-        }),
-      ).toEqual({
-        test: {
-          id: 'test',
-          position: [0, 0, 0],
-          rotation: [0, 0, 0],
-          type: 'test-scene-normalization',
-        },
-        unknown: { id: 'unknown', type: 'unknown-kind', custom: true },
-      })
-    } finally {
-      restoreRegistry()
-    }
+    expect(useEditor.getState().toolMode).toEqual({ mode: 'select' })
+    expect(useEditor.getState().mode).toBe('select')
+    expect(useEditor.getState().tool).toBeNull()
+    // The phase is a preference and stays put.
+    expect(useEditor.getState().phase).toBe('building')
   })
 })

package/src/lib/scene.ts

@@ -1,7 +1,10 @@
 'use client'
 
 import {
+  type AnyNodeId,
   clearSceneHistory,
+  getSceneDocument,
+  materializeRegisteredNodeDefaults,
   nodeRegistry,
   resolveLevelId,
   sceneRegistry,
@@ -9,10 +12,11 @@ import {
 } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
 import useEditor, {
+  editorUiStateOnOpen,
   hasCustomPersistedEditorUiState,
-  normalizePersistedEditorUiState,
   type PersistedEditorUiState,
 } from '../store/use-editor'
+import useInteractionScope from '../store/use-interaction-scope'
 import { editorHostPanelRegistry } from './plugin-panels'
 
 export type SceneGraph = {
@@ -25,6 +29,18 @@ export type SceneGraph = {
   installedPlugins?: string[]
 }
 
+/**
+ * The scene as saves and exports write it. A clone in hand — a preset or duplicate the user is
+ * placing — is in the store from the tile click so tools can render and host it, but it only
+ * becomes part of the document when its placement commits.
+ */
+export function getSavedSceneDocument() {
+  const { scope } = useInteractionScope.getState()
+  const placing =
+    scope.kind === 'placing' && scope.driver === 'move-tool' ? [scope.nodeId as AnyNodeId] : []
+  return getSceneDocument(placing)
+}
+
 type PersistedSelectionPath = {
   buildingId: string | null
   levelId: string | null
@@ -150,7 +166,6 @@ export function writePersistedSelection(selection: {
 }
 
 function getEditorUiStateForRestoredSelection(
-  sceneNodes: Record<string, any>,
   selection: PersistedSelectionPath,
   fallbackUiState: PersistedEditorUiState,
 ): PersistedEditorUiState {
@@ -167,43 +182,16 @@ function getEditorUiStateForRestoredSelection(
             : { mode: 'select' },
       mode,
       tool: mode === 'build' ? 'property-line' : null,
-      structureLayer: 'elements',
-      catalogCategory: null,
-    }
-  }
-
-  if (selection.zoneId) {
-    return {
-      ...fallbackUiState,
-      phase: 'structure',
-      toolMode: { mode: 'select' },
-      mode: 'select',
-      tool: null,
-      structureLayer: 'zones',
       catalogCategory: null,
     }
   }
 
-  const selectedNodes = selection.selectedIds
-    .map((id) => sceneNodes[id])
-    .filter((node): node is Record<string, any> => Boolean(node))
-
-  const shouldRestoreFurnishPhase =
-    selectedNodes.length > 0 &&
-    selectedNodes.every(
-      (node) =>
-        node.type === 'item' &&
-        node.asset?.category !== 'door' &&
-        node.asset?.category !== 'window',
-    )
-
   return {
     ...fallbackUiState,
-    phase: shouldRestoreFurnishPhase ? 'furnish' : 'structure',
+    phase: 'building',
     toolMode: { mode: 'select' },
     mode: 'select',
     tool: null,
-    structureLayer: 'elements',
     catalogCategory: null,
   }
 }
@@ -284,11 +272,14 @@ export function syncEditorSelectionFromCurrentScene() {
       .flatMap((node) => (Array.isArray(node.children) ? node.children.map(resolve) : []))
       .find((node) => node?.type === 'building')
   const firstLevel = firstBuilding?.children?.map(resolve).find((n: any) => n?.type === 'level')
-  const restoredEditorUiState = normalizePersistedEditorUiState(useEditor.getState())
+  // Every project open lands in select mode, a mid-session switch included: this
+  // runs on each scene load, so it reads the live state the last project left
+  // behind and would otherwise re-arm that project's tool over the new scene.
+  const restoredEditorUiState = editorUiStateOnOpen(useEditor.getState())
   const shouldRestoreEditorUiState = hasCustomPersistedEditorUiState(restoredEditorUiState)
   const restoredSelection = getRestoredSelectionForScene(sceneNodes)
   const selectionDrivenEditorUiState = restoredSelection
-    ? getEditorUiStateForRestoredSelection(sceneNodes, restoredSelection, restoredEditorUiState)
+    ? getEditorUiStateForRestoredSelection(restoredSelection, restoredEditorUiState)
     : null
 
   if (firstBuilding && firstLevel) {
@@ -303,8 +294,7 @@ export function syncEditorSelectionFromCurrentScene() {
         selectedIds: [],
         zoneId: null,
       })
-      useEditor.getState().setPhase('structure')
-      useEditor.getState().setStructureLayer('elements')
+      useEditor.getState().setPhase('building')
       useEditor.getState().setMode('build')
       useEditor.getState().setTool('wall')
       return
@@ -351,8 +341,7 @@ export function syncEditorSelectionFromCurrentScene() {
       selectedIds: [],
       zoneId: null,
     })
-    useEditor.getState().setPhase('structure')
-    useEditor.getState().setStructureLayer('elements')
+    useEditor.getState().setPhase('building')
   } else {
     useEditor.getState().setPhase('site')
     useViewer.getState().setSelection({
@@ -381,7 +370,6 @@ function resetEditorInteractionState() {
   sceneRegistry.clear()
   useEditor.setState({
     phase: 'site',
-    structureLayer: 'elements',
     catalogCategory: null,
     selectedItem: null,
     selectedReferenceId: null,
@@ -400,30 +388,18 @@ function hasUsableSceneGraph(sceneGraph?: SceneGraph | null): sceneGraph is Scen
   )
 }
 
-export function normalizeSceneGraphNodes(
-  nodes: Readonly<Record<string, unknown>>,
-): Record<string, unknown> {
-  return Object.fromEntries(
-    Object.entries(nodes).map(([id, value]) => {
-      if (!value || typeof value !== 'object' || Array.isArray(value)) return [id, value]
-      const type = (value as { type?: unknown }).type
-      if (typeof type !== 'string') return [id, value]
-      const parsed = nodeRegistry.get(type)?.schema.safeParse(value)
-      return [id, parsed?.success ? parsed.data : value]
-    }),
-  )
-}
-
 export function applySceneGraphToEditor(sceneGraph?: SceneGraph | null) {
   const defaultInstalledPlugins = editorHostPanelRegistry.getDefaultInstalledPluginIds()
   if (hasUsableSceneGraph(sceneGraph)) {
     const { nodes, rootNodeIds, collections, materials, installedPlugins } = sceneGraph
-    useScene.getState().setScene(normalizeSceneGraphNodes(nodes) as any, rootNodeIds as any, {
-      collections: collections as any,
-      materials: materials as any,
-      installedPlugins: installedPlugins ?? defaultInstalledPlugins,
-      hasExplicitPluginInstallState: installedPlugins !== undefined,
-    })
+    useScene
+      .getState()
+      .setScene(materializeRegisteredNodeDefaults(nodes) as any, rootNodeIds as any, {
+        collections: collections as any,
+        materials: materials as any,
+        installedPlugins: installedPlugins ?? defaultInstalledPlugins,
+        hasExplicitPluginInstallState: installedPlugins !== undefined,
+      })
   } else {
     useScene.getState().clearScene()
     useScene.getState().setInstalledPlugins(defaultInstalledPlugins, { explicit: false })

package/src/lib/selection-routing.test.ts

@@ -11,14 +11,109 @@ import { useViewer } from '@pascal-app/viewer'
 import { z } from 'zod'
 import useEditor from '../store/use-editor'
 import {
+  deleteNodeFromCanvas,
   emitCanvasNodeSelection,
+  enterBuildingFromCanvas,
+  enterBuildingFromPlanHit,
+  resolveCanvasBuildingId,
   resolveCanvasSelectionNode,
-  resolveNodeSelectionTarget,
   resolveSelectedIdsForNodeClick,
   selectionModifiersFromEvent,
   shouldPreserveSelectedRoofHostTarget,
 } from './selection-routing'
 
+describe('building entry from either canvas', () => {
+  test('a Site hit enters the owning building before selecting an element', () => {
+    const previousScene = useScene.getState()
+    const previousSelection = useViewer.getState().selection
+    const previousEditor = useEditor.getState()
+    const building = { id: 'building_pick', type: 'building', children: ['level_pick'] }
+    const level = {
+      id: 'level_pick',
+      type: 'level',
+      level: 0,
+      parentId: building.id,
+      children: ['wall_pick'],
+    }
+    const wall = { id: 'wall_pick', type: 'wall', parentId: level.id }
+    const shelf = { id: 'shelf_pick', type: 'shelf', parentId: wall.id }
+    const elevator = { id: 'elevator_pick', type: 'elevator', parentId: building.id }
+    const nodes = Object.fromEntries(
+      [building, level, wall, shelf, elevator].map((node) => [node.id, node]),
+    ) as Record<string, AnyNode>
+    try {
+      useScene.setState({ nodes: nodes as never, rootNodeIds: [building.id as never] })
+      for (const hit of [wall, shelf, elevator]) {
+        useEditor.getState().setPhase('site')
+        useEditor.getState().armToolMode({ mode: 'select' })
+        const node = nodes[hit.id]!
+        expect(resolveCanvasBuildingId(node, nodes)).toBe(building.id as never)
+        expect(enterBuildingFromCanvas(node)).toBe(true)
+        expect(useEditor.getState().phase).toBe('building')
+        expect(useViewer.getState().selection).toMatchObject({
+          buildingId: building.id,
+          levelId: level.id,
+          selectedIds: [],
+        })
+        useViewer.getState().setSelection({ selectedIds: [wall.id as never] })
+        expect(enterBuildingFromCanvas(node)).toBe(false)
+        expect(useViewer.getState().selection.selectedIds).toEqual([wall.id])
+      }
+      useEditor.getState().setPhase('site')
+      useEditor.getState().armToolMode({ mode: 'build', tool: 'item' })
+      expect(enterBuildingFromCanvas(nodes[wall.id]!)).toBe(false)
+      expect(useEditor.getState().phase).toBe('site')
+    } finally {
+      useScene.setState(previousScene)
+      useViewer.setState({ selection: previousSelection })
+      useEditor.setState(previousEditor)
+    }
+  })
+
+  test('a 2D plan click from Site on a wall picks the whole building; bare ground stays in Site', () => {
+    const previousScene = useScene.getState()
+    const previousSelection = useViewer.getState().selection
+    const previousEditor = useEditor.getState()
+    const building = { id: 'building_plan', type: 'building', children: ['level_plan'] }
+    const level = { id: 'level_plan', type: 'level', level: 0, parentId: building.id, children: [] }
+    const wall = { id: 'wall_plan', type: 'wall', parentId: level.id }
+    const spawn = { id: 'spawn_plan', type: 'spawn', parentId: level.id }
+    const ground = { id: 'surface-material_plan', type: 'surface-material', parentId: 'site_plan' }
+    const siteFence = { id: 'fence_plan', type: 'fence', parentId: 'site_plan' }
+    const nodes = Object.fromEntries(
+      [building, level, wall, spawn, ground, siteFence].map((node) => [node.id, node]),
+    ) as Record<string, AnyNode>
+    try {
+      useScene.setState({ nodes: nodes as never, rootNodeIds: [building.id as never] })
+      useViewer.getState().setSelection({ buildingId: null })
+      useEditor.getState().setPhase('site')
+      useEditor.getState().armToolMode({ mode: 'select' })
+      for (const hit of [null, 'missing_plan', ground.id, siteFence.id]) {
+        expect(enterBuildingFromPlanHit(hit)).toBe(false)
+        expect(useEditor.getState().phase).toBe('site')
+      }
+      expect(enterBuildingFromPlanHit(wall.id)).toBe(true)
+      expect(useEditor.getState().phase).toBe('building')
+      expect(useViewer.getState().selection).toMatchObject({
+        buildingId: building.id,
+        selectedIds: [],
+      })
+      // Inside the building the same hit is an ordinary selection again.
+      expect(enterBuildingFromPlanHit(wall.id)).toBe(false)
+      useEditor.getState().setPhase('site')
+      expect(enterBuildingFromPlanHit(spawn.id)).toBe(true)
+      expect(useViewer.getState().selection).toMatchObject({
+        buildingId: building.id,
+        selectedIds: [],
+      })
+    } finally {
+      useScene.setState(previousScene)
+      useViewer.setState({ selection: previousSelection })
+      useEditor.setState(previousEditor)
+    }
+  })
+})
+
 function registerTestDefinition(kind: string, overrides: Record<string, unknown> = {}) {
   if (nodeRegistry.has(kind)) return
   registerNode({
@@ -69,30 +164,50 @@ describe('resolveSelectedIdsForNodeClick', () => {
 })
 
 describe('emitCanvasNodeSelection', () => {
-  test('publishes the accepted canvas node once', () => {
+  // Plugins (the WebXR plugin) listen for canvas selections on this event.
+  test('a canvas node click publishes the node once', () => {
     const node = { id: 'wall_1', type: 'wall' } as unknown as AnyNode
     const received: AnyNode[] = []
     const onSelection = (selectedNode: AnyNode) => received.push(selectedNode)
     emitter.on('selection:canvas-node-click', onSelection)
-
-    emitCanvasNodeSelection(node)
-
-    emitter.off('selection:canvas-node-click', onSelection)
+    try {
+      emitCanvasNodeSelection(node)
+    } finally {
+      emitter.off('selection:canvas-node-click', onSelection)
+    }
     expect(received).toEqual([node])
   })
 
-  test('deletes an accepted floorplan node when Delete mode is active', () => {
-    const node = BlockNode.parse({ id: 'block_floorplan-delete-target' })
+  test('in Delete mode the click deletes the node and publishes nothing', () => {
+    const node = BlockNode.parse({ id: 'block_canvas-delete-target' })
     const previousToolMode = useEditor.getState().toolMode
     const previousScene = useScene.getState()
     const previousSelection = useViewer.getState().selection
     const received: AnyNode[] = []
-    const listener = (selectedNode: AnyNode) => received.push(selectedNode)
+    const onSelection = (selectedNode: AnyNode) => received.push(selectedNode)
+    emitter.on('selection:canvas-node-click', onSelection)
+    try {
+      useEditor.getState().armToolMode({ mode: 'delete' })
+      useScene.setState({ nodes: { [node.id]: node }, rootNodeIds: [node.id], readOnly: false })
+      emitCanvasNodeSelection(node)
+      expect(useScene.getState().nodes[node.id]).toBeUndefined()
+      expect(received).toEqual([])
+    } finally {
+      emitter.off('selection:canvas-node-click', onSelection)
+      useEditor.getState().armToolMode(previousToolMode)
+      useScene.setState(previousScene)
+      useViewer.setState({ selection: previousSelection })
+    }
+  })
+})
 
-    emitter.on('selection:canvas-node-click', listener)
+describe('deleteNodeFromCanvas', () => {
+  test('deletes the clicked plan node and clears the selection', () => {
+    const node = BlockNode.parse({ id: 'block_floorplan-delete-target' })
+    const previousScene = useScene.getState()
+    const previousSelection = useViewer.getState().selection
 
     try {
-      useEditor.getState().armToolMode({ mode: 'delete' })
       useScene.setState({
         nodes: { [node.id]: node },
         rootNodeIds: [node.id],
@@ -100,27 +215,22 @@ describe('emitCanvasNodeSelection', () => {
       })
       useViewer.getState().setSelection({ selectedIds: [node.id] })
 
-      emitCanvasNodeSelection(node)
+      deleteNodeFromCanvas(node)
 
       expect(useScene.getState().nodes[node.id]).toBeUndefined()
       expect(useViewer.getState().selection.selectedIds).toEqual([])
-      expect(received).toEqual([])
     } finally {
-      emitter.off('selection:canvas-node-click', listener)
-      useEditor.getState().armToolMode(previousToolMode)
       useScene.setState(previousScene)
       useViewer.setState({ selection: previousSelection })
     }
   })
 
-  test('preserves a floorplan node and its selection when the scene is read-only', () => {
+  test('preserves a plan node and its selection when the scene is read-only', () => {
     const node = BlockNode.parse({ id: 'block_floorplan-read-only-target' })
-    const previousToolMode = useEditor.getState().toolMode
     const previousScene = useScene.getState()
     const previousSelection = useViewer.getState().selection
 
     try {
-      useEditor.getState().armToolMode({ mode: 'delete' })
       useScene.setState({
         nodes: { [node.id]: node },
         rootNodeIds: [node.id],
@@ -128,12 +238,11 @@ describe('emitCanvasNodeSelection', () => {
       })
       useViewer.getState().setSelection({ selectedIds: [node.id] })
 
-      emitCanvasNodeSelection(node)
+      deleteNodeFromCanvas(node)
 
       expect(useScene.getState().nodes[node.id]).toEqual(node)
       expect(useViewer.getState().selection.selectedIds).toEqual([node.id])
     } finally {
-      useEditor.getState().armToolMode(previousToolMode)
       useScene.setState(previousScene)
       useViewer.setState({ selection: previousSelection })
     }
@@ -167,31 +276,6 @@ describe('selectionModifiersFromEvent', () => {
   })
 })
 
-describe('resolveNodeSelectionTarget', () => {
-  test('routes furniture items to furnish', () => {
-    const node = {
-      id: 'item_1',
-      type: 'item',
-      asset: { category: 'furniture' },
-    } as unknown as AnyNode
-
-    expect(resolveNodeSelectionTarget(node)).toEqual({ phase: 'furnish' })
-  })
-
-  test('routes door and window catalog items to structure', () => {
-    const node = {
-      id: 'item_1',
-      type: 'item',
-      asset: { category: 'door' },
-    } as unknown as AnyNode
-
-    expect(resolveNodeSelectionTarget(node)).toEqual({
-      phase: 'structure',
-      structureLayer: 'elements',
-    })
-  })
-})
-
 describe('resolveCanvasSelectionNode', () => {
   // Mirrors the cabinet-module setup: modules proxy to their run for grouped
   // move / rotate, but declare `selectionProxy.bypassDirectPick` so a direct

package/src/lib/selection-routing.ts

@@ -1,8 +1,8 @@
 import {
   type AnyNode,
   type AnyNodeId,
+  type BuildingNode,
   emitter,
-  type ItemNode,
   nodeRegistry,
   resolveSelectionProxyId,
   useScene,
@@ -11,6 +11,38 @@ import { useViewer } from '@pascal-app/viewer'
 import useEditor from '../store/use-editor'
 import { emitDeleteSFX } from './sfx-bus'
 
+export function resolveCanvasBuildingId(
+  node: AnyNode,
+  nodes: Record<string, AnyNode>,
+): BuildingNode['id'] | null {
+  const visited = new Set<string>()
+  let current: AnyNode | undefined = node
+  while (current && !visited.has(current.id)) {
+    if (current.type === 'building') return current.id
+    visited.add(current.id)
+    current = current.parentId ? nodes[current.parentId] : undefined
+  }
+  return null
+}
+
+export function enterBuildingFromCanvas(node: AnyNode): boolean {
+  if (useEditor.getState().phase !== 'site' || useEditor.getState().mode !== 'select') return false
+  const buildingId = resolveCanvasBuildingId(node, useScene.getState().nodes)
+  if (!buildingId) return false
+  useViewer.getState().setSelection({ buildingId, selectedIds: [] })
+  useEditor.getState().setPhase('building')
+  return true
+}
+
+/**
+ * A floor-plan click from site, entry or background hit alike: a hit on any of
+ * a building's elements picks that building and goes inside, as in 3D.
+ */
+export function enterBuildingFromPlanHit(hitId: string | null): boolean {
+  const node = hitId ? useScene.getState().nodes[hitId as AnyNodeId] : undefined
+  return node ? enterBuildingFromCanvas(node) : false
+}
+
 export type SelectionModifierKeys = {
   meta: boolean
   ctrl: boolean
@@ -19,29 +51,33 @@ export type SelectionModifierKeys = {
   alt: boolean
 }
 
-export type NodeSelectionTarget = {
-  phase: 'site' | 'structure' | 'furnish'
-  structureLayer?: 'zones' | 'elements'
-}
-
+/** A Delete-mode click on a plan entry: the sledgehammer, not a selection. */
+/**
+ * A canvas click (2D or 3D) selected `node`: publish it on
+ * `selection:canvas-node-click`, which plugins listen for. In Delete mode the
+ * click deletes the node instead.
+ */
 export function emitCanvasNodeSelection(node: AnyNode): void {
   if (useEditor.getState().mode === 'delete') {
-    const scene = useScene.getState()
-    if (scene.readOnly) return
-
-    emitDeleteSFX(node.type)
-    scene.deleteNode(node.id as AnyNodeId)
-    if (node.parentId) scene.dirtyNodes.add(node.parentId as AnyNodeId)
-    useViewer.getState().setSelection({ selectedIds: [] })
-    if (useViewer.getState().hoveredId === node.id) {
-      useViewer.setState({ hoveredId: null })
-    }
+    deleteNodeFromCanvas(node)
     return
   }
-
   emitter.emit('selection:canvas-node-click', node)
 }
 
+export function deleteNodeFromCanvas(node: AnyNode): void {
+  const scene = useScene.getState()
+  if (scene.readOnly) return
+
+  emitDeleteSFX(node.type)
+  scene.deleteNode(node.id as AnyNodeId)
+  if (node.parentId) scene.dirtyNodes.add(node.parentId as AnyNodeId)
+  useViewer.getState().setSelection({ selectedIds: [] })
+  if (useViewer.getState().hoveredId === node.id) {
+    useViewer.setState({ hoveredId: null })
+  }
+}
+
 function shouldBypassSelectionProxy(node: AnyNode, target: AnyNode): boolean {
   if (node.id === target.id) return false
   // Kind-declared bypass (`def.selectionProxy.bypassDirectPick`): the kind
@@ -62,7 +98,7 @@ export function resolveCanvasSelectionNode({
   const proxiedTarget = nodes[resolveSelectionProxyId(node, nodes)] ?? node
   let target = shouldBypassSelectionProxy(node, proxiedTarget) ? node : proxiedTarget
   const parentFrame = nodeRegistry.get(target.type)?.capabilities?.movable?.parentFrame
-  if (parentFrame) {
+  if (parentFrame && !parentFrame.independent) {
     const parent = parentFrame.resolveParent(target, nodes as Readonly<Record<string, AnyNode>>)
     if (parent && selectedIds.length === 1 && selectedIds[0] === parent.id) {
       target = parent
@@ -154,60 +190,3 @@ export function shouldPreserveSelectedRoofHostTarget({
     selectedIds[0] === node.id
   )
 }
-
-export function resolveNodeSelectionTarget(node: AnyNode): NodeSelectionTarget | null {
-  if (node.type === 'building') {
-    return { phase: 'site' }
-  }
-
-  if (node.type === 'zone') {
-    return {
-      phase: 'structure',
-      structureLayer: 'zones',
-    }
-  }
-
-  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 === 'wall' ||
-    node.type === 'fence' ||
-    node.type === 'column' ||
-    node.type === 'elevator' ||
-    node.type === 'slab' ||
-    node.type === 'ceiling' ||
-    node.type === 'roof' ||
-    node.type === 'roof-segment' ||
-    node.type === 'stair' ||
-    node.type === 'stair-segment' ||
-    node.type === 'spawn' ||
-    node.type === 'window' ||
-    node.type === 'door'
-  ) {
-    return {
-      phase: 'structure',
-      structureLayer: 'elements',
-    }
-  }
-
-  const def = nodeRegistry.get(node.type)
-  if (!def) return null
-
-  if (def.category === 'furnish') {
-    return { phase: 'furnish' }
-  }
-
-  return {
-    phase: 'structure',
-    structureLayer: 'elements',
-  }
-}