@pascal-app/editor 1.0.4 → 1.0.5

package/src/components/tools/registry/item-surface-move.test.ts

@@ -443,67 +443,66 @@ describe('registry item-surface move session', () => {
     expect((useScene.getState().nodes[host.id] as ItemNode).children as string[]).toEqual([])
   })
 
-  test.each([
-    'floor',
-    'same host',
-    'floor then host',
-  ])('a hosted move to %s commits once and undo restores the original parent and pose', (destination) => {
-    const initial = createRegistryItemSurfaceMove(original)!
-    const hostedPose = initial.enter(eventFor().event, dimensions, 0.3)!
-    const hosted = useScene.getState().nodes[original.id]!
-    const session = createRegistryItemSurfaceMove(hosted)!
-    let pose: { position: [number, number, number]; rotationY: number } = session.enter(
-      eventFor().event,
-      dimensions,
-      hostedPose.rotationY,
-    )!
-    if (destination !== 'same host') {
-      const world = sceneRegistry.nodes
-        .get('level_surface-move')!
-        .localToWorld(new Vector3(8, 0, 9))
-      pose = session.detach(world.toArray(), pose.rotationY)!
-      const detached = useScene.getState().nodes[original.id]!
-      expect(
-        getFloorPlacedElevation({
-          node: detached,
-          nodes: useScene.getState().nodes,
-          position: pose.position,
-          maxElevation: 0,
-        }),
-      ).toBe(0)
-      const footprints = getFloorPlacedFootprints(
-        nodeRegistry.get(original.type)!.capabilities.floorPlaced!,
-        detached,
-        { nodes: useScene.getState().nodes },
-      ).map((footprint) => ({ ...footprint, position: footprint.position ?? pose.position }))
-      expect(
-        spatialGridManager.canPlaceOnFloorFootprints('level_surface-move', footprints, [
-          original.id,
-        ]).valid,
-      ).toBe(true)
-    }
-    if (destination !== 'floor') {
-      pose = session.enter(eventFor(host, [0.6, 1, -0.4]).event, dimensions, pose.rotationY)!
-    }
-    const final = useScene.getState().nodes[original.id]!
-    const patch = {
-      ...final,
-      ...resolveSupportSlabPatch(final, useScene.getState().nodes, { maxElevation: 0 }),
-    }
-    session.restore()
-    useScene.temporal.getState().resume()
-    useScene.getState().updateNodes([{ id: original.id, data: patch }])
-    useScene.temporal.getState().pause()
-    expect(useScene.getState().nodes[original.id]?.parentId).toBe(
-      destination === 'floor' ? 'level_surface-move' : host.id,
-    )
-    expect(useScene.temporal.getState().pastStates).toHaveLength(1)
-    useScene.temporal.getState().undo()
-    expect(useScene.getState().nodes[original.id]).toEqual(hosted)
-    expect((useScene.getState().nodes[host.id] as ItemNode).children as string[]).toContain(
-      original.id,
-    )
-    useScene.temporal.getState().redo()
-    expect(useScene.getState().nodes[original.id]).toEqual(patch)
-  })
+  test.each(['floor', 'same host', 'floor then host'])(
+    'a hosted move to %s commits once and undo restores the original parent and pose',
+    (destination) => {
+      const initial = createRegistryItemSurfaceMove(original)!
+      const hostedPose = initial.enter(eventFor().event, dimensions, 0.3)!
+      const hosted = useScene.getState().nodes[original.id]!
+      const session = createRegistryItemSurfaceMove(hosted)!
+      let pose: { position: [number, number, number]; rotationY: number } = session.enter(
+        eventFor().event,
+        dimensions,
+        hostedPose.rotationY,
+      )!
+      if (destination !== 'same host') {
+        const world = sceneRegistry.nodes
+          .get('level_surface-move')!
+          .localToWorld(new Vector3(8, 0, 9))
+        pose = session.detach(world.toArray(), pose.rotationY)!
+        const detached = useScene.getState().nodes[original.id]!
+        expect(
+          getFloorPlacedElevation({
+            node: detached,
+            nodes: useScene.getState().nodes,
+            position: pose.position,
+            maxElevation: 0,
+          }),
+        ).toBe(0)
+        const footprints = getFloorPlacedFootprints(
+          nodeRegistry.get(original.type)!.capabilities.floorPlaced!,
+          detached,
+          { nodes: useScene.getState().nodes },
+        ).map((footprint) => ({ ...footprint, position: footprint.position ?? pose.position }))
+        expect(
+          spatialGridManager.canPlaceOnFloorFootprints('level_surface-move', footprints, [
+            original.id,
+          ]).valid,
+        ).toBe(true)
+      }
+      if (destination !== 'floor') {
+        pose = session.enter(eventFor(host, [0.6, 1, -0.4]).event, dimensions, pose.rotationY)!
+      }
+      const final = useScene.getState().nodes[original.id]!
+      const patch = {
+        ...final,
+        ...resolveSupportSlabPatch(final, useScene.getState().nodes, { maxElevation: 0 }),
+      }
+      session.restore()
+      useScene.temporal.getState().resume()
+      useScene.getState().updateNodes([{ id: original.id, data: patch }])
+      useScene.temporal.getState().pause()
+      expect(useScene.getState().nodes[original.id]?.parentId).toBe(
+        destination === 'floor' ? 'level_surface-move' : host.id,
+      )
+      expect(useScene.temporal.getState().pastStates).toHaveLength(1)
+      useScene.temporal.getState().undo()
+      expect(useScene.getState().nodes[original.id]).toEqual(hosted)
+      expect((useScene.getState().nodes[host.id] as ItemNode).children as string[]).toContain(
+        original.id,
+      )
+      useScene.temporal.getState().redo()
+      expect(useScene.getState().nodes[original.id]).toEqual(patch)
+    },
+  )
 })

package/src/components/tools/registry/item-surface-move.ts

@@ -105,6 +105,8 @@ function parentWorldYaw(parentId: string | null | undefined): number {
 export function createRegistryItemSurfaceMove(node: AnyNode) {
   const capabilities = nodeRegistry.get(node.type)?.capabilities
   const floorPlaced = capabilities?.floorPlaced
+  if (capabilities?.movable?.preserveLevelAndElevation && !isFreshPlacementMetadata(node.metadata))
+    return null
   if (!floorPlaced || (floorPlaced.applies && !floorPlaced.applies(node))) return null
 
   const original = node as AnyNode & {

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

@@ -219,32 +219,32 @@ test('the mover rejects an indirect descendant before asking the resolver', () =
   expect(useScene.getState().nodes).toBe(before)
 })
 
-test.each([
-  'host-local',
-  'surface-local',
-] as const)('writes the resolver pose in its %s child frame', (childFrame) => {
-  const placement: SurfacePlacement = {
-    position: [0.25, 1.5, -0.75],
-    rotationY: 0.4,
-    surfaceId: 'test-surface',
-    childFrame,
-    surfaceLocal: { position: [-0.5, 0, 0.25], rotationY: -0.2, rotation: [0.7, -0.2, 0.8] },
-  }
-  resolver.mockReturnValue(placement)
-  const session = createRegistryItemSurfaceMove(child)!
-  const pose = session.enter(hit(), dimensions, 0.3)!
-  const expected = childFrame === 'surface-local' ? placement.surfaceLocal! : placement
-  expect(pose.position).toEqual([...expected.position])
-  expect(pose.rotationY).toBe(expected.rotationY)
-  expect(useScene.getState().nodes[child.id]).toMatchObject({
-    parentId: host.id,
-    position: expected.position,
-    rotation:
-      childFrame === 'surface-local'
-        ? placement.surfaceLocal!.rotation
-        : [0.1, placement.rotationY, 0.2],
-  })
-})
+test.each(['host-local', 'surface-local'] as const)(
+  'writes the resolver pose in its %s child frame',
+  (childFrame) => {
+    const placement: SurfacePlacement = {
+      position: [0.25, 1.5, -0.75],
+      rotationY: 0.4,
+      surfaceId: 'test-surface',
+      childFrame,
+      surfaceLocal: { position: [-0.5, 0, 0.25], rotationY: -0.2, rotation: [0.7, -0.2, 0.8] },
+    }
+    resolver.mockReturnValue(placement)
+    const session = createRegistryItemSurfaceMove(child)!
+    const pose = session.enter(hit(), dimensions, 0.3)!
+    const expected = childFrame === 'surface-local' ? placement.surfaceLocal! : placement
+    expect(pose.position).toEqual([...expected.position])
+    expect(pose.rotationY).toBe(expected.rotationY)
+    expect(useScene.getState().nodes[child.id]).toMatchObject({
+      parentId: host.id,
+      position: expected.position,
+      rotation:
+        childFrame === 'surface-local'
+          ? placement.surfaceLocal!.rotation
+          : [0.1, placement.rotationY, 0.2],
+    })
+  },
+)
 
 test('non-item events never reach the resolver', () => {
   const session = createRegistryItemSurfaceMove(child)!

package/src/components/tools/registry/move-registry-node-tool.test.ts

@@ -1,4 +1,12 @@
-import { expect, test } from 'bun:test'
+import { expect, jest, test } from 'bun:test'
+import type {
+  AnyNode,
+  AnyNodeDefinition,
+  AnyNodeId,
+  BuildingNode,
+  LevelNode,
+} from '@pascal-app/core'
+import type { Catalogue } from '@react-three/fiber'
 import { resolveMoveRotationStep } from './move-registry-node-tool'
 
 test('applies a free rotation step while the move is unattached', () => {
@@ -8,3 +16,262 @@ test('applies a free rotation step while the move is unattached', () => {
 test('rejects rotation steps while the move is wall-attached', () => {
   expect(resolveMoveRotationStep(0.5, 0.25, Math.PI / 2)).toBeNull()
 })
+
+// Contract-derived controller regression, not a helper replay: editable keys
+// leave a live move alone; outside R/T and Alt still affect the real controller.
+// R3F reconciles real Three objects with a rendererless context. No drawing,
+// native typing, canvas hit-testing or GPU evidence is claimed by this test.
+test('focus completion: mounted registry mover owns only outside R T and Alt', async () => {
+  const core = await import('@pascal-app/core')
+  const { useViewer } = await import('@pascal-app/viewer')
+  const { createRoot, extend } = await import('@react-three/fiber')
+  const { act, createElement } = await import('react')
+  const three = await import('three')
+  const { z } = await import('zod')
+  const { MoveRegistryNodeTool } = await import('./move-registry-node-tool')
+  const { default: useEditor } = await import('../../../store/use-editor')
+  const { default: useInteractionScope } = await import('../../../store/use-interaction-scope')
+  const { default: useAlignmentGuides } = await import('../../../store/use-alignment-guides')
+  const { default: useFacingPose } = await import('../../../store/use-facing-pose')
+  const { default: usePlacementPreview } = await import('../../../store/use-placement-preview')
+  const globals = [
+    'window',
+    'document',
+    'requestAnimationFrame',
+    'cancelAnimationFrame',
+    'IS_REACT_ACT_ENVIRONMENT',
+  ] as const
+  const descriptors = globals.map((key) => Object.getOwnPropertyDescriptor(globalThis, key))
+  const stores = [
+    core.useScene,
+    core.useScene.temporal,
+    useViewer,
+    useEditor,
+    useInteractionScope,
+    core.useLiveTransforms,
+    core.useLiveNodeOverrides,
+    useAlignmentGuides,
+    useFacingPose,
+    usePlacementPreview,
+  ]
+  const originalStates = stores.map((store) => store.getState())
+  const restoreRegistry = core.nodeRegistry._snapshot()
+  const sceneObjects = new Map(core.sceneRegistry.nodes)
+  const frames = new Map<number, FrameRequestCallback>()
+  let nextFrame = 0
+  let time = 0
+  const flushFrames = () => {
+    const pending = [...frames.values()]
+    frames.clear()
+    for (const callback of pending) {
+      time += 16
+      callback(time)
+    }
+  }
+  let root: ReturnType<typeof createRoot> | undefined
+  let mountedScene: import('three').Scene | undefined
+  const mesh = new three.Mesh(new three.BoxGeometry(1, 1, 1), new three.MeshBasicMaterial())
+  const id = 'completion_registry' as AnyNodeId
+  const buildingId = 'building_completion_registry' as BuildingNode['id']
+  const levelId = 'level_completion_registry' as LevelNode['id']
+  const node = {
+    id,
+    type: 'completion:registry',
+    object: 'node',
+    parentId: levelId,
+    children: [],
+    metadata: {},
+    visible: true,
+    position: [2, 0, 3],
+    rotation: 0.25,
+  } as unknown as AnyNode
+  jest.useFakeTimers()
+  try {
+    const target = new EventTarget()
+    const documentFixture = { body: { style: { cursor: '' } }, querySelector: () => null }
+    Object.defineProperties(globalThis, {
+      window: {
+        configurable: true,
+        value: Object.assign(target, {
+          matchMedia: () => Object.assign(new EventTarget(), { matches: false }),
+        }),
+      },
+      document: { configurable: true, value: documentFixture },
+      requestAnimationFrame: {
+        configurable: true,
+        value: (callback: FrameRequestCallback) => {
+          frames.set(++nextFrame, callback)
+          return nextFrame
+        },
+      },
+      cancelAnimationFrame: { configurable: true, value: (key: number) => frames.delete(key) },
+      IS_REACT_ACT_ENVIRONMENT: { configurable: true, value: true },
+    })
+    core.registerNode({
+      kind: node.type,
+      schemaVersion: 1,
+      category: 'utility',
+      schema: z.object({ type: z.literal(node.type) }).passthrough(),
+      defaults: () => ({}),
+      capabilities: {
+        movable: { isValidPosition: () => false },
+        floorPlaced: {
+          collides: true,
+          footprint: (candidate: AnyNode) => ({
+            dimensions: [1, 1, 1],
+            rotation: [0, (candidate as unknown as { rotation: number }).rotation, 0],
+          }),
+        },
+      },
+    } as unknown as AnyNodeDefinition)
+    core.useScene.temporal.getState().pause()
+    // Placement validity is level-scoped. Without a real selected level the
+    // mover deliberately treats placement as valid before consulting the kind.
+    core.useScene.setState({
+      nodes: {
+        [buildingId]: {
+          id: buildingId,
+          type: 'building',
+          parentId: null,
+          children: [levelId],
+          position: [0, 0, 0],
+          rotation: 0,
+        } as unknown as AnyNode,
+        [levelId]: {
+          id: levelId,
+          type: 'level',
+          parentId: buildingId,
+          children: [id],
+          elevation: 0,
+          height: 3,
+        } as unknown as AnyNode,
+        [id]: node,
+      },
+      rootNodeIds: [buildingId],
+    })
+    core.useScene.temporal.getState().resume()
+    core.clearSceneHistory()
+    core.useScene.getState().updateNode(id, { name: 'history sentinel' } as never)
+    flushFrames()
+    useViewer.getState().setSelection({ selectedIds: [id], levelId, buildingId, zoneId: null })
+    useEditor.setState({ mode: 'select', tool: null })
+    useEditor.getState().setMovingNode(core.useScene.getState().nodes[id]!)
+    mesh.position.set(2, 0, 3)
+    mesh.rotation.y = 0.25
+    core.sceneRegistry.nodes.set(id, mesh)
+    extend(three as unknown as Catalogue)
+    // Supplying a renderer-shaped context prevents WebGLRenderer construction.
+    // Drawing is a hard failure, never a stub returning fake pixels.
+    const gl = {
+      render: () => {
+        throw new Error('CPU controller acceptance must not render')
+      },
+      setSize: () => {},
+      setPixelRatio: () => {},
+      domElement: {},
+    }
+    root = createRoot({} as HTMLCanvasElement)
+    await root.configure({
+      gl: gl as never,
+      frameloop: 'never',
+      size: { width: 300, height: 300, top: 0, left: 0 },
+      onCreated: (state) => {
+        mountedScene = state.scene
+      },
+    })
+    await act(async () => {
+      root!.render(
+        createElement(MoveRegistryNodeTool, { node: core.useScene.getState().nodes[id]! }),
+      )
+    })
+    const colours = () => {
+      const result: number[] = []
+      mountedScene!.traverse((object) => {
+        const material = (object as import('three').Mesh).material
+        for (const entry of Array.isArray(material) ? material : [material]) {
+          if (entry && 'color' in entry)
+            result.push((entry.color as import('three').Color).getHex())
+        }
+      })
+      return result.sort()
+    }
+    const snapshot = () =>
+      JSON.parse(
+        JSON.stringify({
+          nodes: core.useScene.getState().nodes,
+          live: [...core.useLiveTransforms.getState().transforms],
+          overrides: [...core.useLiveNodeOverrides.getState().overrides],
+          scope: useInteractionScope.getState().scope,
+          history: {
+            past: core.useScene.temporal.getState().pastStates,
+            future: core.useScene.temporal.getState().futureStates,
+            tracking: core.useScene.temporal.getState().isTracking,
+            pauseDepth: core.getSceneHistoryPauseDepth(),
+          },
+          pose: { position: mesh.position.toArray(), rotation: mesh.rotation.y },
+          colours: colours(),
+        }),
+      )
+    const key = async (value: string, editable: boolean, type = 'keydown') => {
+      const event = new Event(type, { cancelable: true })
+      Object.defineProperties(event, {
+        key: { value },
+        target: {
+          value: editable
+            ? { tagName: 'TEXTAREA', closest: () => ({ tagName: 'TEXTAREA' }) }
+            : target,
+        },
+        altKey: { value: value === 'Alt' },
+        ctrlKey: { value: false },
+        metaKey: { value: false },
+      })
+      await act(async () => {
+        target.dispatchEvent(event)
+        flushFrames()
+      })
+      return event
+    }
+    expect((await key('r', false)).defaultPrevented).toBe(true)
+    expect(mesh.rotation.y).toBeCloseTo(0.25 + Math.PI / 4)
+    expect(colours()).toContain(0xef4444)
+    const before = snapshot()
+    expect(before.live.length).toBeGreaterThan(0)
+    expect(before.history.past.length).toBeGreaterThan(0)
+    expect(before.history.tracking).toBe(false)
+    expect(before.scope.kind).toBe('moving')
+    for (const value of ['r', 't', 'Alt']) {
+      expect((await key(value, true)).defaultPrevented).toBe(false)
+      expect(snapshot()).toEqual(before)
+    }
+    // Key-up reset remains active even if focus moved into a field.
+    await key('Alt', false)
+    expect(colours()).toContain(0x22c55e)
+    await key('Alt', true, 'keyup')
+    expect(colours()).toContain(0xef4444)
+    expect((await key('t', false)).defaultPrevented).toBe(true)
+    expect(mesh.rotation.y).toBeCloseTo(0.25)
+    expect(core.useLiveTransforms.getState().transforms.get(id)?.rotation).toBeCloseTo(0.25)
+  } finally {
+    if (root)
+      await act(async () => {
+        root!.unmount()
+      })
+    // R3F's delayed disposal is advanced, not slept through, before globals go.
+    jest.runOnlyPendingTimers()
+    frames.clear()
+    restoreRegistry()
+    core.sceneRegistry.nodes.clear()
+    for (const [key, value] of sceneObjects) core.sceneRegistry.nodes.set(key, value)
+    stores.forEach((store, index) => {
+      ;(store.setState as (snapshot: unknown, replace: true) => void)(originalStates[index], true)
+    })
+    mesh.geometry.dispose()
+    mesh.material.dispose()
+    jest.useRealTimers()
+    globals.forEach((key, index) => {
+      const descriptor = descriptors[index]
+      if (descriptor) Object.defineProperty(globalThis, key, descriptor)
+      else Reflect.deleteProperty(globalThis, key)
+    })
+  }
+}, 15_000)

package/src/components/tools/registry/move-registry-node-tool.tsx

@@ -17,6 +17,7 @@ import {
   footprintAABBFrom,
   type GridEvent,
   type GroupMoveSnapResult,
+  getFloorPlacedElevation,
   getFloorPlacedFootprints,
   type MovableConfig,
   movingFootprintAnchors,
@@ -60,6 +61,7 @@ import {
   surfaceAttachmentUpdates,
   updateSurfaceNode,
 } from '../../../lib/surface-attachment'
+import { isTypingTarget } from '../../../lib/typing-target'
 import useAlignmentGuides from '../../../store/use-alignment-guides'
 import useEditor, {
   getActiveSnappingMode,
@@ -416,6 +418,9 @@ export function MoveRegistryNodeTool({ node: source }: { node: AnyNode }) {
   const [cursorRotationY, setCursorRotationY] = useState(() => previewRotationY(originalRotationY))
   const { isFreshPlacement, previewVisible, revealFreshPlacement, useAbsoluteCursorPlacement } =
     useFreshPlacementVisibility({ node })
+  const preserveLevelAndElevation =
+    !isFreshPlacement &&
+    nodeRegistry.get(node.type)?.capabilities?.movable?.preserveLevelAndElevation === true
   // Kinds that declare `movable.cursorAttached` (duct fittings) pin to the
   // cursor instead of preserving the grab offset — small connector-like
   // nodes read an offset drag as "lagging behind the mouse".
@@ -479,7 +484,24 @@ export function MoveRegistryNodeTool({ node: source }: { node: AnyNode }) {
       return Array.isArray(rotation) ? [rotation[0] ?? 0, y, rotation[2] ?? 0] : y
     }
 
+    const keepStartingElevation = (position: [number, number, number], yaw: number) => {
+      if (!preserveLevelAndElevation) return position
+      const rotation = toCommitRotation(yaw)
+      const currentNodes = useScene.getState().nodes
+      const effectiveNode = { ...node, position, rotation } as AnyNode
+      const lift = getFloorPlacedElevation({
+        node: effectiveNode,
+        nodes: { ...currentNodes, [node.id]: effectiveNode },
+        position,
+        rotation,
+      })
+      return [position[0], originalPlanPosition[1] - lift, position[2]] as [number, number, number]
+    }
+
     const currentLevelId = () =>
+      (preserveLevelAndElevation
+        ? findLevelAncestorId(node.id, useScene.getState().nodes)
+        : null) ??
       useViewer.getState().selection.levelId ??
       (itemSurfaceMove ? findLevelAncestorId(node.id, useScene.getState().nodes) : node.parentId)
 
@@ -805,10 +827,14 @@ export function MoveRegistryNodeTool({ node: source }: { node: AnyNode }) {
       // test are plane-height independent, so the elected surface is a
       // single fixed point per pointer ray.
       const pointed = resolvePointerSupportSurface(cameraRef.current, event.position)
-      supportCapRef.current = pointed?.elevation ?? null
-      supportSurfaceRef.current = pointed
-      const rawX = pointed?.localPoint?.[0] ?? event.localPosition[0]
-      const rawZ = pointed?.localPoint?.[2] ?? event.localPosition[2]
+      supportCapRef.current = preserveLevelAndElevation ? null : (pointed?.elevation ?? null)
+      supportSurfaceRef.current = preserveLevelAndElevation ? null : pointed
+      const rawX = preserveLevelAndElevation
+        ? event.localPosition[0]
+        : (pointed?.localPoint?.[0] ?? event.localPosition[0])
+      const rawZ = preserveLevelAndElevation
+        ? event.localPosition[2]
+        : (pointed?.localPoint?.[2] ?? event.localPosition[2])
       revealFreshPlacement()
 
       const magnetic = isMagneticSnapActive()
@@ -982,7 +1008,7 @@ export function MoveRegistryNodeTool({ node: source }: { node: AnyNode }) {
           if (guides.length > 0) useAlignmentGuides.getState().set(guides)
         }
       }
-      if (!parentFrame && pointed?.sourceNodeId) {
+      if (!preserveLevelAndElevation && !parentFrame && pointed?.sourceNodeId) {
         const rotation = toCommitRotation(rotationRef.current)
         const effectiveNode = {
           ...((useScene.getState().nodes[node.id] ?? node) as Record<string, unknown>),
@@ -1000,6 +1026,7 @@ export function MoveRegistryNodeTool({ node: source }: { node: AnyNode }) {
           },
         ).position
       }
+      position = keepStartingElevation(position, rotationRef.current)
       const visualPosition = getVisualPosition(position)
       hasMovedRef.current = true
       setCursorPosition(visualPosition)
@@ -1107,18 +1134,20 @@ export function MoveRegistryNodeTool({ node: source }: { node: AnyNode }) {
           // The pointer cap makes the persisted host reproduce the capped
           // election — a drop under a deck stores the aimed-at lower slab
           // (or the ground), not the deck hanging above.
-          ...resolveSupportSlabPatch(
-            effectiveNode,
-            {
-              ...useScene.getState().nodes,
-              [node.id]: effectiveNode,
-            },
-            {
-              maxElevation: supportCapRef.current,
-              preferredSlabId: supportSurfaceRef.current?.supportSlabId,
-              pinSupport: supportSurfaceRef.current?.sourceNodeId != null,
-            },
-          ),
+          ...(preserveLevelAndElevation
+            ? {}
+            : resolveSupportSlabPatch(
+                effectiveNode,
+                {
+                  ...useScene.getState().nodes,
+                  [node.id]: effectiveNode,
+                },
+                {
+                  maxElevation: supportCapRef.current,
+                  preferredSlabId: supportSurfaceRef.current?.supportSlabId,
+                  pinSupport: supportSurfaceRef.current?.sourceNodeId != null,
+                },
+              )),
           ...(isNew
             ? {
                 metadata: stripPlacementMetadataFlags(node.metadata),
@@ -1191,18 +1220,20 @@ export function MoveRegistryNodeTool({ node: source }: { node: AnyNode }) {
           const committedNode = def.schema.parse({
             ...reparsed,
             parentId: node.parentId,
-            ...resolveSupportSlabPatch(
-              { ...reparsed, parentId: node.parentId } as AnyNode,
-              {
-                ...useScene.getState().nodes,
-                [reparsed.id]: reparsed,
-              },
-              {
-                maxElevation: supportCapRef.current,
-                preferredSlabId: supportSurfaceRef.current?.supportSlabId,
-                pinSupport: supportSurfaceRef.current?.sourceNodeId != null,
-              },
-            ),
+            ...(preserveLevelAndElevation
+              ? {}
+              : resolveSupportSlabPatch(
+                  { ...reparsed, parentId: node.parentId } as AnyNode,
+                  {
+                    ...useScene.getState().nodes,
+                    [reparsed.id]: reparsed,
+                  },
+                  {
+                    maxElevation: supportCapRef.current,
+                    preferredSlabId: supportSurfaceRef.current?.supportSlabId,
+                    pinSupport: supportSurfaceRef.current?.sourceNodeId != null,
+                  },
+                )),
           }) as AnyNode
           useScene.temporal.getState().resume()
           useScene.getState().createNode(committedNode, node.parentId as AnyNodeId)
@@ -1247,6 +1278,7 @@ export function MoveRegistryNodeTool({ node: source }: { node: AnyNode }) {
     // item placement keys (and the "Rotate" hints the move HUD shows). Applied
     // imperatively + mirrored to the live transform; committed on drop.
     const onKeyDown = (e: KeyboardEvent) => {
+      if (isTypingTarget(e.target)) return
       // Hold Alt (free place) to force placement on an invalid (red) footprint,
       // matching the GLB item tool. Recolour the box to green while held.
       if (e.key === 'Alt') {
@@ -1287,6 +1319,7 @@ export function MoveRegistryNodeTool({ node: source }: { node: AnyNode }) {
         )
         position = canonicalPositionFromPlan(planOrigin[0], position[1], planOrigin[2])
       }
+      position = keepStartingElevation(position, hostedPose?.rotationY ?? nextFreeRotation)
       lastCursorRef.current = position
       freeRotationRef.current = hostedPose?.rotationY ?? nextFreeRotation
       rotationRef.current = freeRotationRef.current
@@ -1423,6 +1456,7 @@ export function MoveRegistryNodeTool({ node: source }: { node: AnyNode }) {
     originalPosition,
     originalPlanPosition,
     originalRotationY,
+    preserveLevelAndElevation,
     previewRotationY,
     revealFreshPlacement,
     useAbsoluteCursorPlacement,