@pascal-app/editor 0.8.0 → 0.9.2

package/src/components/tools/elevator/move-elevator-tool.tsx

@@ -0,0 +1,263 @@
+import {
+  type AnyNodeId,
+  type BuildingNode,
+  type ElevatorNode,
+  ElevatorNode as ElevatorNodeSchema,
+  emitter,
+  type GridEvent,
+  type LevelNode,
+  pauseSceneHistory,
+  resumeSceneHistory,
+  sceneRegistry,
+  useLiveTransforms,
+  useScene,
+} from '@pascal-app/core'
+import { useCallback, useEffect, useRef, useState } from 'react'
+import { markToolCancelConsumed } from '../../../hooks/use-keyboard'
+import { resolveElevatorSupportY } from '../../../lib/elevator-support'
+import { consumePlacementDragRelease } from '../../../lib/placement-drag-release'
+import { sfxEmitter } from '../../../lib/sfx-bus'
+import useEditor from '../../../store/use-editor'
+import { CursorSphere } from '../shared/cursor-sphere'
+
+function stripMoveMetadata(metadata: ElevatorNode['metadata']) {
+  if (typeof metadata !== 'object' || metadata === null || Array.isArray(metadata)) {
+    return metadata
+  }
+
+  const nextMeta = { ...(metadata as Record<string, unknown>) }
+  delete nextMeta.isNew
+  delete nextMeta.isTransient
+  return nextMeta as ElevatorNode['metadata']
+}
+
+export function MoveElevatorTool({
+  node: movingNode,
+  onCommitted,
+}: {
+  node: ElevatorNode
+  onCommitted?: (nodeId: AnyNodeId) => void
+}) {
+  const onCommittedRef = useRef(onCommitted)
+  const historyPausedRef = useRef(false)
+  const previousGridPosRef = useRef<[number, number] | null>(null)
+  const dragAnchorRef = useRef<[number, number] | null>(null)
+  const previewPositionRef = useRef<ElevatorNode['position']>([
+    movingNode.position[0],
+    movingNode.position[1],
+    movingNode.position[2],
+  ])
+  const [cursorPosition, setCursorPosition] = useState<[number, number, number]>(() => [
+    movingNode.position[0],
+    movingNode.position[1],
+    movingNode.position[2],
+  ])
+
+  const exitMoveMode = useCallback(() => {
+    useEditor.getState().setMovingNode(null)
+  }, [])
+
+  useEffect(() => {
+    onCommittedRef.current = onCommitted
+  }, [onCommitted])
+
+  useEffect(() => {
+    const pauseHistory = () => {
+      const temporal = useScene.temporal.getState()
+      if (historyPausedRef.current || !temporal.isTracking) return
+      pauseSceneHistory(useScene)
+      historyPausedRef.current = true
+    }
+    const resumeHistory = () => {
+      if (!historyPausedRef.current) return
+      resumeSceneHistory(useScene)
+      historyPausedRef.current = false
+    }
+
+    pauseHistory()
+    dragAnchorRef.current = null
+    previousGridPosRef.current = null
+    const movingNodeId = (movingNode as { id?: ElevatorNode['id'] }).id
+
+    const meta =
+      typeof movingNode.metadata === 'object' && movingNode.metadata !== null
+        ? (movingNode.metadata as Record<string, unknown>)
+        : {}
+    const isNew = !!meta.isNew
+    const committedMeta = stripMoveMetadata(movingNode.metadata)
+    const original = {
+      position: [...movingNode.position] as ElevatorNode['position'],
+      rotation: movingNode.rotation,
+      metadata: movingNode.metadata,
+    }
+
+    let wasCommitted = false
+    let wasCancelled = false
+    let pendingRotation = movingNode.rotation
+    const supportBuildingId = movingNode.parentId as BuildingNode['id'] | null | undefined
+    const supportLevelId = (movingNode.fromLevelId ?? movingNode.defaultLevelId) as
+      | LevelNode['id']
+      | null
+
+    const applyPreview = (
+      position: ElevatorNode['position'],
+      rotation: ElevatorNode['rotation'],
+    ) => {
+      if (movingNodeId) {
+        useLiveTransforms.getState().set(movingNodeId, { position, rotation })
+      }
+
+      const object = movingNodeId ? sceneRegistry.nodes.get(movingNodeId) : null
+      if (object) {
+        object.position.set(position[0], position[1], position[2])
+        object.rotation.y = rotation
+      }
+    }
+
+    const resetObject = (
+      position: ElevatorNode['position'],
+      rotation: ElevatorNode['rotation'],
+    ) => {
+      const object = movingNodeId ? sceneRegistry.nodes.get(movingNodeId) : null
+      if (object) {
+        object.position.set(position[0], position[1], position[2])
+        object.rotation.y = rotation
+      }
+    }
+
+    const clearPreview = () => {
+      if (movingNodeId) {
+        useLiveTransforms.getState().clear(movingNodeId)
+      }
+    }
+
+    const onGridMove = (event: GridEvent) => {
+      const bypassSnap = event.nativeEvent?.shiftKey === true
+      const rawX = bypassSnap ? event.localPosition[0] : Math.round(event.localPosition[0] * 2) / 2
+      const rawZ = bypassSnap ? event.localPosition[2] : Math.round(event.localPosition[2] * 2) / 2
+      const anchor = dragAnchorRef.current ?? [rawX, rawZ]
+      dragAnchorRef.current = anchor
+      const gridX = movingNode.position[0] + (rawX - anchor[0])
+      const gridZ = movingNode.position[2] + (rawZ - anchor[1])
+      const supportY = resolveElevatorSupportY({
+        buildingId: supportBuildingId,
+        preferredLevelId: supportLevelId,
+        x: gridX,
+        z: gridZ,
+      })
+
+      if (
+        !bypassSnap &&
+        previousGridPosRef.current &&
+        (gridX !== previousGridPosRef.current[0] || gridZ !== previousGridPosRef.current[1])
+      ) {
+        sfxEmitter.emit('sfx:grid-snap')
+      }
+
+      previousGridPosRef.current = [gridX, gridZ]
+      setCursorPosition([gridX, supportY, gridZ])
+      previewPositionRef.current = [gridX, supportY, gridZ]
+      applyPreview(previewPositionRef.current, pendingRotation)
+    }
+
+    const onGridClick = (event: GridEvent) => {
+      if (wasCommitted) return
+      const nextPosition: ElevatorNode['position'] = [...previewPositionRef.current]
+
+      wasCommitted = true
+      clearPreview()
+      resumeHistory()
+      if (movingNodeId && useScene.getState().nodes[movingNodeId as AnyNodeId]) {
+        useScene.getState().updateNode(movingNodeId as AnyNodeId, {
+          position: nextPosition,
+          rotation: pendingRotation,
+          metadata: committedMeta,
+        })
+        onCommittedRef.current?.(movingNodeId as AnyNodeId)
+      } else if (movingNode.parentId) {
+        const elevator = ElevatorNodeSchema.parse({
+          ...movingNode,
+          id: undefined,
+          position: nextPosition,
+          rotation: pendingRotation,
+          metadata: committedMeta,
+        })
+        useScene.getState().createNode(elevator, movingNode.parentId as AnyNodeId)
+        onCommittedRef.current?.(elevator.id as AnyNodeId)
+      }
+
+      sfxEmitter.emit('sfx:item-place')
+      exitMoveMode()
+      event.nativeEvent?.stopPropagation?.()
+    }
+
+    const onPlacementDragPointerUp = (event: PointerEvent) => {
+      if (!consumePlacementDragRelease(event)) return
+      onGridClick({ nativeEvent: event } as unknown as GridEvent)
+    }
+
+    const onCancel = () => {
+      wasCancelled = true
+      clearPreview()
+      if (isNew && movingNodeId) {
+        useScene.getState().deleteNode(movingNodeId as AnyNodeId)
+      } else {
+        if (movingNodeId) {
+          useScene.getState().updateNode(movingNodeId as AnyNodeId, {
+            position: original.position,
+            rotation: original.rotation,
+            metadata: original.metadata,
+          })
+        }
+      }
+      resetObject(original.position, original.rotation)
+      resumeHistory()
+      markToolCancelConsumed()
+      exitMoveMode()
+    }
+
+    const onKeyDown = (event: KeyboardEvent) => {
+      if (event.target instanceof HTMLInputElement || event.target instanceof HTMLTextAreaElement) {
+        return
+      }
+
+      const ROTATION_STEP = Math.PI / 4
+      let rotationDelta = 0
+      if (event.key === 'r' || event.key === 'R') rotationDelta = ROTATION_STEP
+      else if (event.key === 't' || event.key === 'T') rotationDelta = -ROTATION_STEP
+
+      if (rotationDelta !== 0) {
+        event.preventDefault()
+        sfxEmitter.emit('sfx:item-rotate')
+        pendingRotation += rotationDelta
+        applyPreview(previewPositionRef.current, pendingRotation)
+      }
+    }
+
+    emitter.on('grid:move', onGridMove)
+    emitter.on('grid:click', onGridClick)
+    emitter.on('tool:cancel', onCancel)
+    window.addEventListener('keydown', onKeyDown)
+    window.addEventListener('pointerup', onPlacementDragPointerUp)
+
+    return () => {
+      clearPreview()
+      if (!(wasCommitted || wasCancelled || isNew) && movingNodeId) {
+        useScene.getState().updateNode(movingNodeId as AnyNodeId, {
+          position: original.position,
+          rotation: original.rotation,
+          metadata: original.metadata,
+        })
+        resetObject(original.position, original.rotation)
+      }
+      resumeHistory()
+      emitter.off('grid:move', onGridMove)
+      emitter.off('grid:click', onGridClick)
+      emitter.off('tool:cancel', onCancel)
+      window.removeEventListener('keydown', onKeyDown)
+      window.removeEventListener('pointerup', onPlacementDragPointerUp)
+    }
+  }, [movingNode, exitMoveMode])
+
+  return <CursorSphere position={cursorPosition} showTooltip={false} />
+}

package/src/components/tools/fence/fence-drafting.ts

@@ -1,25 +1,30 @@
 import {
+  DEFAULT_ANGLE_STEP,
   FenceNode,
+  getTwoPointFenceCurveTangents,
   getWallCurveFrameAt,
   getWallCurveLength,
   isCurvedWall,
+  snapPointAlongAngleRay,
   useScene,
   type WallNode,
 } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
 import { sfxEmitter } from '../../../lib/sfx-bus'
+import useEditor from '../../../store/use-editor'
 import {
   findWallSnapTarget,
-  getWallAngleSnapStep,
-  getWallGridStep,
-  isWallLongEnough,
-  snapPointTo45Degrees,
+  getSegmentGridStep,
+  isSegmentLongEnough,
   snapPointToGrid,
   type WallPlanPoint,
 } from '../wall/wall-drafting'
 
 export type FencePlanPoint = WallPlanPoint
 
+const FENCE_CORNER_SNAP_RADIUS = 0.28
+const FENCE_SPAN_SNAP_RADIUS = 0.16
+
 type SegmentNode = {
   start: FencePlanPoint
   end: FencePlanPoint
@@ -57,46 +62,68 @@ function findFenceSnapTarget(
   fences: FenceNode[],
   ignoreFenceIds: string[] = [],
 ): FencePlanPoint | null {
-  const radiusSquared = 0.35 ** 2
+  const cornerRadiusSquared = FENCE_CORNER_SNAP_RADIUS ** 2
+  const spanRadiusSquared = FENCE_SPAN_SNAP_RADIUS ** 2
   const ignoredFenceIds = new Set(ignoreFenceIds)
-  let bestTarget: FencePlanPoint | null = null
-  let bestDistanceSquared = Number.POSITIVE_INFINITY
+  let bestCornerTarget: FencePlanPoint | null = null
+  let bestCornerDistanceSquared = Number.POSITIVE_INFINITY
+  let bestSpanTarget: FencePlanPoint | null = null
+  let bestSpanDistanceSquared = Number.POSITIVE_INFINITY
 
   for (const fence of fences) {
     if (ignoredFenceIds.has(fence.id)) {
       continue
     }
 
-    const candidates: Array<FencePlanPoint | null> = [fence.start, fence.end]
+    for (const candidate of [fence.start, fence.end]) {
+      const candidateDistanceSquared = distanceSquared(point, candidate)
+      if (
+        candidateDistanceSquared > cornerRadiusSquared ||
+        candidateDistanceSquared >= bestCornerDistanceSquared
+      ) {
+        continue
+      }
+
+      bestCornerTarget = candidate
+      bestCornerDistanceSquared = candidateDistanceSquared
+    }
+
     if (isCurvedWall(fence)) {
       const sampleCount = Math.max(8, Math.ceil(getWallCurveLength(fence) / 0.3))
-      for (let index = 0; index <= sampleCount; index += 1) {
+      for (let index = 1; index < sampleCount; index += 1) {
         const frame = getWallCurveFrameAt(fence, index / sampleCount)
-        candidates.push([frame.point.x, frame.point.y])
+        const candidate: FencePlanPoint = [frame.point.x, frame.point.y]
+        const candidateDistanceSquared = distanceSquared(point, candidate)
+        if (
+          candidateDistanceSquared > spanRadiusSquared ||
+          candidateDistanceSquared >= bestSpanDistanceSquared
+        ) {
+          continue
+        }
+
+        bestSpanTarget = candidate
+        bestSpanDistanceSquared = candidateDistanceSquared
       }
     } else {
-      candidates.push(projectPointOntoSegment(point, fence))
-    }
-
-    for (const candidate of candidates) {
+      const candidate = projectPointOntoSegment(point, fence)
       if (!candidate) {
         continue
       }
 
       const candidateDistanceSquared = distanceSquared(point, candidate)
       if (
-        candidateDistanceSquared > radiusSquared ||
-        candidateDistanceSquared >= bestDistanceSquared
+        candidateDistanceSquared > spanRadiusSquared ||
+        candidateDistanceSquared >= bestSpanDistanceSquared
       ) {
         continue
       }
 
-      bestTarget = candidate
-      bestDistanceSquared = candidateDistanceSquared
+      bestSpanTarget = candidate
+      bestSpanDistanceSquared = candidateDistanceSquared
     }
   }
 
-  return bestTarget
+  return bestCornerTarget ?? bestSpanTarget
 }
 
 export function snapFenceDraftPoint(args: {
@@ -106,16 +133,57 @@ export function snapFenceDraftPoint(args: {
   start?: FencePlanPoint
   angleSnap?: boolean
   ignoreFenceIds?: string[]
+  bypassSnap?: boolean
+  magnetic?: boolean
+  /** Override the grid step. */
+  step?: number
+  /**
+   * Optional grid-snap function. When provided, replaces the default
+   * local-axis snap — lets the 2D floor-plan keep snapping to the
+   * world XZ grid even when the building is rotated. Wall / fence
+   * endpoint snap precedence is preserved.
+   */
+  gridSnap?: (point: FencePlanPoint) => FencePlanPoint
 }): FencePlanPoint {
-  const { point, walls, fences, start, angleSnap = false, ignoreFenceIds } = args
-  const gridStep = getWallGridStep()
-  const angleStep = getWallAngleSnapStep(gridStep)
-  const basePoint =
+  const {
+    point,
+    walls,
+    fences,
+    start,
+    angleSnap = false,
+    ignoreFenceIds,
+    bypassSnap = false,
+    magnetic = true,
+    step,
+    gridSnap,
+  } = args
+  if (bypassSnap) return point
+
+  const gridStep = step ?? getSegmentGridStep()
+
+  // Magnetic endpoint snap must beat the angle lock, and the lock can pull
+  // the cursor far enough off an endpoint that probing the locked point
+  // would never engage — so under the lock, probe from the RAW cursor
+  // first (mirrors `snapWallDraftPointDetailed`'s special-point pre-pass).
+  if (start && angleSnap) {
+    const rawTarget =
+      magnetic &&
+      (findFenceSnapTarget(point, fences, ignoreFenceIds) ?? findWallSnapTarget(point, walls))
+    if (rawTarget) return rawTarget
+  }
+
+  // The angle path snaps the distance ALONG the 15° ray — a scalar, the
+  // same in world and local frames — so the `gridSnap` world-grid override
+  // only applies when the angle lock is off.
+  const basePoint: FencePlanPoint =
     start && angleSnap
-      ? snapPointTo45Degrees(start, point, gridStep, angleStep)
-      : snapPointToGrid(point, gridStep)
-  const fenceSnapTarget = findFenceSnapTarget(basePoint, fences, ignoreFenceIds)
+      ? [...snapPointAlongAngleRay(start, point, DEFAULT_ANGLE_STEP, gridStep)]
+      : gridSnap
+        ? gridSnap(point)
+        : snapPointToGrid(point, gridStep)
+  if (!magnetic) return basePoint
 
+  const fenceSnapTarget = findFenceSnapTarget(basePoint, fences, ignoreFenceIds)
   return fenceSnapTarget ?? findWallSnapTarget(basePoint, walls) ?? basePoint
 }
 
@@ -126,15 +194,61 @@ export function createFenceOnCurrentLevel(
   const currentLevelId = useViewer.getState().selection.levelId
   const { createNode, nodes } = useScene.getState()
 
-  if (!(currentLevelId && isWallLongEnough(start, end))) {
+  if (!(currentLevelId && isSegmentLongEnough(start, end))) {
+    return null
+  }
+
+  const fenceCount = Object.values(nodes).filter((node) => node.type === 'fence').length
+  // Build parameters seeded by a placed preset (height, style, post
+  // spacing, …) merge in first; `name`/`start`/`end` always win. The
+  // schema parse validates and drops anything unexpected.
+  const defaults = useEditor.getState().toolDefaults.fence ?? {}
+  const fence = FenceNode.parse({
+    ...defaults,
+    name: `Fence ${fenceCount + 1}`,
+    start,
+    end,
+  })
+
+  createNode(fence, currentLevelId)
+  sfxEmitter.emit('sfx:structure-build')
+
+  return fence
+}
+
+/**
+ * Commit a smooth spline fence from a list of drawn control points. The
+ * centerline becomes a Catmull-Rom curve through `path`; `start`/`end` are
+ * pinned to the first/last point so endpoint handles, bbox, and miter
+ * references stay valid. Requires >= 2 points spanning a usable distance.
+ */
+export function createSplineFenceOnCurrentLevel(
+  path: FencePlanPoint[],
+  tangents = getTwoPointFenceCurveTangents(path),
+): FenceNode | null {
+  const currentLevelId = useViewer.getState().selection.levelId
+  const { createNode, nodes } = useScene.getState()
+
+  if (!currentLevelId || path.length < 2) {
+    return null
+  }
+  const start = path[0]!
+  const end = path[path.length - 1]!
+  // A degenerate single-point-ish path (all clicks on one spot) is rejected
+  // the same way a too-short straight segment is.
+  if (!isSegmentLongEnough(start, end) && path.length < 3) {
     return null
   }
 
   const fenceCount = Object.values(nodes).filter((node) => node.type === 'fence').length
+  const defaults = useEditor.getState().toolDefaults.fence ?? {}
   const fence = FenceNode.parse({
+    ...defaults,
     name: `Fence ${fenceCount + 1}`,
     start,
     end,
+    path,
+    tangents,
   })
 
   createNode(fence, currentLevelId)

package/src/components/tools/item/move-tool.tsx

@@ -1,112 +1,52 @@
-import type {
-  BuildingNode,
-  CeilingNode,
-  ColumnNode,
-  DoorNode,
-  FenceNode,
-  ItemNode,
-  RoofNode,
-  RoofSegmentNode,
-  SlabNode,
-  SpawnNode,
-  StairNode,
-  StairSegmentNode,
-  WallNode,
-  WindowNode,
-} from '@pascal-app/core'
-import { Vector3 } from 'three'
-import { sfxEmitter } from '../../../lib/sfx-bus'
-import useEditor from '../../../store/use-editor'
-import { MoveBuildingContent } from '../building/move-building-tool'
-import { MoveCeilingTool } from '../ceiling/move-ceiling-tool'
-import { MoveColumnTool } from '../column/move-column-tool'
-import { MoveDoorTool } from '../door/move-door-tool'
-import { MoveFenceTool } from '../fence/move-fence-tool'
-import { MoveRoofTool } from '../roof/move-roof-tool'
-import { MoveSlabTool } from '../slab/move-slab-tool'
-import { MoveSpawnTool } from '../spawn/move-spawn-tool'
-import { MoveWallTool } from '../wall/move-wall-tool'
-import { MoveWindowTool } from '../window/move-window-tool'
-import type { PlacementState } from './placement-types'
-import { useDraftNode } from './use-draft-node'
-import { usePlacementCoordinator } from './use-placement-coordinator'
+import type { AnyNodeId, ElevatorNode, SpawnNode } from '@pascal-app/core'
+import { nodeRegistry } from '@pascal-app/core'
+import { Suspense } from 'react'
+import { useMovingNode } from '../../../store/use-interaction-scope'
+import { MoveElevatorTool } from '../elevator/move-elevator-tool'
+import { MoveRegistryNodeTool } from '../registry/move-registry-node-tool'
+import { getRegistryAffordanceTool } from '../shared/affordance-dispatch'
 
-function getInitialState(node: {
-  asset: { attachTo?: string }
-  parentId: string | null
-}): PlacementState {
-  const attachTo = node.asset.attachTo
-  if (attachTo === 'wall' || attachTo === 'wall-side') {
-    return { surface: 'wall', wallId: node.parentId, ceilingId: null, surfaceItemId: null }
-  }
-  if (attachTo === 'ceiling') {
-    return { surface: 'ceiling', wallId: null, ceilingId: node.parentId, surfaceItemId: null }
-  }
-  return { surface: 'floor', wallId: null, ceilingId: null, surfaceItemId: null }
-}
+/**
+ * MoveTool dispatcher. Routes to (in order):
+ *
+ *   1. `def.affordanceTools.move` — kind-owned move component, lazy-loaded
+ *      via `getRegistryAffordanceTool`. Covers generic movers
+ *      (slab / ceiling / wall / fence / column / item / door / window), the
+ *      bespoke roof / roof-segment / stair / stair-segment / building
+ *      movers, and the polyline / fitting ghost-placement movers
+ *      (duct-segment / duct-fitting). A kind that ships its own mover wins
+ *      even if it also declares `capabilities.movable` (duct-fitting keeps
+ *      `movable` for the inspector / hint readers but places via its ghost).
+ *   2. `MoveRegistryNodeTool` — generic translate-on-XZ for kinds that only
+ *      declare `capabilities.movable` (shelf, spawn, duct-terminal,
+ *      hvac-equipment, …).
+ *   3. `elevator` is the lone remaining legacy arm — its bespoke cab/shaft
+ *      mover hasn't been ported to a kind-owned affordance yet.
+ */
+export const MoveTool: React.FC<{
+  onNodeMoved?: (nodeId: AnyNodeId) => void
+  onSpawnMoved?: (nodeId: SpawnNode['id']) => void
+}> = ({ onNodeMoved }) => {
+  const movingNode = useMovingNode()
 
-function MoveItemContent({ movingNode }: { movingNode: ItemNode }) {
-  const draftNode = useDraftNode()
-
-  const meta =
-    typeof movingNode.metadata === 'object' && movingNode.metadata !== null
-      ? (movingNode.metadata as Record<string, unknown>)
-      : {}
-  const isNew = !!meta.isNew
+  if (!movingNode) return null
 
-  const cursor = usePlacementCoordinator({
-    asset: movingNode.asset,
-    draftNode,
-    // Duplicates start fresh in floor mode; wall/ceiling draft is created lazily by ensureDraft
-    initialState: isNew
-      ? { surface: 'floor', wallId: null, ceilingId: null, surfaceItemId: null }
-      : getInitialState(movingNode),
-    // Preserve the original item's scale so Y-position calculations use the correct height
-    defaultScale: isNew ? movingNode.scale : undefined,
-    initDraft: (gridPosition) => {
-      if (isNew) {
-        // Duplicate: use the same create() path as ItemTool so ghost rendering works correctly.
-        // Floor items get a draft immediately; wall/ceiling items are created lazily on surface entry.
-        gridPosition.copy(new Vector3(...movingNode.position))
-        if (!movingNode.asset.attachTo) {
-          draftNode.create(gridPosition, movingNode.asset, movingNode.rotation, movingNode.scale)
-        }
-      } else {
-        draftNode.adopt(movingNode)
-        gridPosition.copy(new Vector3(...movingNode.position))
-      }
-    },
-    onCommitted: () => {
-      sfxEmitter.emit('sfx:item-place')
-      useEditor.getState().setMovingNode(null)
-      return false
-    },
-    onCancel: () => {
-      draftNode.destroy()
-      useEditor.getState().setMovingNode(null)
-    },
-  })
+  const def = nodeRegistry.get(movingNode.type)
 
-  return <>{cursor}</>
-}
+  const RegistryMove = getRegistryAffordanceTool(movingNode.type, 'move')
+  if (RegistryMove) {
+    return (
+      <Suspense fallback={null}>
+        <RegistryMove node={movingNode} />
+      </Suspense>
+    )
+  }
 
-export const MoveTool: React.FC = () => {
-  const movingNode = useEditor((state) => state.movingNode)
+  if (def?.capabilities?.movable) {
+    return <MoveRegistryNodeTool node={movingNode} />
+  }
 
-  if (!movingNode) return null
-  if (movingNode.type === 'building')
-    return <MoveBuildingContent node={movingNode as BuildingNode} />
-  if (movingNode.type === 'door') return <MoveDoorTool node={movingNode as DoorNode} />
-  if (movingNode.type === 'window') return <MoveWindowTool node={movingNode as WindowNode} />
-  if (movingNode.type === 'ceiling') return <MoveCeilingTool node={movingNode as CeilingNode} />
-  if (movingNode.type === 'column') return <MoveColumnTool node={movingNode as ColumnNode} />
-  if (movingNode.type === 'slab') return <MoveSlabTool node={movingNode as SlabNode} />
-  if (movingNode.type === 'wall') return <MoveWallTool node={movingNode as WallNode} />
-  if (movingNode.type === 'fence') return <MoveFenceTool node={movingNode as FenceNode} />
-  if (movingNode.type === 'roof' || movingNode.type === 'roof-segment')
-    return <MoveRoofTool node={movingNode as RoofNode | RoofSegmentNode} />
-  if (movingNode.type === 'spawn') return <MoveSpawnTool node={movingNode as SpawnNode} />
-  if (movingNode.type === 'stair' || movingNode.type === 'stair-segment')
-    return <MoveRoofTool node={movingNode as StairNode | StairSegmentNode} />
-  return <MoveItemContent movingNode={movingNode as ItemNode} />
+  if (movingNode.type === 'elevator')
+    return <MoveElevatorTool node={movingNode as ElevatorNode} onCommitted={onNodeMoved} />
+  return null
 }

package/src/components/tools/item/placement-math.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, test } from 'bun:test'
+import { getDetachedAttachmentPreviewLift, stripTransient } from './placement-math'
+
+describe('stripTransient', () => {
+  test('removes placement-only metadata flags before commit', () => {
+    expect(stripTransient({ isNew: true, isTransient: true, label: 'copy' })).toEqual({
+      label: 'copy',
+    })
+  })
+})
+
+describe('getDetachedAttachmentPreviewLift', () => {
+  test('raises attach-only item previews while they are detached from their host', () => {
+    expect(getDetachedAttachmentPreviewLift('wall')).toBeGreaterThan(0)
+    expect(getDetachedAttachmentPreviewLift('wall-side')).toBeGreaterThan(0)
+    expect(getDetachedAttachmentPreviewLift('ceiling')).toBeGreaterThan(0)
+  })
+
+  test('keeps floor item previews on the floor', () => {
+    expect(getDetachedAttachmentPreviewLift(undefined)).toBe(0)
+  })
+})