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/wall/actions/curve.ts

@@ -1,83 +0,0 @@
-import {
-  type AnyNode,
-  type AnyNodeId,
-  type DragAction,
-  getClampedWallCurveOffset,
-  getMaxWallCurveOffset,
-  getWallChordFrame,
-  normalizeWallCurveOffset,
-  type WallNode,
-} from '@pascal-app/core'
-
-/**
- * Phase 5 Stage D — curve-wall drag affordance.
- *
- * Mirrors `fence/actions/curve.ts`. Same chord-perpendicular projection,
- * same clamp/normalize, same single-undo dance on commit. The only
- * meaningful difference is the wall's snap-step-aware preview (the
- * legacy CurveWallTool snapped the pointer position to `getWallGridStep`
- * before projecting). We rely on the wall snap services existing in
- * the wall-drafting module — exposing those here would bloat the
- * surface, so we accept the slight precision difference for now (the
- * normalized offset is what zundo records anyway).
- */
-
-type CurveWallCtx = {
-  nodeId: AnyNodeId
-  originalCurveOffset: number
-  chord: ReturnType<typeof getWallChordFrame>
-  maxCurveOffset: number
-  startNode: WallNode
-}
-
-type CurveWallDraft = {
-  curveOffset: number
-}
-
-export const curveWallDragAction: DragAction<CurveWallCtx, CurveWallDraft> = {
-  begin: (input) => {
-    const node = input.node as WallNode | undefined
-    if (!node) throw new Error('[curveWallDragAction] begin requires a wall node')
-    return {
-      nodeId: node.id as AnyNodeId,
-      originalCurveOffset: getClampedWallCurveOffset(node),
-      chord: getWallChordFrame(node),
-      maxCurveOffset: getMaxWallCurveOffset(node),
-      startNode: node,
-    }
-  },
-
-  preview: (ctx, point) => {
-    const [px, pz] = point
-    const offset = -(
-      (px - ctx.chord.midpoint.x) * ctx.chord.normal.x +
-      (pz - ctx.chord.midpoint.y) * ctx.chord.normal.y
-    )
-    return { curveOffset: offset }
-  },
-
-  snap: (draft, ctx, _services) => {
-    const clamped = Math.max(-ctx.maxCurveOffset, Math.min(ctx.maxCurveOffset, draft.curveOffset))
-    return { curveOffset: normalizeWallCurveOffset(ctx.startNode, clamped) }
-  },
-
-  apply: (draft, ctx, scene) => {
-    scene.update(ctx.nodeId, { curveOffset: draft.curveOffset } as Partial<AnyNode>)
-    scene.markDirty(ctx.nodeId)
-    return [ctx.nodeId]
-  },
-
-  commit: (draft, ctx, scene) => {
-    // Always push a pastState entry — see fence/actions/curve.ts for
-    // the rationale (no-op-bend would otherwise let Ctrl-Z cancel the
-    // wall creation).
-    scene.restoreAll()
-    scene.resumeHistory()
-    scene.update(ctx.nodeId, { curveOffset: draft.curveOffset } as Partial<AnyNode>)
-    return true
-  },
-
-  cancel: (_ctx, _scene) => {
-    // No-op — orchestrator restores via snapshot.
-  },
-}

packages/nodes/src/wall/curve-tool.tsx

@@ -1,62 +1,191 @@
 'use client'
 
-import { getWallMidpointHandlePoint, useScene, type WallNode } from '@pascal-app/core'
-import { CursorSphere, triggerSFX, useDragAction, useEditor } from '@pascal-app/editor'
+import {
+  type AnyNodeId,
+  emitter,
+  type GridEvent,
+  getClampedWallCurveOffset,
+  getMaxWallCurveOffset,
+  getWallChordFrame,
+  getWallMidpointHandlePoint,
+  normalizeWallCurveOffset,
+  useScene,
+  type WallNode,
+} from '@pascal-app/core'
+import {
+  CursorSphere,
+  getWallGridStep,
+  markToolCancelConsumed,
+  snapScalarToGrid,
+  triggerSFX,
+  useEditor,
+} from '@pascal-app/editor'
 import { useViewer } from '@pascal-app/viewer'
-import { useEffect, useState } from 'react'
-import { curveWallDragAction } from './actions/curve'
+import { useCallback, useEffect, useRef, useState } from 'react'
 
 /**
- * Phase 5 Stage D — thin React wrapper around `curveWallDragAction`.
+ * Phase 5 Stage D — wall curve tool (kind-owned).
  *
- * Replaces the legacy `CurveWallTool` (178 LoC). Same UX as the fence
- * curve port — cursor sphere follows the chord-perpendicular projection
- * of the pointer, dragging the wall's `curveOffset` live; grid:click
- * commits with the single-undo dance, Esc cancels.
- *
- * Mounted by ToolManager via `def.affordanceTools.curve` when
- * `useEditor.curvingWall` activates.
+ * 1:1 port of the legacy `CurveWallTool`. Same snap pipeline, Shift
+ * override, history dance, activation grace. The wall variant uses
+ * `useScene.temporal.getState().pause()` / `.resume()` directly rather
+ * than the depth-counted `pauseSceneHistory` helpers — matches legacy.
  */
-export const WallCurveTool: React.FC<{ node: WallNode }> = ({ node }) => {
+export const CurveWallTool: React.FC<{ node: WallNode }> = ({ node }) => {
+  const activatedAtRef = useRef<number>(Date.now())
+  const originalCurveOffsetRef = useRef(getClampedWallCurveOffset(node))
+  const previousCurveOffsetRef = useRef<number | null>(null)
+  const shiftPressedRef = useRef(false)
+  const previewOffsetRef = useRef<number>(originalCurveOffsetRef.current)
+
   const initialHandle = getWallMidpointHandlePoint(node)
-  const [cursorPos, setCursorPos] = useState<[number, number, number]>([
+  const [cursorLocalPos, setCursorLocalPos] = useState<[number, number, number]>([
     initialHandle.x,
     0,
     initialHandle.y,
   ])
 
-  const exitCurveMode = (committed: boolean) => {
-    if (committed) triggerSFX('sfx:item-place')
-    useViewer.getState().setSelection({ selectedIds: [node.id] })
+  const exitCurveMode = useCallback(() => {
     useEditor.getState().setCurvingWall(null)
-  }
-
-  useDragAction({
-    active: true,
-    action: curveWallDragAction,
-    initial: {
-      node,
-      point: [initialHandle.x, initialHandle.y],
-    },
-    onCommit: () => exitCurveMode(true),
-    onCancel: () => exitCurveMode(false),
-  })
-
-  const liveCurveOffset = useScene((s) => {
-    const live = s.nodes[node.id]
-    return live?.type === 'wall' ? ((live as WallNode).curveOffset ?? 0) : 0
-  })
+  }, [])
 
   useEffect(() => {
-    const handlePoint = getWallMidpointHandlePoint({ ...node, curveOffset: liveCurveOffset })
-    setCursorPos([handlePoint.x, 0, handlePoint.y])
-  }, [liveCurveOffset, node])
+    const nodeId = node.id
+    const originalCurveOffset = originalCurveOffsetRef.current
+    const chord = getWallChordFrame(node)
+    const maxCurveOffset = getMaxWallCurveOffset(node)
+
+    useScene.temporal.getState().pause()
+    let wasCommitted = false
+
+    const applyPreview = (curveOffset: number) => {
+      if (previewOffsetRef.current === curveOffset) {
+        return
+      }
+      previewOffsetRef.current = curveOffset
+
+      const nextNode = {
+        ...node,
+        curveOffset,
+      }
+      const handlePoint = getWallMidpointHandlePoint(nextNode)
+      setCursorLocalPos([handlePoint.x, 0, handlePoint.y])
+      useScene.getState().updateNode(nodeId, { curveOffset })
+      useScene.getState().markDirty(nodeId as AnyNodeId)
+    }
+
+    const restoreOriginal = () => {
+      if (previewOffsetRef.current === originalCurveOffset) {
+        return
+      }
+      previewOffsetRef.current = originalCurveOffset
+      useScene.getState().updateNode(nodeId, { curveOffset: originalCurveOffset })
+      useScene.getState().markDirty(nodeId as AnyNodeId)
+    }
+
+    const onGridMove = (event: GridEvent) => {
+      const snapStep = getWallGridStep()
+      const localX = shiftPressedRef.current
+        ? event.localPosition[0]
+        : snapScalarToGrid(event.localPosition[0], snapStep)
+      const localZ = shiftPressedRef.current
+        ? event.localPosition[2]
+        : snapScalarToGrid(event.localPosition[2], snapStep)
+
+      const offsetFromMidpoint = -(
+        (localX - chord.midpoint.x) * chord.normal.x +
+        (localZ - chord.midpoint.y) * chord.normal.y
+      )
+      const snappedOffset = shiftPressedRef.current
+        ? offsetFromMidpoint
+        : snapScalarToGrid(offsetFromMidpoint, snapStep)
+      const nextCurveOffset = normalizeWallCurveOffset(
+        node,
+        Math.max(-maxCurveOffset, Math.min(maxCurveOffset, snappedOffset)),
+      )
+
+      if (
+        previousCurveOffsetRef.current !== null &&
+        nextCurveOffset !== previousCurveOffsetRef.current
+      ) {
+        triggerSFX('sfx:grid-snap')
+      }
+      previousCurveOffsetRef.current = nextCurveOffset
+
+      applyPreview(nextCurveOffset)
+    }
+
+    const onGridClick = (event: GridEvent) => {
+      if (Date.now() - activatedAtRef.current < 150) {
+        event.nativeEvent?.stopPropagation?.()
+        return
+      }
+
+      const curveOffset = previewOffsetRef.current
+      wasCommitted = true
+
+      if (curveOffset !== originalCurveOffset) {
+        // Restore original baseline while paused so the next resume+update
+        // registers as a single tracked change (undo reverts to original).
+        useScene.getState().updateNode(nodeId, { curveOffset: originalCurveOffset })
+        useScene.getState().markDirty(nodeId as AnyNodeId)
+
+        useScene.temporal.getState().resume()
+        useScene.getState().updateNode(nodeId, { curveOffset })
+        useScene.getState().markDirty(nodeId as AnyNodeId)
+        useScene.temporal.getState().pause()
+      }
+
+      triggerSFX('sfx:item-place')
+      useViewer.getState().setSelection({ selectedIds: [nodeId] })
+      exitCurveMode()
+      event.nativeEvent?.stopPropagation?.()
+    }
+
+    const onCancel = () => {
+      restoreOriginal()
+      useViewer.getState().setSelection({ selectedIds: [nodeId] })
+      useScene.temporal.getState().resume()
+      markToolCancelConsumed()
+      exitCurveMode()
+    }
+
+    const onKeyDown = (event: KeyboardEvent) => {
+      if (event.key === 'Shift') {
+        shiftPressedRef.current = true
+      }
+    }
+
+    const onKeyUp = (event: KeyboardEvent) => {
+      if (event.key === 'Shift') {
+        shiftPressedRef.current = false
+      }
+    }
+
+    emitter.on('grid:move', onGridMove)
+    emitter.on('grid:click', onGridClick)
+    emitter.on('tool:cancel', onCancel)
+    window.addEventListener('keydown', onKeyDown)
+    window.addEventListener('keyup', onKeyUp)
+
+    return () => {
+      if (!wasCommitted) {
+        restoreOriginal()
+      }
+      useScene.temporal.getState().resume()
+      emitter.off('grid:move', onGridMove)
+      emitter.off('grid:click', onGridClick)
+      emitter.off('tool:cancel', onCancel)
+      window.removeEventListener('keydown', onKeyDown)
+      window.removeEventListener('keyup', onKeyUp)
+    }
+  }, [exitCurveMode, node])
 
   return (
     <group>
-      <CursorSphere position={cursorPos} showTooltip={false} />
+      <CursorSphere position={cursorLocalPos} showTooltip={false} />
     </group>
   )
 }
 
-export default WallCurveTool
+export default CurveWallTool

packages/nodes/src/wall/definition.ts

@@ -57,14 +57,14 @@ export const wallDefinition: NodeDefinition<typeof WallNode> = {
 
   parametrics: wallParametrics,
 
-  // Stage D — deferred for wall. The curve port (`curve-tool.tsx` +
-  // `actions/curve.ts`) needs more work to match the legacy
-  // CurveWallTool's UX (pre-snap on pointer position, 0.5m grid step,
-  // Shift override, smooth scene.update without cascade overhead).
-  // Legacy fallback runs until that lands. Endpoint move / whole-wall
-  // move / placement are all still legacy too — they're the biggest
-  // tools and have linked-wall corner cascade logic that needs a
-  // careful port.
+  // Stage D — wall curve is a 1:1 port of the legacy CurveWallTool,
+  // relocated into this folder and dispatched via the registry. Endpoint
+  // move (linked-wall corner cascade + ALT-detach), whole-wall move, and
+  // placement are still legacy — they're substantially larger and queued
+  // for separate port passes.
+  affordanceTools: {
+    curve: () => import('./curve-tool'),
+  },
 
   renderer: {
     kind: 'parametric',