@pascal-app/editor 0.9.2 → 1.0.0-beta.2

package/src/components/tools/stair/stair-tool.tsx

@@ -9,12 +9,14 @@ import {
   movingAlignmentAnchors,
   type NodeEvent,
   resolveAlignment,
+  resolveSupportSlabPatch,
   StairNode,
   StairSegmentNode,
   syncAutoStairOpenings,
   useScene,
 } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
+import { useThree } from '@react-three/fiber'
 import { useEffect, useMemo, useRef } from 'react'
 import * as THREE from 'three'
 import { sfxEmitter } from '../../../lib/sfx-bus'
@@ -31,8 +33,11 @@ import useEditor, {
 } from '../../../store/use-editor'
 
 import useFacingPose from '../../../store/use-facing-pose'
+import { useStairBuildPreview } from '../../../store/use-stair-build-preview'
 import { CursorSphere } from '../shared/cursor-sphere'
 import { getFloorStackPreviewPosition } from '../shared/floor-stack-preview'
+import { resolvePointerSupportSurface } from '../shared/pointer-support-cap'
+import { createStairCommitGate, swallowFollowUpBrowserClick } from './stair-click-guard'
 import {
   DEFAULT_CURVED_STAIR_INNER_RADIUS,
   DEFAULT_CURVED_STAIR_SWEEP_ANGLE,
@@ -57,6 +62,7 @@ const GRID_OFFSET = 0.02
 /** Figma-style alignment-snap threshold (meters), matching the move tools. */
 const ALIGNMENT_THRESHOLD_M = 0.08
 type ClickTriggerEvent = GridEvent | NodeEvent<AnyNode>
+type MoveTriggerEvent = GridEvent | NodeEvent<AnyNode>
 
 const CLICK_TRIGGER_KINDS = [
   'shelf',
@@ -149,7 +155,6 @@ function createDefaultStairNode({
     slabOpeningMode: 'destination',
     openingOffset: DEFAULT_STAIR_OPENING_OFFSET,
     width: DEFAULT_STAIR_WIDTH,
-    totalRise: DEFAULT_STAIR_HEIGHT,
     stepCount: DEFAULT_STAIR_STEP_COUNT,
     thickness: DEFAULT_STAIR_THICKNESS,
     fillToFloor: DEFAULT_STAIR_FILL_TO_FLOOR,
@@ -172,6 +177,7 @@ function commitStairPlacement(
   levelId: LevelNode['id'],
   position: [number, number, number],
   rotation: number,
+  supportElevationCap: number | null,
 ): void {
   const { createNodes, nodes } = useScene.getState()
   const placementLevelId = resolveStairPlacementLevelId(
@@ -192,13 +198,27 @@ function commitStairPlacement(
   })
   const nextLevelId = destinationPlan?.toLevel.id ?? placementLevelId
 
-  const stair = createDefaultStairNode({
-    name,
-    levelId: placementLevelId,
-    nextLevelId,
-    position,
-    rotation,
-    segmentId: segment.id,
+  const stair = StairNode.parse({
+    ...createDefaultStairNode({
+      name,
+      levelId: placementLevelId,
+      nextLevelId,
+      position,
+      rotation,
+      segmentId: segment.id,
+    }),
+    parentId: placementLevelId,
+  })
+  const prospectiveNodes = {
+    ...nodes,
+    [stair.id]: stair,
+    [segment.id]: { ...segment, parentId: stair.id },
+  } as Record<string, AnyNode>
+  const committedStair = StairNode.parse({
+    ...stair,
+    ...resolveSupportSlabPatch(stair, prospectiveNodes, {
+      maxElevation: supportElevationCap,
+    }),
   })
 
   const createdLevel = destinationPlan?.createdLevel
@@ -209,17 +229,21 @@ function commitStairPlacement(
 
   createNodes([
     ...levelCreateOps,
-    { node: stair, parentId: placementLevelId },
-    { node: segment, parentId: stair.id },
+    { node: committedStair, parentId: placementLevelId },
+    { node: segment, parentId: committedStair.id },
   ])
 
   sfxEmitter.emit('sfx:structure-build')
 }
 
 export const StairTool: React.FC = () => {
+  const camera = useThree((state) => state.camera)
+  const cameraRef = useRef(camera)
+  cameraRef.current = camera
   const cursorRef = useRef<THREE.Group>(null)
   const previewRef = useRef<THREE.Group>(null)
   const rotationRef = useRef(0)
+  const supportCapRef = useRef<number | null>(null)
   const previousGridPosRef = useRef<[number, number] | null>(null)
   const lastCanonicalPositionRef = useRef<[number, number, number] | null>(null)
   const currentLevelId = useViewer((state) => state.selection.levelId)
@@ -230,11 +254,16 @@ export const StairTool: React.FC = () => {
     if (!currentLevelId) return
 
     const openingPreview = createSurfaceOpeningPreviewController()
+    // Refuses the duplicate commit triggers a single physical click produces
+    // — see `stair-click-guard.ts`. Fresh per armed session.
+    const commitGate = createStairCommitGate()
 
     // Reset rotation when tool activates
     rotationRef.current = 0
+    useStairBuildPreview.getState().reset()
     if (previewRef.current) previewRef.current.rotation.y = 0
     lastCanonicalPositionRef.current = null
+    supportCapRef.current = null
 
     const buildPreviewScene = (position: [number, number, number], rotation: number) => {
       const nodes = useScene.getState().nodes
@@ -281,10 +310,15 @@ export const StairTool: React.FC = () => {
     // cheap because it has no opening sync).
     let lastPreviewKey: string | null = null
 
-    const applyDraftPreview = (position: [number, number, number], rotation: number) => {
-      const key = `${position[0].toFixed(3)},${position[2].toFixed(3)},${rotation.toFixed(4)}`
+    const applyDraftPreview = (
+      position: [number, number, number],
+      rotation: number,
+      supportElevationCap: number | null,
+    ) => {
+      const key = `${position[0].toFixed(3)},${position[2].toFixed(3)},${rotation.toFixed(4)},${supportElevationCap?.toFixed(3) ?? 'none'}`
       if (key === lastPreviewKey) return
       lastPreviewKey = key
+      useStairBuildPreview.getState().setPreview([position[0], position[2]], rotation)
       const preview = buildPreviewScene(position, rotation)
       const visualPosition = preview
         ? getFloorStackPreviewPosition({
@@ -293,6 +327,7 @@ export const StairTool: React.FC = () => {
             rotation,
             levelId: preview.placementLevelId,
             nodes: preview.previewNodes,
+            maxElevation: supportElevationCap,
           })
         : position
       if (cursorRef.current) {
@@ -388,25 +423,34 @@ export const StairTool: React.FC = () => {
       return [x, z]
     }
 
-    const onGridMove = (event: GridEvent) => {
+    const resolveStairPosition = (event: MoveTriggerEvent): [number, number, number] | null => {
+      const pointed = resolvePointerSupportSurface(cameraRef.current, event.position)
+      supportCapRef.current = pointed?.elevation ?? null
+      const fallbackPosition =
+        'node' in event ? lastCanonicalPositionRef.current : event.localPosition
+      if (!pointed?.localPoint && !fallbackPosition) return null
+      const rawX = pointed?.localPoint?.[0] ?? fallbackPosition![0]
+      const rawZ = pointed?.localPoint?.[2] ?? fallbackPosition![2]
       // Grid snap follows the global mode (live step so the HUD chip is
       // honest); Off keeps the raw cursor. Shift cycles the mode centrally.
       const step = useEditor.getState().gridSnapStep
       const [gridX, gridZ] = alignPoint(
-        isGridSnapActive()
-          ? Math.round(event.localPosition[0] / step) * step
-          : event.localPosition[0],
-        isGridSnapActive()
-          ? Math.round(event.localPosition[2] / step) * step
-          : event.localPosition[2],
-        event.localPosition[0],
-        event.localPosition[2],
+        isGridSnapActive() ? Math.round(rawX / step) * step : rawX,
+        isGridSnapActive() ? Math.round(rawZ / step) * step : rawZ,
+        rawX,
+        rawZ,
         !isAlignmentGuideActive(),
         isMagneticSnapActive(),
       )
-      const position: [number, number, number] = [gridX, 0, gridZ]
+      return [gridX, 0, gridZ]
+    }
+
+    const onPointerMove = (event: MoveTriggerEvent) => {
+      const position = resolveStairPosition(event)
+      if (!position) return
+      const [gridX, , gridZ] = position
       lastCanonicalPositionRef.current = position
-      applyDraftPreview(position, rotationRef.current)
+      applyDraftPreview(position, rotationRef.current, supportCapRef.current)
 
       if (
         (isGridSnapActive() || isMagneticSnapActive()) &&
@@ -419,37 +463,28 @@ export const StairTool: React.FC = () => {
       previousGridPosRef.current = [gridX, gridZ]
     }
 
-    const getAlignedGridPosition = (event: GridEvent): [number, number, number] => {
-      const step = useEditor.getState().gridSnapStep
-      const [gridX, gridZ] = alignPoint(
-        isGridSnapActive()
-          ? Math.round(event.localPosition[0] / step) * step
-          : event.localPosition[0],
-        isGridSnapActive()
-          ? Math.round(event.localPosition[2] / step) * step
-          : event.localPosition[2],
-        event.localPosition[0],
-        event.localPosition[2],
-        !isAlignmentGuideActive(),
-        isMagneticSnapActive(),
-      )
-      return [gridX, 0, gridZ]
-    }
-
     const commitAtCursor = (event: ClickTriggerEvent) => {
       if (!currentLevelId) return
+      // One physical click can reach here twice (node click synthesized on
+      // pointerup + the native browser click driving `grid:click`) — see
+      // `stair-click-guard.ts`. The gate refuses anything after a single-
+      // continuation commit; the swallow below eats the same gesture's
+      // follow-up click while the tool stays armed (repeat continuation).
+      if (!commitGate.shouldCommit()) return
       const nodeEvent = 'node' in event ? (event as NodeEvent<AnyNode>) : null
       if (nodeEvent) {
         nodeEvent.stopPropagation()
         nodeEvent.nativeEvent.stopPropagation()
+        // The canvas-level `grid:click` listener is out of stopPropagation's
+        // reach — without this, the browser click that follows this
+        // pointerup-synthesized node click commits a second stair.
+        swallowFollowUpBrowserClick()
       }
 
-      const position = nodeEvent
-        ? lastCanonicalPositionRef.current
-        : getAlignedGridPosition(event as GridEvent)
+      const position = resolveStairPosition(event)
       if (!position) return
 
-      commitStairPlacement(currentLevelId, position, rotationRef.current)
+      commitStairPlacement(currentLevelId, position, rotationRef.current, supportCapRef.current)
       openingPreview.clear()
       // Commit cleared the opening preview, so force the next hover (even on the
       // same cell) to rebuild rather than dedupe against the just-placed key.
@@ -462,8 +497,14 @@ export const StairTool: React.FC = () => {
       if (useEditor.getState().getContinuation('point') === 'repeat') {
         alignmentCandidates = collectAlignmentAnchors(useScene.getState().nodes, '', currentLevelId)
       } else {
+        commitGate.markExited()
         useFacingPose.getState().clear()
         useEditor.getState().setTool(null)
+        // Return to select mode explicitly (matches the spawn tool's exit).
+        // The selection managers route node clicks only while
+        // `mode === 'select'`; exiting with `mode: 'build'` + a null tool
+        // left every click dead until the user pressed Escape.
+        useEditor.getState().setMode('select')
       }
     }
 
@@ -482,34 +523,44 @@ export const StairTool: React.FC = () => {
         sfxEmitter.emit('sfx:item-rotate')
         rotationRef.current += rotationDelta
         if (lastCanonicalPositionRef.current) {
-          applyDraftPreview(lastCanonicalPositionRef.current, rotationRef.current)
+          applyDraftPreview(
+            lastCanonicalPositionRef.current,
+            rotationRef.current,
+            supportCapRef.current,
+          )
         } else if (previewRef.current) {
           previewRef.current.rotation.y = rotationRef.current
         }
       }
     }
 
-    emitter.on('grid:move', onGridMove)
+    emitter.on('grid:move', onPointerMove)
     emitter.on('grid:click', commitAtCursor)
     type SuffixedKey<K extends string> = `${K}:${EventSuffix}`
     type ClickKey = SuffixedKey<(typeof CLICK_TRIGGER_KINDS)[number]>
+    type MoveKey = SuffixedKey<(typeof CLICK_TRIGGER_KINDS)[number]>
     for (const kind of CLICK_TRIGGER_KINDS) {
       const key = `${kind}:click` as ClickKey
       emitter.on(key, commitAtCursor as never)
+      const moveKey = `${kind}:move` as MoveKey
+      emitter.on(moveKey, onPointerMove as never)
     }
     window.addEventListener('keydown', onKeyDown)
 
     return () => {
-      emitter.off('grid:move', onGridMove)
+      emitter.off('grid:move', onPointerMove)
       emitter.off('grid:click', commitAtCursor)
       for (const kind of CLICK_TRIGGER_KINDS) {
         const key = `${kind}:click` as ClickKey
         emitter.off(key, commitAtCursor as never)
+        const moveKey = `${kind}:move` as MoveKey
+        emitter.off(moveKey, onPointerMove as never)
       }
       window.removeEventListener('keydown', onKeyDown)
       useAlignmentGuides.getState().clear()
       openingPreview.clear()
       useFacingPose.getState().clear()
+      useStairBuildPreview.getState().reset()
     }
   }, [currentLevelId])
 

package/src/components/tools/tool-manager.tsx

@@ -1,4 +1,5 @@
 import {
+  type AnyNodeDefinition,
   type AnyNodeId,
   type BuildingNode,
   type CeilingNode,
@@ -10,17 +11,21 @@ import {
 } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
 import { type ComponentType, lazy, Suspense, useMemo } from 'react'
+import { siteBoundaryHandlesEnabled } from '../../lib/site-boundary'
 import useEditor, { type Phase, type Tool } from '../../store/use-editor'
 import {
   useControlPointReshape,
   useEditingHole,
   useEndpointReshape,
   useIsCurveReshape,
+  useIsFloorplanDrivenReshape,
+  useIsToolDrivenReshape,
   useMovingNode,
   useReshapingNode,
   useTangentReshape,
 } from '../../store/use-interaction-scope'
 import { Alignment3DGuideLayer } from '../editor/alignment-3d-guide-layer'
+import { Elevation3DGuideLayer } from '../editor/elevation-3d-guide-layer'
 import { OpeningGuides3DLayer } from '../editor/opening-guides-3d-layer'
 import { WallSnapBeaconLayer } from '../editor/wall-snap-beacon-layer'
 import { ElevatorTool } from './elevator/elevator-tool'
@@ -29,6 +34,7 @@ import { RoofTool } from './roof/roof-tool'
 import { getRegistryAffordanceTool } from './shared/affordance-dispatch'
 import { FacingPoseIndicator } from './shared/facing-pose-indicator'
 import { SiteBoundaryEditor } from './site/site-boundary-editor'
+import { TerrainSculptTool } from './site/terrain-sculpt-tool'
 import { StairTool } from './stair/stair-tool'
 import { ZoneBoundaryEditor } from './zone/zone-boundary-editor'
 import { ZoneTool } from './zone/zone-tool'
@@ -36,6 +42,29 @@ import { ZoneTool } from './zone/zone-tool'
 // Cache lazy tool components keyed by their loader so React.lazy isn't
 // re-invoked across renders.
 const lazyToolCache = new WeakMap<() => Promise<unknown>, ComponentType>()
+const registryToolPreloadCache = new WeakMap<AnyNodeDefinition, Promise<void>>()
+
+export function preloadRegistryToolModules(tool: string | null): Promise<void> {
+  if (!tool) return Promise.resolve()
+  const def = nodeRegistry.get(tool)
+  if (!def) return Promise.resolve()
+  const cached = registryToolPreloadCache.get(def)
+  if (cached) return cached
+
+  const loaders: Array<() => Promise<unknown>> = []
+  if (def.tool) loaders.push(def.tool)
+  if (def.preview) loaders.push(def.preview)
+  if (def.renderer?.kind === 'parametric') loaders.push(def.renderer.module)
+  if (def.system) loaders.push(def.system.module)
+  if (def.parametrics?.customPanel) loaders.push(def.parametrics.customPanel)
+  if (def.parametrics?.trailingSection) loaders.push(def.parametrics.trailingSection)
+  const moveTool = def.affordanceTools?.move
+  if (moveTool) loaders.push(moveTool)
+
+  const preload = Promise.allSettled(loaders.map((loader) => loader())).then(() => undefined)
+  registryToolPreloadCache.set(def, preload)
+  return preload
+}
 
 function getRegistryTool(tool: Tool | null): ComponentType | null {
   if (!tool) return null
@@ -43,7 +72,13 @@ function getRegistryTool(tool: Tool | null): ComponentType | null {
   if (!def?.tool) return null
   const cached = lazyToolCache.get(def.tool)
   if (cached) return cached
-  const Comp = lazy(def.tool as () => Promise<{ default: ComponentType }>)
+  const Comp = lazy(async () => {
+    // Placement can only begin once the node's preview, committed renderer,
+    // inspector, and move contribution are warm. This keeps the click itself
+    // synchronous even under Next.js dev-time on-demand compilation.
+    await preloadRegistryToolModules(tool)
+    return def.tool!() as Promise<{ default: ComponentType }>
+  })
   lazyToolCache.set(def.tool, Comp)
   return Comp
 }
@@ -73,6 +108,8 @@ export const ToolManager: React.FC = () => {
   const controlPointReshape = useControlPointReshape()
   const tangentReshape = useTangentReshape()
   const isCurveReshape = useIsCurveReshape()
+  const isToolDrivenReshape = useIsToolDrivenReshape()
+  const isFloorplanDrivenReshape = useIsFloorplanDrivenReshape()
   const reshapingNode = useReshapingNode()
   // The endpoint affordance tool's `target` is kind-specific
   // (`{ wall | fence, endpoint }`); rebuild it from the (frozen) reshaped node +
@@ -128,9 +165,14 @@ export const ToolManager: React.FC = () => {
     | CeilingNode['id']
     | undefined
 
-  // Keep the site vertex flags available in select mode; the editor component
-  // switches to full polygon editing only after a flag activates site mode.
-  const showSiteBoundaryEditor = phase === 'site' || mode === 'select'
+  // Site boundary handles normally share one 2D/3D rule. Sculpt is the deliberate
+  // 3D exception: the brush only owns this canvas, where PolygonEditor can hand
+  // off its pointer before a boundary drag starts.
+  const sculpting = mode === 'terrain-sculpt'
+  // Sculpt keeps the 3D property controls visible. PolygonEditor marks its
+  // pointer before the canvas-level brush listener runs, and activating one
+  // exits sculpt mode before starting the boundary drag.
+  const showSiteBoundaryEditor = sculpting || siteBoundaryHandlesEnabled({ mode, phase })
 
   // A multi-selection is manipulated as one rigid group (drag / R / T), so
   // per-node reshape chrome — the slab / ceiling boundary editors' vertex and
@@ -143,6 +185,7 @@ export const ToolManager: React.FC = () => {
     mode === 'select' &&
     isSoleSelection &&
     selectedSlabId !== undefined &&
+    !isFloorplanDrivenReshape &&
     !editingSlabHoleIsManual
 
   // Show slab hole editor when editing a hole on the selected slab
@@ -150,6 +193,7 @@ export const ToolManager: React.FC = () => {
     selectedSlabId !== undefined &&
     editingHole !== null &&
     editingHole.nodeId === selectedSlabId &&
+    !isFloorplanDrivenReshape &&
     editingSlabHoleIsManual
 
   // Show ceiling boundary editor when in structure/select mode with a ceiling selected (but not editing a hole)
@@ -158,13 +202,15 @@ export const ToolManager: React.FC = () => {
     mode === 'select' &&
     isSoleSelection &&
     selectedCeilingId !== undefined &&
+    !isFloorplanDrivenReshape &&
     (!editingHole || editingHole.nodeId !== selectedCeilingId)
 
   // Show ceiling hole editor when editing a hole on the selected ceiling
   const showCeilingHoleEditor =
     selectedCeilingId !== undefined &&
     editingHole !== null &&
-    editingHole.nodeId === selectedCeilingId
+    editingHole.nodeId === selectedCeilingId &&
+    !isFloorplanDrivenReshape
 
   // Show zone boundary editor when in structure/select mode with a zone selected
   // Hide when editing a slab or ceiling to avoid overlapping handles
@@ -172,6 +218,7 @@ export const ToolManager: React.FC = () => {
     phase === 'structure' &&
     mode === 'select' &&
     selectedZoneId !== null &&
+    !isFloorplanDrivenReshape &&
     !showSlabBoundaryEditor &&
     !showCeilingBoundaryEditor
 
@@ -217,6 +264,10 @@ export const ToolManager: React.FC = () => {
     <>
       {/* World-space tools: site boundary and building movement operate in world coordinates */}
       {showSiteBoundaryEditor && <SiteBoundaryEditor />}
+      {/* Terrain sculpting is a mode rather than a `tools[phase][tool]` entry —
+          it places no node — so it gets its own gate here. World-space, because
+          the ground is not building-local. */}
+      {sculpting && <TerrainSculptTool />}
       {showMover && movingNode?.type === 'building' && (
         <MoveTool onNodeMoved={handlePlacedNodeSelected} onSpawnMoved={handlePlacedNodeSelected} />
       )}
@@ -271,7 +322,8 @@ export const ToolManager: React.FC = () => {
               </Suspense>
             ) : null
           })()}
-        {endpointTarget &&
+        {isToolDrivenReshape &&
+          endpointTarget &&
           reshapingNode &&
           (() => {
             const RegistryAffordance = getRegistryAffordanceTool(
@@ -284,7 +336,8 @@ export const ToolManager: React.FC = () => {
               </Suspense>
             ) : null
           })()}
-        {isCurveReshape &&
+        {isToolDrivenReshape &&
+          isCurveReshape &&
           reshapingNode &&
           (() => {
             const RegistryAffordance = getRegistryAffordanceTool(reshapingNode.type, 'curve')
@@ -294,7 +347,8 @@ export const ToolManager: React.FC = () => {
               </Suspense>
             ) : null
           })()}
-        {controlPointTarget &&
+        {isToolDrivenReshape &&
+          controlPointTarget &&
           (() => {
             const RegistryAffordance = getRegistryAffordanceTool('fence', 'move-control-point')
             return RegistryAffordance ? (
@@ -303,7 +357,8 @@ export const ToolManager: React.FC = () => {
               </Suspense>
             ) : null
           })()}
-        {tangentTarget &&
+        {isToolDrivenReshape &&
+          tangentTarget &&
           (() => {
             const RegistryAffordance = getRegistryAffordanceTool('fence', 'move-tangent')
             return RegistryAffordance ? (
@@ -344,6 +399,9 @@ export const ToolManager: React.FC = () => {
         {/* Wall-plane proximity / sill / equal-spacing guides for openings,
             published by the door/window move tools in the same world frame. */}
         <OpeningGuides3DLayer />
+        {/* Structural Y-datum feedback for slab, ceiling, wall, and fence
+            elevation handles. Ephemeral editor chrome; never scene data. */}
+        <Elevation3DGuideLayer />
         {/* "Magnetic" beacon at the active wall-draft snap point. */}
         <WallSnapBeaconLayer />
       </group>

package/src/components/tools/wall/wall-drafting.test.ts

@@ -2,8 +2,14 @@ import { beforeEach, describe, expect, test } from 'bun:test'
 import {
   type AnyNode,
   type AnyNodeId,
+  applyHeightPatch,
+  createTerrainField,
   DoorNode as DoorSchema,
+  encodeTerrainField,
+  flattenPatch,
+  GROUND_SUPPORT_ID,
   runAsSingleSceneHistoryStep,
+  spatialGridManager,
   useScene,
   type WallNode,
   WallNode as WallSchema,
@@ -14,6 +20,7 @@ import useInteractionScope from '../../../store/use-interaction-scope'
 import {
   createWallOnCurrentLevel,
   resolveEndpointWallSplit,
+  resolveTerrainWallConstructionOptions,
   snapWallDraftPointDetailed,
 } from './wall-drafting'
 import type { WallPlanPoint } from './wall-snap-geometry'
@@ -86,7 +93,7 @@ describe('createWallOnCurrentLevel', () => {
     useEditor.getState().setSnappingMode('wall', 'lines')
     useInteractionScope
       .getState()
-      .begin({ kind: 'reshaping', nodeId: 'wall_a', reshape: 'endpoint' })
+      .begin({ kind: 'reshaping', nodeId: 'wall_a', reshape: 'endpoint', driver: 'tool' })
     seedLevel([makeWall([0, 0], [4, 0], 'wall_a')])
     useScene.temporal.getState().clear()
     useScene.temporal.getState().resume()
@@ -102,6 +109,83 @@ describe('createWallOnCurrentLevel', () => {
     expect(levelWalls()).toHaveLength(2)
   })
 
+  test('committed wall preserves the ghost construction elevation on ground', () => {
+    const created = createWallOnCurrentLevel([2, 2], [3, 2], {
+      supportCap: 1.75,
+      preferredSupportSlabId: GROUND_SUPPORT_ID,
+      constructionElevation: 1.75,
+      constructionHeight: 2.5,
+    })
+
+    expect(created?.supportSlabId).toBe(GROUND_SUPPORT_ID)
+    expect(created?.supportOffset).toBe(1.75)
+    expect(created?.height).toBe(2.5)
+    const support = spatialGridManager.getSlabSupportForWall(
+      LEVEL_ID,
+      created?.start ?? [0, 0],
+      created?.end ?? [0, 0],
+      created?.curveOffset,
+      created?.thickness,
+      created?.supportSlabId,
+      undefined,
+      created?.supportOffset,
+    )
+    expect(support.elevation).toBe(1.75)
+  })
+
+  test('2D terrain construction options freeze the first-point elevation and wall height', () => {
+    const field = createTerrainField({ cols: 5, rows: 5, spacing: 1, origin: [-2, -2] })
+    const patch = flattenPatch(field, { minX: -2, minZ: -2, maxX: 2, maxZ: 2 }, 1.5)
+    if (!patch) throw new Error('Expected terrain patch')
+    const terrain = applyHeightPatch(field, patch)
+    const site = {
+      id: 'site_test',
+      type: 'site',
+      object: 'node',
+      parentId: null,
+      visible: true,
+      metadata: {},
+      children: ['building_test'],
+      terrain: encodeTerrainField(terrain),
+    } as unknown as AnyNode
+    const building = {
+      id: 'building_test',
+      type: 'building',
+      object: 'node',
+      parentId: site.id,
+      visible: true,
+      metadata: {},
+      children: [LEVEL_ID],
+      position: [0, 0, 0],
+      rotation: [0, 0, 0],
+    } as AnyNode
+    const level = {
+      id: LEVEL_ID,
+      type: 'level',
+      object: 'node',
+      parentId: building.id,
+      visible: true,
+      metadata: {},
+      children: [],
+      level: 0,
+      height: 3,
+    } as AnyNode
+    const nodes = Object.fromEntries([site, building, level].map((node) => [node.id, node]))
+
+    expect(resolveTerrainWallConstructionOptions(nodes, LEVEL_ID, [0, 0])).toEqual({
+      constructionElevation: 1.5,
+      constructionHeight: 3,
+      supportCap: 1.5,
+    })
+    expect(
+      resolveTerrainWallConstructionOptions(nodes, LEVEL_ID, [0, 0], { height: 2.25 }),
+    ).toEqual({
+      constructionElevation: 1.5,
+      constructionHeight: 2.25,
+      supportCap: 1.5,
+    })
+  })
+
   test('endpoint near the host start corner snaps there without splitting', () => {
     const created = createWallOnCurrentLevel([2, 2], [0.015, 0])
 
@@ -326,5 +410,38 @@ describe('snapWallDraftPointDetailed', () => {
 
     expect(result.point).toEqual([3.99, 0.03])
     expect(result.snap).toBeNull()
+    expect(result.targetWallIds).toEqual([])
+  })
+
+  // Endpoint-move regression: walls attached to the moving corner keep their
+  // pre-drag coordinates in the scene during the drag, so their stale corner
+  // recreates the old junction inside the connect radius. The move tools must
+  // pass those walls in `ignoreWallIds` (attached mode) or a sub-5cm corner
+  // correction — e.g. squaring a scan-imported 91° junction — can never land.
+  test('a stale linked-wall corner swallows a sub-connect-radius correction unless ignored', () => {
+    // `wall_d` shares the dragged corner of `wall_c` at [2, 0.03]; the user
+    // drops 3cm away at [2, 0] to square the junction.
+    const linked = makeWall([2, 0.03], [2, 2], 'wall_d')
+
+    const captured = snapWallDraftPointDetailed({
+      point: [2, 0],
+      walls: [linked],
+      ignoreWallIds: ['wall_c'],
+      magnetic: false,
+      step: 0,
+    })
+    expect(captured.point).toEqual([2, 0.03])
+    expect(captured.snap).toBe('endpoint')
+    expect(captured.targetWallIds).toEqual(['wall_d'])
+
+    const freed = snapWallDraftPointDetailed({
+      point: [2, 0],
+      walls: [linked],
+      ignoreWallIds: ['wall_c', 'wall_d'],
+      magnetic: false,
+      step: 0,
+    })
+    expect(freed.point).toEqual([2, 0])
+    expect(freed.snap).toBeNull()
   })
 })