@pascal-app/editor 1.0.1 → 1.0.4

package/src/components/tools/item/use-placement-coordinator.tsx

@@ -3,12 +3,16 @@ import {
   type AlignmentAnchor,
   type AnyNode,
   type AnyNodeId,
+  beginSceneHistoryPauseSession,
   type CeilingEvent,
+  canHostSurfaceChild,
   collectAlignmentAnchors,
   emitter,
   findLevelAncestorId,
   type GridEvent,
   getScaledDimensions,
+  getWallBodyCenterOffset,
+  getWallLocalFaceZ,
   type ItemEvent,
   movingFootprintAnchors,
   type NodeEvent,
@@ -24,7 +28,6 @@ import {
   useScene,
   useSpatialQuery,
   type WallEvent,
-  type WallNode,
 } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
 import { Html } from '@react-three/drei'
@@ -48,12 +51,13 @@ import {
 } from '../../../lib/active-placement-surface'
 import { EDITOR_LAYER } from '../../../lib/constants'
 import { formatLinearMeasurement } from '../../../lib/measurements'
+import { isFreshPlacementMetadata } from '../../../lib/placement-metadata'
 import { createMovementSfxTick } from '../../../lib/sfx/movement-tick'
 import { sfxEmitter } from '../../../lib/sfx-bus'
 import {
   surfaceAttachmentId,
   surfaceFramePose,
-  updateSurfaceNode,
+  updateSurfaceNode as writeSurfaceNode,
 } from '../../../lib/surface-attachment'
 import {
   projectAlignmentGuidesWorldToActiveBuildingLocal,
@@ -66,6 +70,7 @@ import useEditor, {
   isMagneticSnapActive,
 } from '../../../store/use-editor'
 import useFacingPose from '../../../store/use-facing-pose'
+import { getMovingNode } from '../../../store/use-interaction-scope'
 import usePlacementPreview from '../../../store/use-placement-preview'
 import {
   createItemSurfaceGridDispatch,
@@ -80,11 +85,13 @@ import {
 } from '../shared/placement-box-geometry'
 import {
   type PointerSupportSurface,
-  resolvePointerSupportElevation,
   resolvePointerSupportSurface,
 } from '../shared/pointer-support-cap'
 import { createShelfStickiness } from '../shared/shelf-stickiness'
-import { createSurfaceRejectionFeedback } from '../shared/surface-rejection'
+import {
+  createSurfaceEventOwnership,
+  createSurfaceRejectionFeedback,
+} from '../shared/surface-rejection'
 import { shouldCreateFloorDraft } from './draft-creation'
 import { commitFaceHostClick, resolveFaceHostPreviewCommit } from './face-host-commit'
 import {
@@ -112,7 +119,7 @@ import {
 } from './placement-strategies'
 import { resolveItemPlacementSurfaceNormal } from './placement-surface'
 import type { PlacementState, TransitionResult } from './placement-types'
-import type { DraftNodeHandle } from './use-draft-node'
+import { type DraftNodeHandle, type ItemCopy, pausedDraftWrite } from './use-draft-node'
 
 const DEFAULT_DIMENSIONS: [number, number, number] = [1, 1, 1]
 
@@ -258,20 +265,20 @@ basePlaneMaterial.opacityNode = radialOpacity
 
 export interface PlacementCoordinatorConfig {
   asset: AssetInput | null
+  /** Scale to use when lazily creating a draft (e.g. for wall/ceiling duplicates). Defaults to [1,1,1]. */
+  defaultScale?: [number, number, number]
   draftNode: DraftNodeHandle
   initDraft: (gridPosition: Vector3) => void
-  onCommitted: () => boolean
-  onCancel?: () => void
   initialState?: PlacementState
-  /** Scale to use when lazily creating a draft (e.g. for wall/ceiling duplicates). Defaults to [1,1,1]. */
-  defaultScale?: [number, number, number]
-  /** Painted slot overrides to seed onto a lazily-created draft (wall/ceiling
-   *  duplicates) so the duplicate keeps its materials. */
-  slots?: ItemNode['slots']
+  onCancel?: () => void
+  onCommitted: () => boolean
   /** Move-mode sessions keep the grabbed item offset from the first surface hit
    *  (floor / wall / ceiling / item-surface / shelf) instead of snapping the
    *  item's origin under the cursor. */
   preserveDragOffset?: boolean
+  /** The item a duplicate copies, for a lazily-created draft (wall/ceiling
+   *  duplicates) to keep its materials and collections. */
+  copied?: ItemCopy
 }
 
 export function usePlacementCoordinator(config: PlacementCoordinatorConfig): React.ReactNode {
@@ -524,7 +531,14 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
 
   useEffect(() => {
     if (!asset) return
-    useScene.temporal.getState().pause()
+    // History is paused only around the placement's own writes, never for the whole carry:
+    // the draft stays out of history snapshots (core's history-drafts), so writes others make
+    // mid-carry record as their own steps, with space detection. In split view the 2D move
+    // overlay co-owns the gesture (keyed by the moving node), and the drop's commitStep lifts
+    // its pause too.
+    const movingNodeId = getMovingNode()?.id
+    const updateSurfaceNode: typeof writeSurfaceNode = (...args) =>
+      pausedDraftWrite(() => writeSurfaceNode(...args))
 
     const validators = { canPlaceOnFloor, canPlaceOnWall, canPlaceOnCeiling }
 
@@ -597,13 +611,13 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
       wasAdopted: boolean,
       repeat: () => void,
     ) => {
+      if (!committedId) return
       if (configRef.current.onCommitted()) {
         repeat()
         return
       }
 
       useAlignmentGuides.getState().clear()
-      useScene.temporal.getState().resume()
       if (committedId) {
         useViewer.getState().setSelection({ selectedIds: [committedId as AnyNodeId] })
       }
@@ -626,12 +640,27 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
     ) => {
       const draftId = draftNode.current?.id ?? null
       const wasAdopted = draftNode.isAdopted
-      const finalId = draftNode.commit(nodeUpdate, options)
-      if (draftId) {
+      const drop = beginSceneHistoryPauseSession(useScene, { gesture: movingNodeId })
+      let finalId: string | null
+      try {
+        finalId = drop.commitStep(() =>
+          draftNode.commit(nodeUpdate, {
+            ...options,
+            onReject: (reason) => {
+              feedback.reject(reason)
+              edgeMaterial.color.setHex(0xef_44_44)
+              basePlaneMaterial.color.setHex(0xef_44_44)
+            },
+          }),
+        )
+      } finally {
+        drop.end()
+      }
+      if (finalId && draftId) {
         useLiveTransforms.getState().clear(draftId)
         useLiveNodeOverrides.getState().clearFields(draftId, faceHostClearFields(draftNode.current))
       }
-      return { committedId: finalId ?? draftId, wasAdopted }
+      return { committedId: finalId, wasAdopted }
     }
 
     const faceHostClearFields = (draft: ItemNode | null | undefined): Array<keyof ItemNode> => {
@@ -651,6 +680,7 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
     }
 
     const surfacePointer = createItemSurfacePointerArbitration()
+    const surfaceOwnership = createSurfaceEventOwnership()
     const revalidate = (): boolean => {
       const fits = checkCanPlace(getContext(), validators)
       if (
@@ -681,11 +711,22 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
       return placeable
     }
 
-    const surfaceContext = (event: NodeEvent<AnyNode>) => {
+    const surfaceContext = (event: NodeEvent<AnyNode>, generic = false) => {
       lastSurfaceEvent = event
       return {
         ...getContext(),
         onSurfaceReject: (reason: SurfaceRejectReason) => {
+          // A rejected generic acquisition leaves the paired pointer's floor route in charge.
+          if (
+            generic &&
+            placementState.current.surfaceItemId !== event.node.id &&
+            reason !== 'surface-cutout' &&
+            reason !== 'surface-occupied'
+          ) {
+            return
+          }
+          surfaceOwnership.claim(event.node.id, event.nativeEvent.nativeEvent ?? event.nativeEvent)
+          event.stopPropagation()
           if (
             (reason === 'footprint-outside-surface' ||
               reason === 'footprint-exceeds-host' ||
@@ -695,7 +736,9 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
           ) {
             feedback.clear()
             detachItemSurfaceToFloor(event as ItemEvent)
-            surfacePointer.hit(event.node.id, event.nativeEvent.nativeEvent ?? event.nativeEvent)
+            // A generic host exit yields positioning to this pointer's paired floor event.
+            if (!generic)
+              surfacePointer.hit(event.node.id, event.nativeEvent.nativeEvent ?? event.nativeEvent)
             return
           }
           feedback.reject(reason, event.nativeEvent.nativeEvent ?? event.nativeEvent)
@@ -746,6 +789,7 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
 
     const applyTransition = (result: TransitionResult, event?: NodeEvent<AnyNode>) => {
       if (event) {
+        surfaceOwnership.claim(event.node.id, event.nativeEvent.nativeEvent ?? event.nativeEvent)
         surfacePointer.hit(event.node.id, event.nativeEvent.nativeEvent ?? event.nativeEvent)
         tickSurfaceMovementSfx(result.cursorPosition)
       }
@@ -805,16 +849,15 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
         asset,
         initRotation,
         configRef.current.defaultScale,
-        configRef.current.slots,
+        configRef.current.copied,
       )
 
       const draft = draftNode.current
       if (draft) {
         Object.assign(draft, result.nodeUpdate)
         // One-time setup: put node in the right parent so it renders correctly
-        if (result.surfaceId !== undefined)
-          draftNode.updateSurface(result.nodeUpdate, result.surfaceId)
-        else updateSurfaceNode(draft.id, result.nodeUpdate)
+        if (result.surfaceId === undefined) updateSurfaceNode(draft.id, result.nodeUpdate)
+        else draftNode.updateSurface(result.nodeUpdate, result.surfaceId)
         disableDraftRaycastNow()
       }
 
@@ -1054,7 +1097,9 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
       // perspective-skewed along the ray whenever the plane sits on a
       // different storey than the pointed surface (the skew is what made
       // a drag over a deck-above-a-floor hop between the two surfaces).
-      const pointed = resolvePointerSupportSurface(cameraRef.current, event.position)
+      const pointed = resolvePointerSupportSurface(cameraRef.current, event.position, {
+        pointerRay: event.nativeEvent.ray,
+      })
       pointerSupportCapRef.current = pointed?.elevation ?? null
       pointerSupportSurfaceRef.current = pointed
       const surfaceEvent: GridEvent =
@@ -1247,7 +1292,7 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
           asset,
           currentRotation,
           configRef.current.defaultScale,
-          configRef.current.slots,
+          configRef.current.copied,
         )
         const previewBounds = expandBoundsToGrid(
           getFallbackPreviewBounds(draftNode.current, asset, asset.attachTo),
@@ -1398,12 +1443,13 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
           const rot = result.nodeUpdate?.rotation
           if (rot) mesh.rotation.y = rot[1]
 
-          // Push wall-side items out by half the parent wall's thickness
-          if (asset.attachTo === 'wall-side' && placementState.current.wallId) {
+          if (placementState.current.wallId) {
             const parentWall = useScene.getState().nodes[placementState.current.wallId as AnyNodeId]
             if (parentWall?.type === 'wall') {
-              const wallThickness = (parentWall as WallNode).thickness ?? 0.1
-              mesh.position.z = (wallThickness / 2) * (draft.side === 'front' ? 1 : -1)
+              mesh.position.z =
+                asset.attachTo === 'wall-side'
+                  ? getWallLocalFaceZ(parentWall, draft.side === 'front' ? 'a' : 'b')
+                  : draft.position[2] + getWallBodyCenterOffset(parentWall)
             }
           }
         }
@@ -1571,7 +1617,7 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
             const segment =
               useScene.getState().nodes[placementState.current.roofSegmentId as AnyNodeId]
             if (segment?.type === 'roof-segment') {
-              mesh.position.z = (segment.wallThickness ?? 0.1) / 2
+              mesh.position.z = getWallLocalFaceZ({ thickness: segment.wallThickness ?? 0.1 }, 'a')
             }
           }
           const rot = result.nodeUpdate?.rotation
@@ -1611,10 +1657,12 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
         applyTransition(result)
         const draft = draftNode.current
         if (draft) {
-          useScene.getState().updateNode(draft.id, {
-            parentId: result.nodeUpdate.parentId as string,
-            roofSegmentId: undefined,
-          })
+          pausedDraftWrite(() =>
+            useScene.getState().updateNode(draft.id, {
+              parentId: result.nodeUpdate.parentId as string,
+              roofSegmentId: undefined,
+            }),
+          )
         }
       } else {
         // Create mode: destroy transient and reset state
@@ -1729,9 +1777,11 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
       }
       if (draftNode.isAdopted) {
         applyTransition(result)
-        if (draft) useScene.getState().updateNode(draft.id, result.nodeUpdate)
+        if (draft)
+          pausedDraftWrite(() => useScene.getState().updateNode(draft.id, result.nodeUpdate))
       } else {
         draftNode.destroy()
+        gridPosition.current.set(...result.gridPosition)
         Object.assign(placementState.current, result.stateUpdate)
       }
     }
@@ -1744,11 +1794,10 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
       // Landing back on the floor: refresh the pointer surface cap from
       // this event's world hit so the first floor position already targets
       // the aimed-at surface (not a deck above it).
-      pointerSupportCapRef.current = resolvePointerSupportElevation(cameraRef.current, [
-        event.position[0],
-        event.position[1],
-        event.position[2],
-      ])
+      pointerSupportCapRef.current =
+        resolvePointerSupportSurface(cameraRef.current, event.position, {
+          pointerRay: event.nativeEvent.ray,
+        })?.elevation ?? null
       // Coming back from a host: forget the floor grab too, so the item
       // centers under the cursor instead of restoring the pre-drag offset —
       // and landing on the floor is "anchoring elsewhere", so a later return
@@ -1823,7 +1872,7 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
       revalidate()
     }
 
-    const onItemEnter = (event: NodeEvent<AnyNode>) => {
+    const onItemEnter = (event: NodeEvent<AnyNode>, generic = false) => {
       if (event.node.type === 'cabinet' && placementState.current.surfaceItemId === event.node.id) {
         onItemMove(event)
         return
@@ -1834,7 +1883,9 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
       }
       if (event.node.id === draftNode.current?.id) return
       has3DPointerDrivenMoveRef.current = true
-      const result = itemSurfaceStrategy.enter(surfaceContext(event), event)
+      // An authored object's underside takes ceiling items (a pendant under a vault).
+      if (enterFaceHost(event)) return
+      const result = itemSurfaceStrategy.enter(surfaceContext(event, generic), event)
       if (!result) return
       feedback.clear()
 
@@ -1849,12 +1900,23 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
       }
     }
 
-    const onItemMove = (event: NodeEvent<AnyNode>) => {
+    const onItemMove = (event: NodeEvent<AnyNode>, generic = false) => {
       if (event.node.id === draftNode.current?.id) return
+      if (
+        placementState.current.surface === 'block-face' &&
+        placementState.current.blockId === event.node.id
+      ) {
+        onFaceHostMove(event)
+        return
+      }
+      if (placementState.current.surface !== 'block-face' && enterFaceHost(event)) {
+        releaseCommit = () => onFaceHostClick(event)
+        return
+      }
       releaseCommit = () => onItemClick(event)
       has3DPointerDrivenMoveRef.current = true
       if (!cursorGroupRef.current) return
-      const ctx = surfaceContext(event)
+      const ctx = surfaceContext(event, generic)
       if (event.node.type === 'cabinet') {
         lastRawPos.current.set(...event.position)
         surfacePointer.hit(event.node.id, event.nativeEvent.nativeEvent ?? event.nativeEvent)
@@ -1879,6 +1941,8 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
           event,
         )
 
+        // An unclaimed generic mesh must let its owning ancestor receive the same hit.
+        if (generic && !enterResult) return
         event.stopPropagation()
         if (enterResult) {
           applyTransition(enterResult, event)
@@ -1892,7 +1956,7 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
       }
 
       if (!draftNode.current) {
-        const enterResult = itemSurfaceStrategy.enter(surfaceContext(event), event)
+        const enterResult = itemSurfaceStrategy.enter(surfaceContext(event, generic), event)
         if (!enterResult) return
         event.stopPropagation()
         ensureDraft(enterResult)
@@ -1900,9 +1964,9 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
       }
 
       const surfaceWorld =
-        ctx.state.surfaceItemId !== null
-          ? resolveHostSurfaceWorld(ctx.state.surfaceItemId, event.position)
-          : null
+        ctx.state.surfaceItemId === null
+          ? null
+          : resolveHostSurfaceWorld(ctx.state.surfaceItemId, event.position)
       const itemMoveEvent = surfaceWorld ? { ...event, position: surfaceWorld } : event
       lastRawPos.current.set(
         itemMoveEvent.position[0],
@@ -1949,6 +2013,13 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
     const onItemLeave = (event: NodeEvent<AnyNode>) => {
       if (event.node.type === 'cabinet') return
       if (event.node.id === draftNode.current?.id) return
+      if (
+        placementState.current.surface === 'block-face' &&
+        placementState.current.blockId === event.node.id
+      ) {
+        onFaceHostLeave(event)
+        return
+      }
       if (placementState.current.surface !== 'item-surface') return
 
       event.stopPropagation()
@@ -1964,6 +2035,13 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
     const onItemClick = (event: NodeEvent<AnyNode>) => {
       gridDispatch.flush()
       if (feedback.reason) return
+      if (
+        placementState.current.surface === 'block-face' &&
+        placementState.current.blockId === event.node.id
+      ) {
+        onFaceHostClick(event)
+        return
+      }
       // Click on the draft item itself. R3F dispatches click events to
       // the closest intersected mesh only — when the draft is hovering
       // on a host (shelf / table / etc.) the draft's mesh is *above*
@@ -2007,12 +2085,7 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
         // the host's own click event is blocked by the cursor preview.
         if (ctx.state.surface === 'item-surface' && ctx.state.surfaceItemId) {
           const hostNode = useScene.getState().nodes[ctx.state.surfaceItemId as AnyNodeId]
-          if (
-            hostNode &&
-            (hostNode.type === 'item' ||
-              hostNode.type === 'cabinet' ||
-              hostNode.type === 'procedural-item')
-          ) {
+          if (hostNode) {
             const synthetic = { ...event, node: hostNode } as ItemEvent
             const result = itemSurfaceStrategy.click(ctx, synthetic)
             if (result) {
@@ -2283,9 +2356,9 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
         return
       }
       const shelfWorld =
-        ctx.state.shelfId !== null
-          ? resolveHostSurfaceWorld(ctx.state.shelfId, event.position)
-          : null
+        ctx.state.shelfId === null
+          ? null
+          : resolveHostSurfaceWorld(ctx.state.shelfId, event.position)
       const shelfMoveEvent = shelfWorld ? { ...event, position: shelfWorld } : event
       const result = shelfSurfaceStrategy.move(ctx, shelfMoveEvent)
       if (!result) return
@@ -2386,7 +2459,49 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
         const currentRotation = draft.rotation
         // Round to the nearest 45° then step, matching the placed-item R/T.
         const newRotationY = steppedRotation(currentRotation[1] ?? 0, rotationDir)
-        draft.rotation = [currentRotation[0], newRotationY, currentRotation[2]]
+        const nextRotation: [number, number, number] = [
+          currentRotation[0],
+          newRotationY,
+          currentRotation[2],
+        ]
+        const surface = placementState.current.surface
+        const surfaceMesh =
+          surface === 'item-surface' && placementState.current.surfaceItemId
+            ? sceneRegistry.nodes.get(placementState.current.surfaceItemId)
+            : undefined
+        let surfacePosition: [number, number, number] | undefined
+        if (surfaceMesh) {
+          const localPos = surfaceMesh.worldToLocal(lastRawPos.current.clone())
+          const [dimX, , dimZ] = getScaledDimensions(draft)
+          const swapDims = Math.abs(Math.sin(newRotationY)) > 0.9
+          surfacePosition = [
+            snapToGrid(localPos.x, swapDims ? dimZ : dimX),
+            gridPosition.current.y,
+            snapToGrid(localPos.z, swapDims ? dimX : dimZ),
+          ]
+        }
+        if (surfaceAttachmentId(draft)) {
+          let occupied = false
+          checkCanPlace(
+            {
+              ...getContext(),
+              draftItem: { ...draft, rotation: nextRotation },
+              gridPosition: surfacePosition
+                ? new Vector3(...surfacePosition)
+                : gridPosition.current,
+              onSurfaceReject: (reason) => {
+                occupied = reason === 'surface-occupied'
+              },
+            },
+            validators,
+          )
+          if (occupied) {
+            feedback.reject('surface-occupied')
+            revalidate()
+            return
+          }
+        }
+        draft.rotation = nextRotation
 
         // Rotate the building-local cursor by the same delta as the host-local
         // draft. This preserves the host's composed yaw for items resting on a
@@ -2398,7 +2513,6 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
         if (mesh) mesh.rotation.y = newRotationY
 
         // Re-snap position immediately with updated rotation (dimX/dimZ may swap at 90°)
-        const surface = placementState.current.surface
         if (surface === 'floor' || surface === 'ceiling') {
           const dims = getScaledDimensions(draft)
           const [dimX, , dimZ] = dims
@@ -2428,15 +2542,8 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
             }
           }
         } else if (surface === 'item-surface' && placementState.current.surfaceItemId) {
-          const surfaceMesh = sceneRegistry.nodes.get(placementState.current.surfaceItemId)
-          if (surfaceMesh) {
-            const localPos = surfaceMesh.worldToLocal(lastRawPos.current.clone())
-            const dims = getScaledDimensions(draft)
-            const [dimX, , dimZ] = dims
-            const swapDims = Math.abs(Math.sin(newRotationY)) > 0.9
-            const x = snapToGrid(localPos.x, swapDims ? dimZ : dimX)
-            const z = snapToGrid(localPos.z, swapDims ? dimX : dimZ)
-            const y = gridPosition.current.y
+          if (surfaceMesh && surfacePosition) {
+            const [x, y, z] = surfacePosition
             gridPosition.current.set(x, y, z)
             draft.position = [x, y, z]
             const worldSnapped = surfaceMesh.localToWorld(new Vector3(x, y, z))
@@ -2553,7 +2660,7 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
       if (event.button !== 2) return
       const down = rightDown
       rightDown = null
-      if (!down || !configRef.current.onCancel) return
+      if (!(down && configRef.current.onCancel)) return
       const movedSq = (event.clientX - down.x) ** 2 + (event.clientY - down.y) ** 2
       const elapsed = performance.now() - down.t
       if (movedSq <= RIGHT_CLICK_CANCEL_MAX_MOVE_PX ** 2 && elapsed <= RIGHT_CLICK_CANCEL_MAX_MS) {
@@ -2594,7 +2701,7 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
     const unsubDraftWatch = useScene.subscribe((state) => {
       if (tearingDown) return
       const draft = draftNode.current
-      if (draft === null) return
+      if (draft === null || isFreshPlacementMetadata(draft.metadata)) return
       if (draft.id in state.nodes) return
 
       queueMicrotask(() => {
@@ -2602,48 +2709,79 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
         const draft = draftNode.current
         if (draft === null) return
         if (draft.id in useScene.getState().nodes) return
-        // Temporal is paused during placement, createNode won't be tracked
-        useScene.getState().createNode(draft, draft.parentId as AnyNodeId)
+        pausedDraftWrite(() => useScene.getState().createNode(draft, draft.parentId as AnyNodeId))
       })
     })
 
     // ---- Subscribe ----
 
+    const specializedKinds = new Set<string>()
+    const subscribeSpecialized = <E,>(key: string, handler: (event: E) => void) => {
+      specializedKinds.add(key.slice(0, key.lastIndexOf(':')))
+      emitter.on(key as never, handler as never)
+    }
+    const genericRoute = (phase: 'enter' | 'move' | 'click' | 'leave') => (event: NodeEvent) => {
+      if (specializedKinds.has(event.node.type)) return
+      if (
+        !surfaceOwnership.allows(event.node.id, event.nativeEvent.nativeEvent ?? event.nativeEvent)
+      )
+        return
+      if (nodeRegistry.get(event.node.type)?.capabilities.faceHost) {
+        const handlers = {
+          enter: onFaceHostEnter,
+          move: onFaceHostMove,
+          click: onFaceHostClick,
+          leave: onFaceHostLeave,
+        }
+        handlers[phase](event)
+        return
+      }
+      if (!canHostSurfaceChild(event.node, 'item', draftNode.current?.id)) return
+      if (phase === 'leave' && placementState.current.surfaceItemId !== event.node.id) return
+      if (phase === 'enter') onItemEnter(event, true)
+      else if (phase === 'move') onItemMove(event, true)
+      else if (phase === 'click') onItemClick(event)
+      else onItemLeave(event)
+    }
+    const onNodeEnter = genericRoute('enter')
+    const onNodeMove = genericRoute('move')
+    const onNodeClick = genericRoute('click')
+    const onNodeLeave = genericRoute('leave')
     const gridDispatch = createItemSurfaceGridDispatch(onGridMove)
     emitter.on('grid:move', gridDispatch.schedule)
     emitter.on('grid:click', onGridClick)
-    emitter.on('item:enter', onItemEnter)
-    emitter.on('item:move', onItemMove)
-    emitter.on('item:leave', onItemLeave)
-    emitter.on('item:click', onItemClick)
-    emitter.on('wall:enter', onWallEnter)
-    emitter.on('wall:move', onWallMove)
-    emitter.on('wall:click', onWallClick)
-    emitter.on('wall:leave', onWallLeave)
-    emitter.on('roof:enter', onRoofWallEnter)
-    emitter.on('roof:move', onRoofWallMove)
-    emitter.on('roof:click', onRoofWallClick)
-    emitter.on('roof:leave', onRoofWallLeave)
-    emitter.on('node:enter', onFaceHostEnter)
-    emitter.on('node:move', onFaceHostMove)
-    emitter.on('node:click', onFaceHostClick)
-    emitter.on('node:leave', onFaceHostLeave)
-    emitter.on('ceiling:enter', onCeilingEnter)
-    emitter.on('ceiling:move', onCeilingMove)
-    emitter.on('ceiling:click', onCeilingClick)
-    emitter.on('ceiling:leave', onCeilingLeave)
-    emitter.on('cabinet:enter', onItemEnter)
-    emitter.on('procedural-item:enter' as never, onItemEnter)
-    emitter.on('cabinet:move', onItemMove)
-    emitter.on('procedural-item:move' as never, onItemMove)
-    emitter.on('cabinet:click', onItemClick)
-    emitter.on('procedural-item:click' as never, onItemClick)
-    emitter.on('cabinet:leave', onItemLeave)
-    emitter.on('procedural-item:leave' as never, onItemLeave)
-    emitter.on('shelf:enter', onShelfEnter)
-    emitter.on('shelf:move', onShelfMove)
-    emitter.on('shelf:click', onShelfClick)
-    emitter.on('shelf:leave', onShelfLeave)
+    subscribeSpecialized('item:enter', onItemEnter)
+    subscribeSpecialized('item:move', onItemMove)
+    subscribeSpecialized('item:leave', onItemLeave)
+    subscribeSpecialized('item:click', onItemClick)
+    subscribeSpecialized('wall:enter', onWallEnter)
+    subscribeSpecialized('wall:move', onWallMove)
+    subscribeSpecialized('wall:click', onWallClick)
+    subscribeSpecialized('wall:leave', onWallLeave)
+    subscribeSpecialized('roof:enter', onRoofWallEnter)
+    subscribeSpecialized('roof:move', onRoofWallMove)
+    subscribeSpecialized('roof:click', onRoofWallClick)
+    subscribeSpecialized('roof:leave', onRoofWallLeave)
+    emitter.on('node:enter', onNodeEnter)
+    emitter.on('node:move', onNodeMove)
+    emitter.on('node:click', onNodeClick)
+    emitter.on('node:leave', onNodeLeave)
+    subscribeSpecialized('ceiling:enter', onCeilingEnter)
+    subscribeSpecialized('ceiling:move', onCeilingMove)
+    subscribeSpecialized('ceiling:click', onCeilingClick)
+    subscribeSpecialized('ceiling:leave', onCeilingLeave)
+    subscribeSpecialized('cabinet:enter', onItemEnter)
+    subscribeSpecialized('procedural-item:enter', onItemEnter)
+    subscribeSpecialized('cabinet:move', onItemMove)
+    subscribeSpecialized('procedural-item:move', onItemMove)
+    subscribeSpecialized('cabinet:click', onItemClick)
+    subscribeSpecialized('procedural-item:click', onItemClick)
+    subscribeSpecialized('cabinet:leave', onItemLeave)
+    subscribeSpecialized('procedural-item:leave', onItemLeave)
+    subscribeSpecialized('shelf:enter', onShelfEnter)
+    subscribeSpecialized('shelf:move', onShelfMove)
+    subscribeSpecialized('shelf:click', onShelfClick)
+    subscribeSpecialized('shelf:leave', onShelfLeave)
 
     // A floor placement commits at the tracked floor cursor (`gridPosition`),
     // which keeps following the floor even when the click ray lands on a wall
@@ -2673,7 +2811,6 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
         useLiveNodeOverrides.getState().clearFields(draftNode.current.id, ['rotation'])
       }
       draftNode.destroy()
-      useScene.temporal.getState().resume()
       gridDispatch.cancel()
       emitter.off('grid:move', gridDispatch.schedule)
       emitter.off('grid:click', onGridClick)
@@ -2689,10 +2826,10 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
       emitter.off('roof:move', onRoofWallMove)
       emitter.off('roof:click', onRoofWallClick)
       emitter.off('roof:leave', onRoofWallLeave)
-      emitter.off('node:enter', onFaceHostEnter)
-      emitter.off('node:move', onFaceHostMove)
-      emitter.off('node:click', onFaceHostClick)
-      emitter.off('node:leave', onFaceHostLeave)
+      emitter.off('node:enter', onNodeEnter)
+      emitter.off('node:move', onNodeMove)
+      emitter.off('node:click', onNodeClick)
+      emitter.off('node:leave', onNodeLeave)
       emitter.off('ceiling:enter', onCeilingEnter)
       emitter.off('ceiling:move', onCeilingMove)
       emitter.off('ceiling:click', onCeilingClick)
@@ -2764,12 +2901,15 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
       draftParent?.type === 'shelf' ||
       draftParent?.type === 'cabinet' ||
       draftParent?.type === 'procedural-item' ||
+      (draftParent && canHostSurfaceChild(draftParent, draft.type, draft.id)) ||
       (draftParent &&
         nodeRegistry.get(draftParent.type)?.capabilities.faceHost?.currentFaceId(draft))
     )
       return
     draft.parentId = viewerLevelId
-    useScene.getState().updateNode(draft.id as AnyNodeId, { parentId: viewerLevelId })
+    pausedDraftWrite(() =>
+      useScene.getState().updateNode(draft.id as AnyNodeId, { parentId: viewerLevelId }),
+    )
   }, [viewerLevelId, draftNode, asset])
 
   // Restore the draft mesh's raycast when the coordinator unmounts (tool change).
@@ -2782,8 +2922,8 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
   // instead of drawing an inline triangle. Only this coordinator publishes — a
   // moving existing node has no draft here, so the grid reads that case straight
   // off the node's mesh. Cleared when idle.
-  const surfaceNormalRef = useRef(new Vector3(0, 1, 0))
   const surfaceWorldPointRef = useRef(new Vector3())
+  const surfaceNormalRef = useRef(new Vector3(0, 1, 0))
   const facingForwardRef = useRef(new Vector3(0, 0, 1))
   const facingQuatRef = useRef(new Quaternion())
   const ghostSurfaceQuatRef = useRef(new Quaternion())