Phase 5 Stage D: re-port curve + whole-item move tools 1:1 from legacy

Each tool is now a direct copy of the legacy implementation, relocated
under @pascal-app/nodes/<kind>/ and dispatched via the registry's
def.affordanceTools. No DragAction abstraction, no clever live-drag
exception, no novel snap pipeline — same code, same UX, same
performance, same history dance.

Ports:
- fence/curve-tool.tsx    (legacy CurveFenceTool, 1:1)
- fence/move-tool.tsx     (legacy MoveFenceTool, 1:1 — including
                           the mesh.position + useLiveTransforms
                           exception that the legacy uses for fence
                           specifically)
- wall/curve-tool.tsx     (legacy CurveWallTool, 1:1)
- slab/move-tool.tsx      (legacy MoveSlabTool, 1:1)
- ceiling/move-tool.tsx   (legacy MoveCeilingTool, 1:1 — preview
                           fill + outline overlay preserved)

Drops the obsolete DragAction-based action files
(packages/nodes/src/{fence,wall,slab,ceiling}/actions/{curve,move}.ts)
and their now-empty actions/ directories where applicable. Fence
keeps actions/move-endpoint.ts since that port works.

Editor public surface gains `getWallGridStep` + `snapScalarToGrid`
(transitional exports — Stage F moves them into @pascal-app/nodes).

ToolManager + MoveTool dispatch unchanged: the same legacy-fallback
branches now mount the registry component because the affordances are
declared, but the rendered behavior matches the legacy because the
implementations are copies.

Per-kind progress: fence D ✅ (curve / move-endpoint / move / placement
all kind-owned), slab D ✅, ceiling D ✅, wall D 🟡 (curve only,
endpoint/move/placement still legacy).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

packages/nodes/src/slab/actions/move.ts

@@ -1,191 +0,0 @@
-import {
-  type AnyNode,
-  type AnyNodeId,
-  type DragAction,
-  type FenceNode,
-  type LevelNode,
-  type SlabNode,
-  sceneRegistry,
-  useLiveTransforms,
-  useScene,
-  type WallNode,
-} from '@pascal-app/core'
-import { type FencePlanPoint, snapFenceDraftPoint, triggerSFX } from '@pascal-app/editor'
-import type * as THREE from 'three'
-
-function sameSnap(a: FencePlanPoint | null, b: FencePlanPoint): boolean {
-  return a !== null && a[0] === b[0] && a[1] === b[1]
-}
-
-/**
- * Phase 5 Stage D — whole-slab move drag affordance.
- *
- * Uses the **live-drag exception** (same recipe as fence move): the
- * slab MESH is translated visually via `sceneRegistry.nodes.get(slabId)
- * .position` plus a mirror entry in `useLiveTransforms`. The scene
- * store's polygon stays untouched during the drag — no React re-render
- * per tick, no CSG-with-holes rebuild per frame.
- *
- * On commit the final polygon is written to the scene via the single-
- * undo dance, then the mesh-position offset is cleared. The renderer
- * picks up the new polygon, the mesh re-mounts at the new world coords,
- * and zundo records one diff.
- *
- * Hosted items don't follow the visual translation (same as legacy —
- * item.position is independent of slab.polygon). Acceptable: the slab
- * snaps back into place on commit so the visual mismatch is brief.
- */
-
-function translatePolygon(
-  polygon: Array<[number, number]>,
-  deltaX: number,
-  deltaZ: number,
-): Array<[number, number]> {
-  return polygon.map(([x, z]) => [x + deltaX, z + deltaZ] as [number, number])
-}
-
-function polygonCenter(polygon: Array<[number, number]>): [number, number] {
-  if (polygon.length === 0) return [0, 0]
-  let sx = 0
-  let sz = 0
-  for (const [x, z] of polygon) {
-    sx += x
-    sz += z
-  }
-  return [sx / polygon.length, sz / polygon.length]
-}
-
-function setMeshOffset(id: AnyNodeId, deltaX: number, deltaZ: number): void {
-  const mesh = sceneRegistry.nodes.get(id) as THREE.Object3D | undefined
-  if (mesh) mesh.position.set(deltaX, 0, deltaZ)
-}
-
-function setLiveTransform(
-  id: AnyNodeId,
-  originalCenter: [number, number],
-  deltaX: number,
-  deltaZ: number,
-): void {
-  useLiveTransforms.getState().set(id, {
-    position: [originalCenter[0] + deltaX, 0, originalCenter[1] + deltaZ],
-    rotation: 0,
-  })
-}
-
-function clearLiveState(id: AnyNodeId): void {
-  setMeshOffset(id, 0, 0)
-  useLiveTransforms.getState().clear(id)
-}
-
-export type MoveSlabCtx = {
-  slabId: AnyNodeId
-  originalPolygon: Array<[number, number]>
-  originalHoles: Array<Array<[number, number]>>
-  originalCenter: [number, number]
-  parentId: string | null
-  levelWalls: WallNode[]
-  levelFences: FenceNode[]
-  dragAnchor: FencePlanPoint | null
-  lastSnapped: FencePlanPoint | null
-}
-
-export type MoveSlabDraft = {
-  polygon: Array<[number, number]>
-  holes: Array<Array<[number, number]>>
-  deltaX: number
-  deltaZ: number
-}
-
-export const moveSlabDragAction: DragAction<MoveSlabCtx, MoveSlabDraft> = {
-  begin: (input) => {
-    const slab = input.node as SlabNode | undefined
-    if (!slab) throw new Error('[moveSlabDragAction] begin requires a slab node')
-    const parentId = slab.parentId ?? null
-    const originalPolygon: Array<[number, number]> = slab.polygon.map(
-      ([x, z]) => [x, z] as [number, number],
-    )
-    const originalHoles: Array<Array<[number, number]>> = (slab.holes ?? []).map((h) =>
-      h.map(([x, z]) => [x, z] as [number, number]),
-    )
-
-    const { nodes } = useScene.getState()
-    const levelNode =
-      parentId && nodes[parentId as AnyNodeId]?.type === 'level'
-        ? (nodes[parentId as AnyNodeId] as LevelNode)
-        : null
-    const levelWalls: WallNode[] = []
-    const levelFences: FenceNode[] = []
-    if (levelNode) {
-      for (const childId of levelNode.children ?? []) {
-        const child = nodes[childId as AnyNodeId]
-        if (!child) continue
-        if (child.type === 'wall') levelWalls.push(child)
-        else if (child.type === 'fence') levelFences.push(child)
-      }
-    }
-
-    return {
-      slabId: slab.id as AnyNodeId,
-      originalPolygon,
-      originalHoles,
-      originalCenter: polygonCenter(originalPolygon),
-      parentId,
-      levelWalls,
-      levelFences,
-      dragAnchor: null,
-      lastSnapped: null,
-    }
-  },
-
-  preview: (ctx, point, _modifiers) => {
-    const snapped = snapFenceDraftPoint({
-      point: [point[0], point[1]],
-      walls: ctx.levelWalls,
-      fences: ctx.levelFences,
-    })
-    if (!sameSnap(ctx.lastSnapped, snapped)) {
-      if (ctx.lastSnapped !== null) triggerSFX('sfx:grid-snap')
-      ctx.lastSnapped = snapped
-    }
-    if (!ctx.dragAnchor) ctx.dragAnchor = snapped
-    const deltaX = snapped[0] - ctx.dragAnchor[0]
-    const deltaZ = snapped[1] - ctx.dragAnchor[1]
-    // Translation is computed lazily on commit — preview only needs the
-    // deltas for the mesh-offset visual.
-    return {
-      polygon: ctx.originalPolygon,
-      holes: ctx.originalHoles,
-      deltaX,
-      deltaZ,
-    }
-  },
-
-  apply: (draft, ctx, _scene) => {
-    // Live-drag exception: visual translate via Three.js mesh.position +
-    // useLiveTransforms. No scene.update during the drag, no React
-    // re-render of the slab geometry, no CSG-with-holes rebuild.
-    setMeshOffset(ctx.slabId, draft.deltaX, draft.deltaZ)
-    setLiveTransform(ctx.slabId, ctx.originalCenter, draft.deltaX, draft.deltaZ)
-    return []
-  },
-
-  commit: (draft, ctx, scene) => {
-    // Single-undo dance — snapshot is empty (no scene.update during
-    // apply), restoreAll is a no-op. Resume history, write the final
-    // polygon. Zundo records one diff: original → translated.
-    scene.restoreAll()
-    scene.resumeHistory()
-    scene.update(ctx.slabId, {
-      polygon: translatePolygon(ctx.originalPolygon, draft.deltaX, draft.deltaZ),
-      holes: ctx.originalHoles.map((h) => translatePolygon(h, draft.deltaX, draft.deltaZ)),
-    } as Partial<AnyNode>)
-    clearLiveState(ctx.slabId)
-    return true
-  },
-
-  cancel: (ctx, _scene) => {
-    // Clear live-drag visual state — mesh snaps back to its (unchanged)
-    // scene position.
-    clearLiveState(ctx.slabId)
-  },
-}

packages/nodes/src/slab/definition.ts

@@ -58,15 +58,14 @@ export const slabDefinition: NodeDefinition<typeof SlabNode> = {
   // with axis/45° snap (Shift to defeat).
   tool: () => import('./tool'),
 
-  // Stage D — boundary + hole editors ported (thin <PolygonEditor>
-  // wrappers, behaviorally identical to legacy). Whole-slab move kept
-  // on the legacy MoveSlabTool: the live-drag mesh.position port
-  // introduced a one-frame teleport on commit (geometry rebuild lags
-  // the position clear), and the legacy already has acceptable perf
-  // via RAF-batched markDirty.
+  // Stage D — all four slab drag-affordances live in this folder.
+  // boundary-edit / hole-edit are thin <PolygonEditor> wrappers; move
+  // is a 1:1 port of the legacy MoveSlabTool (scene.update per tick
+  // with the same history dance, no live-drag exception).
   affordanceTools: {
     'boundary-edit': () => import('./boundary-editor'),
     'hole-edit': () => import('./hole-editor'),
+    move: () => import('./move-tool'),
   },
 
   // Stage B: pure geometry function.

packages/nodes/src/slab/move-tool.tsx

@@ -1,74 +1,193 @@
 'use client'
 
-import { emitter, type GridEvent, type SlabNode } from '@pascal-app/core'
-import { CursorSphere, triggerSFX, useDragAction, useEditor } from '@pascal-app/editor'
+import {
+  type AnyNodeId,
+  emitter,
+  type FenceNode,
+  type GridEvent,
+  type LevelNode,
+  type SlabNode,
+  useScene,
+  type WallNode,
+} from '@pascal-app/core'
+import {
+  CursorSphere,
+  markToolCancelConsumed,
+  snapFenceDraftPoint,
+  triggerSFX,
+  useEditor,
+} from '@pascal-app/editor'
 import { useViewer } from '@pascal-app/viewer'
-import { useEffect, useMemo, useRef } from 'react'
-import type { Group } from 'three'
-import { moveSlabDragAction } from './actions/move'
+import { useCallback, useEffect, useRef, useState } from 'react'
 
 /**
- * Phase 5 Stage D — thin React wrapper around `moveSlabDragAction`.
+ * Phase 5 Stage D — slab whole-move tool (kind-owned).
  *
- * The cursor sphere follows the raw grid pointer via direct ref mutation
- * (no React state, no per-tick re-render). The slab mesh itself is
- * translated by the action using `mesh.position` + `useLiveTransforms`
- * (live-drag exception). Scene polygon is only written on commit.
+ * 1:1 port of the legacy `MoveSlabTool`. scene.update writes polygon
+ * + holes per tick (renderer keeps up via RAF-batched markDirty),
+ * single-undo dance on commit, cursor at polygon center + delta.
  */
-export const SlabMoveTool: React.FC<{ node: SlabNode }> = ({ node }) => {
-  const slabId = node.id
-  const cursorRef = useRef<Group>(null)
+function translatePolygon(
+  polygon: Array<[number, number]>,
+  deltaX: number,
+  deltaZ: number,
+): Array<[number, number]> {
+  return polygon.map(([x, z]) => [x + deltaX, z + deltaZ] as [number, number])
+}
 
-  const initialCenter: [number, number] = useMemo(() => {
-    if (node.polygon.length === 0) return [0, 0]
-    let sx = 0
-    let sz = 0
-    for (const [x, z] of node.polygon) {
-      sx += x
-      sz += z
-    }
-    return [sx / node.polygon.length, sz / node.polygon.length]
-  }, [node.polygon])
+function getPolygonCenter(polygon: Array<[number, number]>): [number, number] {
+  if (polygon.length === 0) return [0, 0]
+  let sumX = 0
+  let sumZ = 0
+  for (const [x, z] of polygon) {
+    sumX += x
+    sumZ += z
+  }
+  return [sumX / polygon.length, sumZ / polygon.length]
+}
 
-  // Cursor follows the raw grid pointer — direct Three.js mutation,
-  // bypassing React reconciliation for the per-tick position update.
-  useEffect(() => {
-    const onMove = (event: GridEvent) => {
-      if (!cursorRef.current) return
-      cursorRef.current.position.set(
-        event.localPosition[0],
-        event.localPosition[1],
-        event.localPosition[2],
-      )
-    }
-    emitter.on('grid:move', onMove)
-    return () => {
-      emitter.off('grid:move', onMove)
-    }
+export const MoveSlabTool: React.FC<{ node: SlabNode }> = ({ node }) => {
+  const activatedAtRef = useRef<number>(Date.now())
+  const originalPolygonRef = useRef(node.polygon.map(([x, z]) => [x, z] as [number, number]))
+  const originalHolesRef = useRef(
+    (node.holes ?? []).map((hole) => hole.map(([x, z]) => [x, z] as [number, number])),
+  )
+  const dragAnchorRef = useRef<[number, number] | null>(null)
+  const previousGridPosRef = useRef<[number, number] | null>(null)
+  const previewRef = useRef<{
+    polygon: Array<[number, number]>
+    holes: Array<Array<[number, number]>>
+  } | null>(null)
+
+  const [cursorLocalPos, setCursorLocalPos] = useState<[number, number, number]>(() => {
+    const center = getPolygonCenter(node.polygon)
+    return [center[0], 0, center[1]]
+  })
+
+  const exitMoveMode = useCallback(() => {
+    useEditor.getState().setMovingNode(null)
   }, [])
 
-  const exitMoveMode = (committed: boolean) => {
-    if (committed) triggerSFX('sfx:item-place')
-    useViewer.getState().setSelection({ selectedIds: [slabId] })
-    useEditor.getState().setMovingNode(null)
-  }
+  useEffect(() => {
+    const originalPolygon = originalPolygonRef.current
+    const originalHoles = originalHolesRef.current
+    const levelNode =
+      node.parentId && useScene.getState().nodes[node.parentId as AnyNodeId]?.type === 'level'
+        ? (useScene.getState().nodes[node.parentId as AnyNodeId] as LevelNode)
+        : null
+    const levelChildren = levelNode?.children ?? []
+    const levelWalls = levelChildren
+      .map((childId) => useScene.getState().nodes[childId as AnyNodeId])
+      .filter((child): child is WallNode => child?.type === 'wall')
+    const levelFences = levelChildren
+      .map((childId) => useScene.getState().nodes[childId as AnyNodeId])
+      .filter((child): child is FenceNode => child?.type === 'fence')
 
-  useDragAction({
-    active: true,
-    action: moveSlabDragAction,
-    initial: {
-      node,
-      point: initialCenter,
-    },
-    onCommit: () => exitMoveMode(true),
-    onCancel: () => exitMoveMode(false),
-  })
+    useScene.temporal.getState().pause()
+    let wasCommitted = false
+
+    const applyPreview = (
+      polygon: Array<[number, number]>,
+      holes: Array<Array<[number, number]>>,
+    ) => {
+      previewRef.current = { polygon, holes }
+      const center = getPolygonCenter(polygon)
+      setCursorLocalPos([center[0], 0, center[1]])
+      useScene.getState().updateNode(node.id, { polygon, holes })
+      useScene.getState().markDirty(node.id as AnyNodeId)
+    }
+
+    const restoreOriginal = () => {
+      useScene.getState().updateNode(node.id, {
+        holes: originalHoles,
+        polygon: originalPolygon,
+      })
+      useScene.getState().markDirty(node.id as AnyNodeId)
+    }
+
+    const onGridMove = (event: GridEvent) => {
+      const [localX, localZ] = snapFenceDraftPoint({
+        point: [event.localPosition[0], event.localPosition[2]],
+        walls: levelWalls,
+        fences: levelFences,
+      })
+
+      if (
+        previousGridPosRef.current &&
+        (localX !== previousGridPosRef.current[0] || localZ !== previousGridPosRef.current[1])
+      ) {
+        triggerSFX('sfx:grid-snap')
+      }
+      previousGridPosRef.current = [localX, localZ]
+
+      const anchor = dragAnchorRef.current ?? [localX, localZ]
+      dragAnchorRef.current = anchor
+
+      const deltaX = localX - anchor[0]
+      const deltaZ = localZ - anchor[1]
+
+      applyPreview(
+        translatePolygon(originalPolygon, deltaX, deltaZ),
+        originalHoles.map((hole) => translatePolygon(hole, deltaX, deltaZ)),
+      )
+    }
+
+    const onGridClick = (event: GridEvent) => {
+      if (Date.now() - activatedAtRef.current < 150) {
+        event.nativeEvent?.stopPropagation?.()
+        return
+      }
+
+      const preview = previewRef.current ?? { polygon: originalPolygon, holes: originalHoles }
+
+      wasCommitted = true
+
+      // Restore original baseline while paused so the next resume+update
+      // registers as a single tracked change (undo reverts to original).
+      useScene.getState().updateNode(node.id, {
+        polygon: originalPolygon,
+        holes: originalHoles,
+      })
+
+      useScene.temporal.getState().resume()
+      useScene.getState().updateNode(node.id, preview)
+      useScene.getState().markDirty(node.id as AnyNodeId)
+      useScene.temporal.getState().pause()
+
+      triggerSFX('sfx:item-place')
+      useViewer.getState().setSelection({ selectedIds: [node.id] })
+      exitMoveMode()
+      event.nativeEvent?.stopPropagation?.()
+    }
+
+    const onCancel = () => {
+      restoreOriginal()
+      useViewer.getState().setSelection({ selectedIds: [node.id] })
+      useScene.temporal.getState().resume()
+      markToolCancelConsumed()
+      exitMoveMode()
+    }
+
+    emitter.on('grid:move', onGridMove)
+    emitter.on('grid:click', onGridClick)
+    emitter.on('tool:cancel', onCancel)
+
+    return () => {
+      if (!wasCommitted) {
+        restoreOriginal()
+      }
+      useScene.temporal.getState().resume()
+      emitter.off('grid:move', onGridMove)
+      emitter.off('grid:click', onGridClick)
+      emitter.off('tool:cancel', onCancel)
+    }
+  }, [exitMoveMode, node.id, node.parentId, node.polygon])
 
   return (
     <group>
-      <CursorSphere ref={cursorRef} showTooltip={false} />
+      <CursorSphere position={cursorLocalPos} showTooltip={false} />
     </group>
   )
 }
 
-export default SlabMoveTool
+export default MoveSlabTool