@pascal-app/editor 1.0.4 → 1.0.6

package/src/components/tools/item/placement-history.test.tsx

@@ -472,3 +472,41 @@ describe('item move history', () => {
     expect(history()).toEqual({ past: before.past, tracking: true, depth: 0 })
   })
 })
+
+describe('item placement selection', () => {
+  // A surface `:click` is synthesized on pointer-up (use-node-events), and the browser fires its
+  // own click after it. By then the editor is back in select mode, where the grid takes that click
+  // for one on empty ground and drops the selection of the item just placed.
+  test('a drop on pointer-up selects the new item and eats the click that follows', async () => {
+    const renderer = await create(<Placement />)
+    try {
+      await carry(10, 14)
+      const dropOnRelease = () =>
+        emitter.emit('node:click', {
+          node: { id: 'site_placement_history', type: 'site' },
+          position: [1.4, 0, 0.5],
+          localPosition: [1.4, 0, 0.5],
+          nativeEvent: { nativeEvent: {} },
+          stopPropagation() {},
+        } as never)
+      window.addEventListener('pointerup', dropOnRelease)
+      await act(async () => {
+        window.dispatchEvent(new Event('pointerup'))
+      })
+      window.removeEventListener('pointerup', dropOnRelease)
+      const placed = levelItems().find((node) => node.id !== item.id)
+      expect(placed).toBeDefined()
+      expect(useViewer.getState().selection.selectedIds).toEqual([placed!.id])
+      const click = new Event('click', { cancelable: true })
+      window.dispatchEvent(click)
+      expect(click.defaultPrevented).toBe(true)
+      // Only that one click: once the swallow window closes, a click reaches the editor again.
+      await new Promise((resolve) => setTimeout(resolve, 350))
+      const next = new Event('click', { cancelable: true })
+      window.dispatchEvent(next)
+      expect(next.defaultPrevented).toBe(false)
+    } finally {
+      await renderer.unmount()
+    }
+  })
+})

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

@@ -1,6 +1,8 @@
 import { beforeEach, describe, expect, test } from 'bun:test'
 import {
   BlockNode,
+  type CeilingEvent,
+  type CeilingNode,
   type GridEvent,
   ItemNode,
   type LevelNode,
@@ -10,7 +12,12 @@ import {
   type WallNode,
 } from '@pascal-app/core'
 import { BufferGeometry, Mesh, MeshBasicMaterial, type Object3D, Vector3 } from 'three'
-import { faceHostStrategy, floorStrategy, wallStrategy } from './placement-strategies'
+import {
+  ceilingStrategy,
+  faceHostStrategy,
+  floorStrategy,
+  wallStrategy,
+} from './placement-strategies'
 import type { PlacementContext, SpatialValidators } from './placement-types'
 import { registerTestBlockFaceHost } from './test-face-host'
 
@@ -492,3 +499,41 @@ describe('floorStrategy.move', () => {
     expect(result.nodeUpdate?.position?.[1]).toBe(0)
   })
 })
+
+describe('ceilingStrategy.move', () => {
+  const ceiling = { id: 'ceiling_test', type: 'ceiling' } as unknown as CeilingNode
+  const ceilingEvent = (): CeilingEvent =>
+    ({
+      node: ceiling,
+      position: [1, 2.5, 1],
+      localPosition: [1, 0, 1],
+      object: new Mesh(),
+      stopPropagation: () => {},
+    }) as unknown as CeilingEvent
+  const onCeiling = (draftItem: ItemNode): PlacementContext => ({
+    ...ceilingContext(),
+    asset: draftItem.asset,
+    draftItem,
+    state: { ...ceilingContext().state, surface: 'ceiling', ceilingId: ceiling.id },
+  })
+  const hanging = (source?: unknown) =>
+    ({
+      ...makeDraft(),
+      asset: { ...makeDraft().asset, attachTo: 'ceiling', dimensions: [0.9, 1, 0.6] },
+      ...(source ? { source } : {}),
+    }) as unknown as ItemNode
+
+  test('hangs a catalog model its full height below the ceiling', () => {
+    const result = ceilingStrategy.move(onCeiling(hanging()), ceilingEvent())
+    expect(result?.gridPosition[1]).toBeCloseTo(-1, 6)
+  })
+
+  test('hangs a scripted object from its top, where the compiler put its origin', () => {
+    const source = {
+      kind: 'script',
+      manifest: { bounds: { min: [-0.45, -1, -0.3], max: [0.45, 0, 0.3] } },
+    }
+    const result = ceilingStrategy.move(onCeiling(hanging(source)), ceilingEvent())
+    expect(result?.gridPosition[1]).toBeCloseTo(0, 6)
+  })
+})

package/src/components/tools/item/placement-strategies.ts

@@ -15,6 +15,7 @@ import type {
   WallNode,
 } from '@pascal-app/core'
 import {
+  ceilingSeatY,
   clampRectToRoofWallFace,
   clearFaceHostItemFields,
   createSceneApi,
@@ -747,9 +748,7 @@ export const ceilingStrategy = {
     // use the ceiling hit's local position rather than world position.
     const x = snapToGrid(event.localPosition[0], swapDims ? dimZ : dimX)
     const z = snapToGrid(event.localPosition[2], swapDims ? dimX : dimZ)
-    // Recessed fixtures seat flush with the ceiling plane (body rising into the
-    // void above); everything else hangs its full height below the ceiling.
-    const seatY = ctx.asset.recessed ? 0 : -itemHeight
+    const seatY = ceilingSeatY(ctx.draftItem ?? { asset: ctx.asset }, itemHeight)
     const worldSnapped = event.object.localToWorld(new Vector3(x, seatY, z))
 
     return {
@@ -781,9 +780,7 @@ export const ceilingStrategy = {
 
     const x = snapToGrid(event.localPosition[0], swapDims ? dimZ : dimX)
     const z = snapToGrid(event.localPosition[2], swapDims ? dimX : dimZ)
-    // Recessed fixtures seat flush with the ceiling plane (body rising into the
-    // void above); everything else hangs its full height below the ceiling.
-    const seatY = ctx.draftItem.asset.recessed ? 0 : -itemHeight
+    const seatY = ceilingSeatY(ctx.draftItem, itemHeight)
     const worldSnapped = event.object.localToWorld(new Vector3(x, seatY, z))
 
     return {

package/src/components/tools/item/shelf-surface-strategy-resolver.test.ts

@@ -117,39 +117,39 @@ function hit(y = 1, z = -0.1): ShelfEvent {
   } as ShelfEvent
 }
 
-test.each([
-  'grid',
-  'off',
-] as const)('midpoint keeps the first declared row and preserves X/Z with grid %s', (mode) => {
-  useEditor.getState().setSnappingMode('item', mode)
-  for (const declared of [
-    [0.5, 1.5],
-    [1.5, 0.5],
-  ]) {
-    rows = declared
-    const expected: [number, number, number] =
-      mode === 'grid' ? [0.25, rows[0]!, 0.125] : [0.37, rows[0]!, -0.1]
-    const ctx = context()
-    const entered = shelfSurfaceStrategy.enter(ctx, hit())!
-    expect(entered.nodeUpdate).toEqual({
-      position: expected,
-      parentId: host.id,
-      rotation: [0.1, 0.7, 0.3],
-    })
-    expect(entered.gridPosition).toEqual(expected)
-    expect(entered.cursorPosition).toEqual(expected)
-    const moved = shelfSurfaceStrategy.move(onShelf(ctx), hit())!
-    expect(moved.nodeUpdate).toEqual({ position: expected })
-    expect(moved.cursorPosition).toEqual(expected)
-    const committed = shelfSurfaceStrategy.click(
-      { ...onShelf(ctx), gridPosition: new Vector3(...entered.gridPosition) },
-      hit(),
-    )!
-    expect(committed.nodeUpdate.position).toEqual(expected)
-    expect(committed.nodeUpdate.parentId).toBe(host.id)
-  }
-  expect(resolver).toHaveBeenCalledTimes(6)
-})
+test.each(['grid', 'off'] as const)(
+  'midpoint keeps the first declared row and preserves X/Z with grid %s',
+  (mode) => {
+    useEditor.getState().setSnappingMode('item', mode)
+    for (const declared of [
+      [0.5, 1.5],
+      [1.5, 0.5],
+    ]) {
+      rows = declared
+      const expected: [number, number, number] =
+        mode === 'grid' ? [0.25, rows[0]!, 0.125] : [0.37, rows[0]!, -0.1]
+      const ctx = context()
+      const entered = shelfSurfaceStrategy.enter(ctx, hit())!
+      expect(entered.nodeUpdate).toEqual({
+        position: expected,
+        parentId: host.id,
+        rotation: [0.1, 0.7, 0.3],
+      })
+      expect(entered.gridPosition).toEqual(expected)
+      expect(entered.cursorPosition).toEqual(expected)
+      const moved = shelfSurfaceStrategy.move(onShelf(ctx), hit())!
+      expect(moved.nodeUpdate).toEqual({ position: expected })
+      expect(moved.cursorPosition).toEqual(expected)
+      const committed = shelfSurfaceStrategy.click(
+        { ...onShelf(ctx), gridPosition: new Vector3(...entered.gridPosition) },
+        hit(),
+      )!
+      expect(committed.nodeUpdate.position).toEqual(expected)
+      expect(committed.nodeUpdate.parentId).toBe(host.id)
+    }
+    expect(resolver).toHaveBeenCalledTimes(6)
+  },
+)
 
 test.each([
   [0.999, 0.5],
@@ -182,29 +182,29 @@ test('a full-board object is refused when grid snapping puts its centre outside
   expect(shelfSurfaceStrategy.enter(context(draft), hit(1, -0.39))).toBeNull()
 })
 
-test.each([
-  'grid',
-  'off',
-] as const)('shelf frame conversion retains exact poses with grid %s', (mode) => {
-  useEditor.getState().setSnappingMode('item', mode)
-  const mesh = sceneRegistry.nodes.get(host.id)!
-  mesh.position.set(4, 2, -3)
-  mesh.rotation.set(0, Math.PI / 3, 0)
-  mesh.updateMatrixWorld(true)
-  const event = hit(1.2)
-  const local = mesh.worldToLocal(new Vector3(...event.position))
-  const expected: [number, number, number] =
-    mode === 'grid' ? [0.25, 1.5, 0.125] : [local.x, 1.5, local.z]
-  const yaw = new Euler().setFromQuaternion(mesh.getWorldQuaternion(new Quaternion()), 'YXZ').y
-  const entered = shelfSurfaceStrategy.enter(context(), event)!
-  expect(entered.nodeUpdate).toEqual({
-    position: expected,
-    parentId: host.id,
-    rotation: [0.1, 0.7 - yaw, 0.3],
-  })
-  expect(entered.cursorPosition).toEqual(mesh.localToWorld(new Vector3(...expected)).toArray())
-  expect(shelfSurfaceStrategy.move(onShelf(context()), event)!.gridPosition).toEqual(expected)
-})
+test.each(['grid', 'off'] as const)(
+  'shelf frame conversion retains exact poses with grid %s',
+  (mode) => {
+    useEditor.getState().setSnappingMode('item', mode)
+    const mesh = sceneRegistry.nodes.get(host.id)!
+    mesh.position.set(4, 2, -3)
+    mesh.rotation.set(0, Math.PI / 3, 0)
+    mesh.updateMatrixWorld(true)
+    const event = hit(1.2)
+    const local = mesh.worldToLocal(new Vector3(...event.position))
+    const expected: [number, number, number] =
+      mode === 'grid' ? [0.25, 1.5, 0.125] : [local.x, 1.5, local.z]
+    const yaw = new Euler().setFromQuaternion(mesh.getWorldQuaternion(new Quaternion()), 'YXZ').y
+    const entered = shelfSurfaceStrategy.enter(context(), event)!
+    expect(entered.nodeUpdate).toEqual({
+      position: expected,
+      parentId: host.id,
+      rotation: [0.1, 0.7 - yaw, 0.3],
+    })
+    expect(entered.cursorPosition).toEqual(mesh.localToWorld(new Vector3(...expected)).toArray())
+    expect(shelfSurfaceStrategy.move(onShelf(context()), event)!.gridPosition).toEqual(expected)
+  },
+)
 
 test('only enter requires an upward normal; moves keep electing rows', () => {
   for (const normal of [[1, 0, 0], [0, -1, 0], undefined] as ShelfEvent['normal'][]) {

package/src/components/tools/item/use-draft-node.test.tsx

@@ -89,105 +89,105 @@ describe('useDraftNode block face commit', () => {
         finish,
       })),
     ),
-  )('an adopted $failure rejection retains owned history through $finish', ({
-    failure,
-    finish,
-  }) => {
-    const item = ItemNode.parse({
-      parentId: LEVEL_ID,
-      position: [1, 0, 1],
-      asset: { id: 'box', name: 'Box', category: 'decor', thumbnail: '', src: '/box.glb' },
-    })
-    useScene.getState().createNode(item, LEVEL_ID as AnyNodeId)
-    useScene.temporal.getState().clear()
-    const originalNodes = structuredClone(useScene.getState().nodes)
-    const draft = draftNode!
-    draft.adopt(item)
-    draft.updateSurface({ position: [2, 0, 2] }, null)
-    const commit = (position: ItemNode['position']) => {
-      const drop = beginSceneHistoryPauseSession(useScene, { gesture: item.id })
-      try {
-        return drop.commitStep(() => draft.commit({ parentId: LEVEL_ID, position }))
-      } finally {
-        drop.end()
-      }
-    }
-    const updateNodes = useScene.getState().updateNodes
-    try {
-      if (failure === 'write') {
-        useScene.setState({
-          updateNodes: (updates) => {
-            if (
-              useScene.temporal.getState().isTracking &&
-              updates.some(
-                (update) =>
-                  update.id === item.id &&
-                  'position' in update.data &&
-                  update.data.position?.[0] === 3,
-              )
-            ) {
-              throw new Error('Rejected tracked write before publication')
-            }
-            return updateNodes(updates)
-          },
-        })
-      }
-      expect(() => commit(failure === 'parse' ? [Number.NaN, 0, 3] : [3, 0, 3])).toThrow()
-      useScene.setState({ updateNodes })
-      expect(draft.current?.id).toBe(item.id)
-      expect(useScene.getState().nodes).toEqual(originalNodes)
-      expect(useScene.temporal.getState().pastStates).toHaveLength(0)
-      expect(useScene.temporal.getState().isTracking).toBe(true)
-      expect(getSceneHistoryPauseDepth()).toBe(0)
-
-      draft.updateSurface({ position: [4, 0, 4] }, null)
-      useScene.getState().updateNode(item.id, { name: 'Foreign rename' })
-      expect(useScene.temporal.getState().pastStates).toHaveLength(1)
-      expect(useScene.temporal.getState().pastStates[0]?.nodes).toEqual(originalNodes)
-      const renamedNodes = {
-        ...originalNodes,
-        [item.id]: { ...originalNodes[item.id]!, name: 'Foreign rename' },
+  )(
+    'an adopted $failure rejection retains owned history through $finish',
+    ({ failure, finish }) => {
+      const item = ItemNode.parse({
+        parentId: LEVEL_ID,
+        position: [1, 0, 1],
+        asset: { id: 'box', name: 'Box', category: 'decor', thumbnail: '', src: '/box.glb' },
+      })
+      useScene.getState().createNode(item, LEVEL_ID as AnyNodeId)
+      useScene.temporal.getState().clear()
+      const originalNodes = structuredClone(useScene.getState().nodes)
+      const draft = draftNode!
+      draft.adopt(item)
+      draft.updateSurface({ position: [2, 0, 2] }, null)
+      const commit = (position: ItemNode['position']) => {
+        const drop = beginSceneHistoryPauseSession(useScene, { gesture: item.id })
+        try {
+          return drop.commitStep(() => draft.commit({ parentId: LEVEL_ID, position }))
+        } finally {
+          drop.end()
+        }
       }
+      const updateNodes = useScene.getState().updateNodes
+      try {
+        if (failure === 'write') {
+          useScene.setState({
+            updateNodes: (updates) => {
+              if (
+                useScene.temporal.getState().isTracking &&
+                updates.some(
+                  (update) =>
+                    update.id === item.id &&
+                    'position' in update.data &&
+                    update.data.position?.[0] === 3,
+                )
+              ) {
+                throw new Error('Rejected tracked write before publication')
+              }
+              return updateNodes(updates)
+            },
+          })
+        }
+        expect(() => commit(failure === 'parse' ? [Number.NaN, 0, 3] : [3, 0, 3])).toThrow()
+        useScene.setState({ updateNodes })
+        expect(draft.current?.id).toBe(item.id)
+        expect(useScene.getState().nodes).toEqual(originalNodes)
+        expect(useScene.temporal.getState().pastStates).toHaveLength(0)
+        expect(useScene.temporal.getState().isTracking).toBe(true)
+        expect(getSceneHistoryPauseDepth()).toBe(0)
 
-      if (finish === 'retry') {
-        expect(commit([5, 0, 5])).toBe(item.id)
-        expect(draft.current).toBeNull()
-        const committedNodes = structuredClone(useScene.getState().nodes)
-        expect(committedNodes[item.id]).toMatchObject({
-          name: 'Foreign rename',
-          position: [5, 0, 5],
-        })
-        expect(useScene.temporal.getState().pastStates).toHaveLength(2)
-        useScene.temporal.getState().undo()
-        expect(useScene.getState().nodes).toEqual(renamedNodes)
-        useScene.temporal.getState().redo()
-        expect(useScene.getState().nodes).toEqual(committedNodes)
-      } else if (finish === 'cancel') {
-        draft.destroy()
-        expect(useScene.getState().nodes).toEqual(renamedNodes)
+        draft.updateSurface({ position: [4, 0, 4] }, null)
+        useScene.getState().updateNode(item.id, { name: 'Foreign rename' })
         expect(useScene.temporal.getState().pastStates).toHaveLength(1)
-        useScene.temporal.getState().undo()
-        expect(useScene.getState().nodes).toEqual(originalNodes)
-        useScene.temporal.getState().redo()
-        expect(useScene.getState().nodes).toEqual(renamedNodes)
-      } else {
-        useScene.getState().updateNode(item.id, { position: [7, 0, 7] })
-        const foreignNodes = structuredClone(useScene.getState().nodes)
+        expect(useScene.temporal.getState().pastStates[0]?.nodes).toEqual(originalNodes)
+        const renamedNodes = {
+          ...originalNodes,
+          [item.id]: { ...originalNodes[item.id]!, name: 'Foreign rename' },
+        }
+
+        if (finish === 'retry') {
+          expect(commit([5, 0, 5])).toBe(item.id)
+          expect(draft.current).toBeNull()
+          const committedNodes = structuredClone(useScene.getState().nodes)
+          expect(committedNodes[item.id]).toMatchObject({
+            name: 'Foreign rename',
+            position: [5, 0, 5],
+          })
+          expect(useScene.temporal.getState().pastStates).toHaveLength(2)
+          useScene.temporal.getState().undo()
+          expect(useScene.getState().nodes).toEqual(renamedNodes)
+          useScene.temporal.getState().redo()
+          expect(useScene.getState().nodes).toEqual(committedNodes)
+        } else if (finish === 'cancel') {
+          draft.destroy()
+          expect(useScene.getState().nodes).toEqual(renamedNodes)
+          expect(useScene.temporal.getState().pastStates).toHaveLength(1)
+          useScene.temporal.getState().undo()
+          expect(useScene.getState().nodes).toEqual(originalNodes)
+          useScene.temporal.getState().redo()
+          expect(useScene.getState().nodes).toEqual(renamedNodes)
+        } else {
+          useScene.getState().updateNode(item.id, { position: [7, 0, 7] })
+          const foreignNodes = structuredClone(useScene.getState().nodes)
+          draft.destroy()
+          expect(useScene.getState().nodes).toEqual(foreignNodes)
+          expect(useScene.temporal.getState().pastStates).toHaveLength(2)
+          useScene.temporal.getState().undo()
+          expect(useScene.getState().nodes).toEqual(renamedNodes)
+          useScene.temporal.getState().redo()
+          expect(useScene.getState().nodes).toEqual(foreignNodes)
+        }
+        expect(useScene.temporal.getState().isTracking).toBe(true)
+        expect(getSceneHistoryPauseDepth()).toBe(0)
+      } finally {
+        useScene.setState({ updateNodes })
         draft.destroy()
-        expect(useScene.getState().nodes).toEqual(foreignNodes)
-        expect(useScene.temporal.getState().pastStates).toHaveLength(2)
-        useScene.temporal.getState().undo()
-        expect(useScene.getState().nodes).toEqual(renamedNodes)
-        useScene.temporal.getState().redo()
-        expect(useScene.getState().nodes).toEqual(foreignNodes)
       }
-      expect(useScene.temporal.getState().isTracking).toBe(true)
-      expect(getSceneHistoryPauseDepth()).toBe(0)
-    } finally {
-      useScene.setState({ updateNodes })
-      draft.destroy()
-    }
-  })
+    },
+  )
 
   test('a drop on an undone host waits for a new valid placement target', () => {
     const item = ItemNode.parse({

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

@@ -59,6 +59,8 @@ import {
   surfaceFramePose,
   updateSurfaceNode as writeSurfaceNode,
 } from '../../../lib/surface-attachment'
+import { isTypingTarget } from '../../../lib/typing-target'
+import { createWallPointerTracker } from '../../../lib/wall-placement-pointer'
 import {
   projectAlignmentGuidesWorldToActiveBuildingLocal,
   resolveAlignmentForActiveBuilding,
@@ -102,6 +104,7 @@ import {
 import {
   getDetachedAttachmentPreviewLift,
   getGridAlignedDimensions,
+  getSideFromNormal,
   snapToGrid,
   snapToHalf,
   snapUpToGridStep,
@@ -606,6 +609,29 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
       if (mesh) reconcileDraftRaycast(mesh)
     }
 
+    // Eat the click the browser fires after a pointer-up that committed, so it
+    // neither commits a second time through a surface `:click` handler nor reaches
+    // the grid, in select mode by then, as a click on empty ground.
+    const swallowNextClick = () => {
+      const swallow = (e: Event) => {
+        e.stopPropagation()
+        e.preventDefault()
+      }
+      window.addEventListener('click', swallow, { capture: true, once: true })
+      setTimeout(() => window.removeEventListener('click', swallow, { capture: true }), 300)
+    }
+    // True between a press's pointer-up and the click the browser fires after it.
+    // Surface `:click` events are synthesized on pointer-up (use-node-events), so a
+    // commit they trigger still has that click to come; a `grid:click` commit is
+    // that click.
+    let releasing = false
+    const onPointerUpCapture = () => {
+      releasing = true
+    }
+    const onClickCapture = () => {
+      releasing = false
+    }
+
     const finishCommittedPlacement = (
       committedId: string | null,
       wasAdopted: boolean,
@@ -628,6 +654,7 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
       // lands on the just-placed (now selected) node instead of a tool-less build
       // limbo. Repeat placements took the early return above and stay armed.
       useEditor.getState().setMode('select')
+      if (releasing) swallowNextClick()
     }
 
     const commitDraft = (
@@ -797,10 +824,13 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
       // Alignment guides are floor-only; clear them when the cursor moves
       // onto a wall / ceiling / item surface (only those paths call this).
       useAlignmentGuides.getState().clear()
-      // Roof faces carry no grab anchor, but landing on one still counts as
-      // anchoring elsewhere — a later return to the grabbed wall must center
-      // under the cursor, not restore the stale grab offset.
-      if (result.stateUpdate.surface === 'roof-wall') grabForgotten = true
+      // A floor transition can be a hit gap; other hosted surfaces are a new anchor.
+      if (
+        result.stateUpdate.surface &&
+        result.stateUpdate.surface !== 'floor' &&
+        result.stateUpdate.surface !== 'wall'
+      )
+        grabForgotten = true
       Object.assign(placementState.current, result.stateUpdate)
       gridPosition.current.set(...result.gridPosition)
 
@@ -924,15 +954,12 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
     // for a given host, then offsets every later move by
     // `start + (raw - anchor)` — mirroring the floor path and the door/window
     // move tools so the item tracks the grabbed point instead of teleporting
-    // its origin under the cursor. Reset on host change (re-seeded from the
-    // item's then-current position) by the surface leave handlers.
-    let wallDragAnchor: {
-      wallId: string
-      rawX: number
-      rawY: number
-      startX: number
-      startY: number
-    } | null = null
+    // its origin under the cursor. Changing hosts or faces clears the offset.
+    const wallPointer = createWallPointerTracker(
+      preserveDragOffset && grabStartPosition
+        ? { wallId: grabWallId, side: draftNode.current?.side, position: grabStartPosition }
+        : undefined,
+    )
     let ceilingDragAnchor: {
       ceilingId: string
       rawX: number
@@ -1053,16 +1080,6 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
     // replays it. Captured once at setup — a fresh coordinator mounts per move.
     const dragMode = useEditor.getState().placementDragMode
     let releaseCommit: (() => void) | null = null
-    // Eat the click the browser fires after pointer-up so the surface
-    // `:click` handlers don't commit a second time.
-    const swallowNextClick = () => {
-      const swallow = (e: Event) => {
-        e.stopPropagation()
-        e.preventDefault()
-      }
-      window.addEventListener('click', swallow, { capture: true, once: true })
-      setTimeout(() => window.removeEventListener('click', swallow, { capture: true }), 300)
-    }
     const onReleaseCommit = () => {
       gridDispatch.flush()
       if (!releaseCommit) return
@@ -1150,6 +1167,8 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
       if (!cursorGroupRef.current) return
       const result = floorStrategy.move(getContext(), floorEvent)
       if (!result) return
+      // Attached items cannot land on the floor; its hit can be a gap in their host.
+      if (!asset.attachTo) grabForgotten = true
 
       // Figma-style alignment snap layered on top of the floor strategy's
       // grid snap: when the draft's edge lines up (on X or Z) with another
@@ -1379,28 +1398,13 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
 
       let wallMoveEvent = event
       if (preserveDragOffset && draftNode.current) {
-        const rawX = event.localPosition[0]
-        const rawY = event.localPosition[1]
-        if (!wallDragAnchor || wallDragAnchor.wallId !== event.node.id) {
-          // Preserve the grab offset only on the wall the item was grabbed
-          // from (no teleport under the pointer at grab time). Any OTHER host
-          // centers the item under the cursor — a host change is already a
-          // jump, so tracking the pointer exactly is the expected feel, while
-          // re-seeding from the carried-over position (the old behavior)
-          // baked an arbitrary along-wall offset into the whole stay on that
-          // wall. Once anchored elsewhere the grab is forgotten for good, so
-          // re-entering the original wall centers under the cursor too.
-          const preserveGrab = preserveGrabOn(event.node.id, grabWallId)
-          wallDragAnchor = {
-            wallId: event.node.id,
-            rawX,
-            rawY,
-            startX: preserveGrab && grabStartPosition ? grabStartPosition[0] : rawX,
-            startY: preserveGrab && grabStartPosition ? grabStartPosition[1] : rawY,
-          }
-        }
-        const correctedX = wallDragAnchor.startX + (rawX - wallDragAnchor.rawX)
-        const correctedY = wallDragAnchor.startY + (rawY - wallDragAnchor.rawY)
+        preserveGrabOn(event.node.id, grabWallId)
+        if (grabForgotten) wallPointer.forget()
+        const [correctedX, correctedY] = wallPointer.resolve(
+          event.node.id,
+          getSideFromNormal(event.normal),
+          [event.localPosition[0], event.localPosition[1]],
+        )
         wallMoveEvent = {
           ...event,
           localPosition: [correctedX, correctedY, event.localPosition[2]],
@@ -1503,7 +1507,7 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
     }
 
     const onWallLeave = (event: WallEvent) => {
-      wallDragAnchor = null
+      wallPointer.leave()
       const result = wallStrategy.leave(getContext())
       if (!result) return
 
@@ -2432,9 +2436,7 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
       }
 
       // Don't intercept keys when focus is inside a text input
-      if (event.target instanceof HTMLInputElement || event.target instanceof HTMLTextAreaElement) {
-        return
-      }
+      if (isTypingTarget(event.target)) return
 
       const draft = draftNode.current
       if (!draft) return
@@ -2798,11 +2800,15 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
     }
     emitter.on('node:click', commitFloorOnSurfaceClick as never)
     if (dragMode) window.addEventListener('pointerup', onReleaseCommit)
+    window.addEventListener('pointerup', onPointerUpCapture, true)
+    window.addEventListener('click', onClickCapture, true)
 
     return () => {
       tearingDown = true
       feedback.clear()
       if (dragMode) window.removeEventListener('pointerup', onReleaseCommit)
+      window.removeEventListener('pointerup', onPointerUpCapture, true)
+      window.removeEventListener('click', onClickCapture, true)
       unsubDraftWatch()
       useAlignmentGuides.getState().clear()
       // Clear every live preview channel before restoring or deleting the draft.