@pascal-app/editor 0.4.0 → 0.5.1

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

@@ -33,6 +33,7 @@ import { distance, smoothstep, uv, vec2 } from 'three/tsl'
 import { LineBasicNodeMaterial, MeshBasicNodeMaterial } from 'three/webgpu'
 import { EDITOR_LAYER } from '../../../lib/constants'
 import { sfxEmitter } from '../../../lib/sfx-bus'
+import { snapToGrid } from './placement-math'
 import {
   ceilingStrategy,
   checkCanPlace,
@@ -68,7 +69,7 @@ const radialOpacity = smoothstep(0, 0.7, dist).mul(0.6)
 basePlaneMaterial.opacityNode = radialOpacity
 
 export interface PlacementCoordinatorConfig {
-  asset: AssetInput
+  asset: AssetInput | null
   draftNode: DraftNodeHandle
   initDraft: (gridPosition: Vector3) => void
   onCommitted: () => boolean
@@ -83,6 +84,7 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
   const edgesRef = useRef<LineSegments>(null!)
   const basePlaneRef = useRef<Mesh>(null!)
   const gridPosition = useRef(new Vector3(0, 0, 0))
+  const lastRawPos = useRef(new Vector3(0, 0, 0))
   const placementState = useRef<PlacementState>(
     config.initialState ?? { surface: 'floor', wallId: null, ceilingId: null, surfaceItemId: null },
   )
@@ -96,6 +98,7 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
   const { asset, draftNode } = config
 
   useEffect(() => {
+    if (!asset) return
     useScene.temporal.getState().pause()
 
     const validators = { canPlaceOnFloor, canPlaceOnWall, canPlaceOnCeiling }
@@ -135,11 +138,21 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
       return placeable
     }
 
+    // Tool visuals are rendered inside the building-local ToolManager group, so all cursor
+    // positions must be in building-local space. Wall/ceiling/item-surface strategies return
+    // world-space cursor positions (from their event.position); convert them here.
+    const worldToBuildingLocal = (x: number, y: number, z: number): Vector3 => {
+      const buildingId = useViewer.getState().selection.buildingId
+      const buildingMesh = buildingId ? sceneRegistry.nodes.get(buildingId as AnyNodeId) : null
+      return buildingMesh ? buildingMesh.worldToLocal(new Vector3(x, y, z)) : new Vector3(x, y, z)
+    }
+
     const applyTransition = (result: TransitionResult) => {
       Object.assign(placementState.current, result.stateUpdate)
       gridPosition.current.set(...result.gridPosition)
 
-      cursorGroupRef.current.position.set(...result.cursorPosition)
+      const c = worldToBuildingLocal(...result.cursorPosition)
+      cursorGroupRef.current.position.set(c.x, c.y, c.z)
       cursorGroupRef.current.rotation.y = result.cursorRotationY
 
       const draft = draftNode.current
@@ -152,7 +165,8 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
 
     const ensureDraft = (result: TransitionResult) => {
       gridPosition.current.set(...result.gridPosition)
-      cursorGroupRef.current.position.set(...result.cursorPosition)
+      const c = worldToBuildingLocal(...result.cursorPosition)
+      cursorGroupRef.current.position.set(c.x, c.y, c.z)
       cursorGroupRef.current.rotation.y = result.cursorRotationY
 
       draftNode.create(
@@ -181,7 +195,10 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
     if (draftNode.current) {
       const mesh = sceneRegistry.nodes.get(draftNode.current.id)
       if (mesh) {
-        mesh.getWorldPosition(cursorGroupRef.current.position)
+        const worldPos = new Vector3()
+        mesh.getWorldPosition(worldPos)
+        const localPos = worldToBuildingLocal(worldPos.x, worldPos.y, worldPos.z)
+        cursorGroupRef.current.position.copy(localPos)
         // Extract world Y rotation (handles wall-parented items correctly)
         const q = new Quaternion()
         mesh.getWorldQuaternion(q)
@@ -216,6 +233,7 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
       // Only update X and Z for cursor - useFrame will handle Y (slab elevation)
       cursorGroupRef.current.position.x = result.cursorPosition[0]
       cursorGroupRef.current.position.z = result.cursorPosition[2]
+      lastRawPos.current.set(event.localPosition[0], event.localPosition[1], event.localPosition[2])
 
       const draft = draftNode.current
       if (draft) draft.position = result.gridPosition
@@ -334,7 +352,8 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
       }
 
       gridPosition.current.set(...result.gridPosition)
-      cursorGroupRef.current.position.set(...result.cursorPosition)
+      const wc = worldToBuildingLocal(...result.cursorPosition)
+      cursorGroupRef.current.position.set(wc.x, wc.y, wc.z)
       cursorGroupRef.current.rotation.y = result.cursorRotationY
 
       const draft = draftNode.current
@@ -486,7 +505,9 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
       event.stopPropagation()
 
       gridPosition.current.set(...result.gridPosition)
-      cursorGroupRef.current.position.set(...result.cursorPosition)
+      lastRawPos.current.set(event.position[0], event.position[1], event.position[2])
+      const ic = worldToBuildingLocal(...result.cursorPosition)
+      cursorGroupRef.current.position.set(ic.x, ic.y, ic.z)
       cursorGroupRef.current.rotation.y = result.cursorRotationY
 
       const draft = draftNode.current
@@ -511,14 +532,15 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
 
       event.stopPropagation()
 
-      // Transition back to floor using event world position
-      const wx = Math.round(event.position[0] * 2) / 2
-      const wz = Math.round(event.position[2] * 2) / 2
+      // Transition back to floor using building-local position
+      const wx = Math.round(event.localPosition[0] * 2) / 2
+      const wz = Math.round(event.localPosition[2] * 2) / 2
       const floorPos: [number, number, number] = [wx, 0, wz]
 
       Object.assign(placementState.current, { surface: 'floor', surfaceItemId: null })
       gridPosition.current.set(wx, 0, wz)
-      cursorGroupRef.current.position.set(wx, event.position[1], wz)
+      cursorGroupRef.current.position.x = wx
+      cursorGroupRef.current.position.z = wz
 
       const draft = draftNode.current
       if (draft) {
@@ -603,7 +625,9 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
       }
 
       gridPosition.current.set(...result.gridPosition)
-      cursorGroupRef.current.position.set(...result.cursorPosition)
+      lastRawPos.current.set(event.position[0], event.position[1], event.position[2])
+      const cc = worldToBuildingLocal(...result.cursorPosition)
+      cursorGroupRef.current.position.set(cc.x, cc.y, cc.z)
 
       revalidate()
 
@@ -677,6 +701,11 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
 
     const ROTATION_STEP = Math.PI / 2
     const onKeyDown = (event: KeyboardEvent) => {
+      // Don't intercept keys when focus is inside a text input
+      if (event.target instanceof HTMLInputElement || event.target instanceof HTMLTextAreaElement) {
+        return
+      }
+
       if (event.key === 'Shift') {
         shiftFreeRef.current = true
         revalidate()
@@ -702,11 +731,55 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
         const mesh = sceneRegistry.nodes.get(draft.id)
         if (mesh) mesh.rotation.y = newRotationY
 
-        // Update live transform rotation for 2D floorplan
+        // Re-snap position immediately with updated rotation (dimX/dimZ may swap at 90°)
+        const surface = placementState.current.surface
+        if (surface === 'floor' || surface === 'ceiling') {
+          const dims = getScaledDimensions(draft)
+          const [dimX, , dimZ] = dims
+          const swapDims = Math.abs(Math.sin(newRotationY)) > 0.9
+          const x = snapToGrid(lastRawPos.current.x, swapDims ? dimZ : dimX)
+          const z = snapToGrid(lastRawPos.current.z, swapDims ? dimX : dimZ)
+          gridPosition.current.set(x, gridPosition.current.y, z)
+          draft.position = [x, gridPosition.current.y, z]
+          cursorGroupRef.current.position.x = x
+          cursorGroupRef.current.position.z = z
+          if (mesh) {
+            mesh.position.x = x
+            mesh.position.z = z
+          }
+        } else if (surface === 'item-surface' && placementState.current.surfaceItemId) {
+          const surfaceMesh = sceneRegistry.nodes.get(placementState.current.surfaceItemId)
+          if (surfaceMesh) {
+            const localPos = surfaceMesh.worldToLocal(lastRawPos.current.clone())
+            const dims = getScaledDimensions(draft)
+            const [dimX, , dimZ] = dims
+            const swapDims = Math.abs(Math.sin(newRotationY)) > 0.9
+            const x = snapToGrid(localPos.x, swapDims ? dimZ : dimX)
+            const z = snapToGrid(localPos.z, swapDims ? dimX : dimZ)
+            const y = gridPosition.current.y
+            gridPosition.current.set(x, y, z)
+            draft.position = [x, y, z]
+            const worldSnapped = surfaceMesh.localToWorld(new Vector3(x, y, z))
+            const localSnapped = worldToBuildingLocal(
+              worldSnapped.x,
+              worldSnapped.y,
+              worldSnapped.z,
+            )
+            cursorGroupRef.current.position.set(localSnapped.x, localSnapped.y, localSnapped.z)
+            if (mesh) mesh.position.set(x, y, z)
+          }
+        }
+
+        // Update live transform for 2D floorplan with post-snap position
         const currentLive = useLiveTransforms.getState().get(draft.id)
         if (currentLive) {
           useLiveTransforms.getState().set(draft.id, {
             ...currentLive,
+            position: [
+              cursorGroupRef.current.position.x,
+              cursorGroupRef.current.position.y,
+              cursorGroupRef.current.position.z,
+            ] as [number, number, number],
             rotation: newRotationY,
           })
         }
@@ -801,6 +874,7 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
   // Wall/ceiling items are managed by their own surface entry events (ensureDraft / reparent).
   const viewerLevelId = useViewer((s) => s.selection.levelId)
   useEffect(() => {
+    if (!asset) return
     const draft = draftNode.current
     if (!(draft && viewerLevelId) || asset.attachTo) return
     if (draft.parentId === viewerLevelId) return
@@ -809,6 +883,7 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
   }, [viewerLevelId, draftNode, asset])
 
   useFrame((_, delta) => {
+    if (!asset) return
     if (!draftNode.current) return
     const mesh = sceneRegistry.nodes.get(draftNode.current.id)
     if (!mesh) return
@@ -850,9 +925,9 @@ export function usePlacementCoordinator(config: PlacementCoordinatorConfig): Rea
   const initialDraft = draftNode.current
   const dims = initialDraft
     ? getScaledDimensions(initialDraft)
-    : (config.asset.dimensions ?? DEFAULT_DIMENSIONS)
+    : (config.asset?.dimensions ?? DEFAULT_DIMENSIONS)
   const initialBoxGeometry = new BoxGeometry(dims[0], dims[1], dims[2])
-  const wallSideZOffset = config.asset.attachTo === 'wall-side' ? -dims[2] / 2 : 0
+  const wallSideZOffset = config.asset?.attachTo === 'wall-side' ? -dims[2] / 2 : 0
   initialBoxGeometry.translate(0, dims[1] / 2, wallSideZOffset)
 
   // Base plane geometry (colored rectangle on the ground)

package/src/components/tools/roof/move-roof-tool.tsx

@@ -156,7 +156,10 @@ export const MoveRoofTool: React.FC<{
       }
 
       previousGridPosRef.current = [gridX, gridZ]
-      setCursorWorldPos([gridX, y, gridZ])
+      // Cursor is inside the building-local ToolManager group — use local position
+      const lx = Math.round(event.localPosition[0] * 2) / 2
+      const lz = Math.round(event.localPosition[2] * 2) / 2
+      setCursorWorldPos([lx, event.localPosition[1], lz])
 
       const [localX, localZ] = computeLocal(gridX, gridZ, y)
 
@@ -175,7 +178,7 @@ export const MoveRoofTool: React.FC<{
     }
 
     const onGridClick = (event: GridEvent) => {
-      const gridX = Math.round(event.position[0] * 2) / 2
+      const gridX = Math.round(event.position[0] * 2) / 2 // world, for computeLocal
       const gridZ = Math.round(event.position[2] * 2) / 2
       const y = event.position[1]
 

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

@@ -173,9 +173,9 @@ export const RoofTool: React.FC = () => {
     const onGridMove = (event: GridEvent) => {
       if (!cursorRef.current) return
 
-      const gridX = Math.round(event.position[0] * 2) / 2
-      const gridZ = Math.round(event.position[2] * 2) / 2
-      const y = event.position[1]
+      const gridX = Math.round(event.localPosition[0] * 2) / 2
+      const gridZ = Math.round(event.localPosition[2] * 2) / 2
+      const y = event.localPosition[1]
 
       const cursorPosition: [number, number, number] = [gridX, y, gridZ]
       const gridY = y + GRID_OFFSET
@@ -206,9 +206,9 @@ export const RoofTool: React.FC = () => {
     const onGridClick = (event: GridEvent) => {
       if (!currentLevelId) return
 
-      const gridX = Math.round(event.position[0] * 2) / 2
-      const gridZ = Math.round(event.position[2] * 2) / 2
-      const y = event.position[1]
+      const gridX = Math.round(event.localPosition[0] * 2) / 2
+      const gridZ = Math.round(event.localPosition[2] * 2) / 2
+      const y = event.localPosition[1]
 
       if (corner1Ref.current) {
         const roofId = commitRoofPlacement(

package/src/components/tools/select/box-select-tool.tsx

@@ -197,7 +197,7 @@ function collectNodeIdsInBounds(bounds: Bounds): string[] {
       const node = nodes[childId as AnyNodeId]
       if (!node) continue
 
-      if (node.type === 'wall') {
+      if (node.type === 'wall' || node.type === 'fence') {
         const wall = node as WallNode
         if (
           segmentIntersectsBounds(wall.start[0], wall.start[1], wall.end[0], wall.end[1], bounds)
@@ -205,7 +205,7 @@ function collectNodeIdsInBounds(bounds: Bounds): string[] {
           result.push(wall.id)
         }
         // Check wall children (doors/windows)
-        for (const itemId of wall.children) {
+        for (const itemId of Array.isArray(wall.children) ? wall.children : []) {
           const child = nodes[itemId as AnyNodeId]
           if (!child) continue
           if (

package/src/components/tools/shared/polygon-editor.tsx

@@ -139,8 +139,8 @@ export const PolygonEditor: React.FC<PolygonEditorProps> = ({
   // Listen to grid:move events to track cursor position
   useEffect(() => {
     const onGridMove = (event: GridEvent) => {
-      const gridX = Math.round(event.position[0] * 2) / 2
-      const gridZ = Math.round(event.position[2] * 2) / 2
+      const gridX = Math.round(event.localPosition[0] * 2) / 2
+      const gridZ = Math.round(event.localPosition[2] * 2) / 2
       const newPosition: [number, number] = [gridX, gridZ]
 
       // Play snap sound when cursor moves to a new grid cell during drag

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

@@ -86,12 +86,12 @@ export const SlabTool: React.FC = () => {
     const onGridMove = (event: GridEvent) => {
       if (!cursorRef.current) return
 
-      const gridX = Math.round(event.position[0] * 2) / 2
-      const gridZ = Math.round(event.position[2] * 2) / 2
+      const gridX = Math.round(event.localPosition[0] * 2) / 2
+      const gridZ = Math.round(event.localPosition[2] * 2) / 2
       const gridPosition: [number, number] = [gridX, gridZ]
 
       setCursorPosition(gridPosition)
-      setLevelY(event.position[1])
+      setLevelY(event.localPosition[1])
 
       // Calculate snapped display position (bypass snap when Shift is held)
       const lastPoint = points[points.length - 1]
@@ -112,7 +112,7 @@ export const SlabTool: React.FC = () => {
       }
 
       previousSnappedPointRef.current = displayPoint
-      cursorRef.current.position.set(displayPoint[0], event.position[1], displayPoint[1])
+      cursorRef.current.position.set(displayPoint[0], event.localPosition[1], displayPoint[1])
     }
 
     const onGridClick = (_event: GridEvent) => {

package/src/components/tools/stair/stair-defaults.ts

@@ -1,3 +1,4 @@
+export const DEFAULT_STAIR_TYPE = 'straight' as const
 export const DEFAULT_STAIR_WIDTH = 1.0
 export const DEFAULT_STAIR_LENGTH = 3.0
 export const DEFAULT_STAIR_HEIGHT = 2.5
@@ -5,3 +6,12 @@ export const DEFAULT_STAIR_STEP_COUNT = 10
 export const DEFAULT_STAIR_ATTACHMENT_SIDE = 'front' as const
 export const DEFAULT_STAIR_FILL_TO_FLOOR = true
 export const DEFAULT_STAIR_THICKNESS = 0.25
+export const DEFAULT_CURVED_STAIR_INNER_RADIUS = 0.9
+export const DEFAULT_CURVED_STAIR_SWEEP_ANGLE = Math.PI / 2
+export const DEFAULT_SPIRAL_STAIR_SWEEP_ANGLE = (400 * Math.PI) / 180
+export const DEFAULT_SPIRAL_TOP_LANDING_MODE = 'none' as const
+export const DEFAULT_SPIRAL_TOP_LANDING_DEPTH = 0.9
+export const DEFAULT_SPIRAL_SHOW_CENTER_COLUMN = true
+export const DEFAULT_SPIRAL_SHOW_STEP_SUPPORTS = true
+export const DEFAULT_STAIR_RAILING_MODE = 'right' as const
+export const DEFAULT_STAIR_RAILING_HEIGHT = 0.92

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

@@ -13,12 +13,21 @@ import * as THREE from 'three'
 import { sfxEmitter } from '../../../lib/sfx-bus'
 import { CursorSphere } from '../shared/cursor-sphere'
 import {
+  DEFAULT_CURVED_STAIR_INNER_RADIUS,
+  DEFAULT_CURVED_STAIR_SWEEP_ANGLE,
+  DEFAULT_SPIRAL_SHOW_CENTER_COLUMN,
+  DEFAULT_SPIRAL_SHOW_STEP_SUPPORTS,
+  DEFAULT_SPIRAL_TOP_LANDING_DEPTH,
+  DEFAULT_SPIRAL_TOP_LANDING_MODE,
   DEFAULT_STAIR_ATTACHMENT_SIDE,
   DEFAULT_STAIR_FILL_TO_FLOOR,
   DEFAULT_STAIR_HEIGHT,
   DEFAULT_STAIR_LENGTH,
+  DEFAULT_STAIR_RAILING_HEIGHT,
+  DEFAULT_STAIR_RAILING_MODE,
   DEFAULT_STAIR_STEP_COUNT,
   DEFAULT_STAIR_THICKNESS,
+  DEFAULT_STAIR_TYPE,
   DEFAULT_STAIR_WIDTH,
 } from './stair-defaults'
 
@@ -88,6 +97,20 @@ function commitStairPlacement(
     name,
     position,
     rotation,
+    stairType: DEFAULT_STAIR_TYPE,
+    width: DEFAULT_STAIR_WIDTH,
+    totalRise: DEFAULT_STAIR_HEIGHT,
+    stepCount: DEFAULT_STAIR_STEP_COUNT,
+    thickness: DEFAULT_STAIR_THICKNESS,
+    fillToFloor: DEFAULT_STAIR_FILL_TO_FLOOR,
+    innerRadius: DEFAULT_CURVED_STAIR_INNER_RADIUS,
+    sweepAngle: DEFAULT_CURVED_STAIR_SWEEP_ANGLE,
+    topLandingMode: DEFAULT_SPIRAL_TOP_LANDING_MODE,
+    topLandingDepth: DEFAULT_SPIRAL_TOP_LANDING_DEPTH,
+    showCenterColumn: DEFAULT_SPIRAL_SHOW_CENTER_COLUMN,
+    showStepSupports: DEFAULT_SPIRAL_SHOW_STEP_SUPPORTS,
+    railingHeight: DEFAULT_STAIR_RAILING_HEIGHT,
+    railingMode: DEFAULT_STAIR_RAILING_MODE,
     children: [segment.id],
   })
 
@@ -116,9 +139,9 @@ export const StairTool: React.FC = () => {
     if (previewRef.current) previewRef.current.rotation.y = 0
 
     const onGridMove = (event: GridEvent) => {
-      const gridX = Math.round(event.position[0] * 2) / 2
-      const gridZ = Math.round(event.position[2] * 2) / 2
-      const y = event.position[1]
+      const gridX = Math.round(event.localPosition[0] * 2) / 2
+      const gridZ = Math.round(event.localPosition[2] * 2) / 2
+      const y = event.localPosition[1]
 
       if (cursorRef.current) {
         cursorRef.current.position.set(gridX, y + GRID_OFFSET, gridZ)
@@ -141,9 +164,9 @@ export const StairTool: React.FC = () => {
     const onGridClick = (event: GridEvent) => {
       if (!currentLevelId) return
 
-      const gridX = Math.round(event.position[0] * 2) / 2
-      const gridZ = Math.round(event.position[2] * 2) / 2
-      const y = event.position[1]
+      const gridX = Math.round(event.localPosition[0] * 2) / 2
+      const gridZ = Math.round(event.localPosition[2] * 2) / 2
+      const y = event.localPosition[1]
 
       commitStairPlacement(currentLevelId, [gridX, y, gridZ], rotationRef.current)
     }

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

@@ -1,10 +1,17 @@
-import { type AnyNodeId, type CeilingNode, type SlabNode, useScene } from '@pascal-app/core'
+import {
+  type AnyNodeId,
+  type BuildingNode,
+  type CeilingNode,
+  type SlabNode,
+  useScene,
+} from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
 import useEditor, { type Phase, type Tool } from '../../store/use-editor'
 import { CeilingBoundaryEditor } from './ceiling/ceiling-boundary-editor'
 import { CeilingHoleEditor } from './ceiling/ceiling-hole-editor'
 import { CeilingTool } from './ceiling/ceiling-tool'
 import { DoorTool } from './door/door-tool'
+import { FenceTool } from './fence/fence-tool'
 import { ItemTool } from './item/item-tool'
 import { MoveTool } from './item/move-tool'
 import { RoofTool } from './roof/roof-tool'
@@ -24,6 +31,7 @@ const tools: Record<Phase, Partial<Record<Tool, React.FC>>> = {
   },
   structure: {
     wall: WallTool,
+    fence: FenceTool,
     slab: SlabTool,
     ceiling: CeilingTool,
     roof: RoofTool,
@@ -45,9 +53,18 @@ export const ToolManager: React.FC = () => {
   const movingNode = useEditor((state) => state.movingNode)
   const editingHole = useEditor((state) => state.editingHole)
   const selectedZoneId = useViewer((state) => state.selection.zoneId)
+  const buildingId = useViewer((state) => state.selection.buildingId)
   const selectedIds = useViewer((state) => state.selection.selectedIds)
   const nodes = useScene((state) => state.nodes)
 
+  // Building transform for the local group — all building-relative tools live inside this group
+  // so their cursor positions and committed data are naturally in building-local space.
+  const building = buildingId
+    ? (nodes[buildingId as AnyNodeId] as BuildingNode | undefined)
+    : undefined
+  const buildingPosition = building?.position ?? [0, 0, 0]
+  const buildingRotation = building?.rotation ?? [0, 0, 0]
+
   // Check if a slab is selected
   const selectedSlabId = selectedIds.find((id) => nodes[id as AnyNodeId]?.type === 'slab') as
     | SlabNode['id']
@@ -102,19 +119,30 @@ export const ToolManager: React.FC = () => {
   return (
     <>
       {showSiteBoundaryEditor && <SiteBoundaryEditor />}
-      {showZoneBoundaryEditor && selectedZoneId && <ZoneBoundaryEditor zoneId={selectedZoneId} />}
-      {showSlabBoundaryEditor && selectedSlabId && <SlabBoundaryEditor slabId={selectedSlabId} />}
-      {showSlabHoleEditor && selectedSlabId && editingHole && (
-        <SlabHoleEditor holeIndex={editingHole.holeIndex} slabId={selectedSlabId} />
-      )}
-      {showCeilingBoundaryEditor && selectedCeilingId && (
-        <CeilingBoundaryEditor ceilingId={selectedCeilingId} />
-      )}
-      {showCeilingHoleEditor && selectedCeilingId && editingHole && (
-        <CeilingHoleEditor ceilingId={selectedCeilingId} holeIndex={editingHole.holeIndex} />
-      )}
-      {movingNode && <MoveTool />}
-      {!movingNode && BuildToolComponent && <BuildToolComponent />}
+      {/* World-space tools: site boundary and building movement operate in world coordinates */}
+      {movingNode?.type === 'building' && <MoveTool />}
+
+      {/* Building-local group: all other tools are relative to the selected building.
+          Cursor visuals set positions in building-local space; this group applies the
+          building's world transform so they render at the correct world position. */}
+      <group
+        position={buildingPosition as [number, number, number]}
+        rotation={buildingRotation as [number, number, number]}
+      >
+        {showZoneBoundaryEditor && selectedZoneId && <ZoneBoundaryEditor zoneId={selectedZoneId} />}
+        {showSlabBoundaryEditor && selectedSlabId && <SlabBoundaryEditor slabId={selectedSlabId} />}
+        {showSlabHoleEditor && selectedSlabId && editingHole && (
+          <SlabHoleEditor holeIndex={editingHole.holeIndex} slabId={selectedSlabId} />
+        )}
+        {showCeilingBoundaryEditor && selectedCeilingId && (
+          <CeilingBoundaryEditor ceilingId={selectedCeilingId} />
+        )}
+        {showCeilingHoleEditor && selectedCeilingId && editingHole && (
+          <CeilingHoleEditor ceilingId={selectedCeilingId} holeIndex={editingHole.holeIndex} />
+        )}
+        {movingNode && movingNode.type !== 'building' && <MoveTool />}
+        {!movingNode && BuildToolComponent && <BuildToolComponent />}
+      </group>
     </>
   )
 }

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

@@ -78,31 +78,28 @@ export const WallTool: React.FC = () => {
     let gridPosition: WallPlanPoint = [0, 0]
     let previousWallEnd: [number, number] | null = null
 
+    // All positions are building-local: this tool is inside the ToolManager building group,
+    // so local coords are used for both data and visual positioning.
     const onGridMove = (event: GridEvent) => {
       if (!(cursorRef.current && wallPreviewRef.current)) return
 
       const walls = getCurrentLevelWalls()
-      const cursorPoint: WallPlanPoint = [event.position[0], event.position[2]]
-      gridPosition = snapWallDraftPoint({
-        point: cursorPoint,
-        walls,
-      })
+      // event.localPosition is building-local — consistent with stored wall start/end
+      const localPoint: WallPlanPoint = [event.localPosition[0], event.localPosition[2]]
+      gridPosition = snapWallDraftPoint({ point: localPoint, walls })
 
       if (buildingState.current === 1) {
-        const snappedPoint = snapWallDraftPoint({
-          point: cursorPoint,
+        const snappedLocal = snapWallDraftPoint({
+          point: localPoint,
           walls,
           start: [startingPoint.current.x, startingPoint.current.z],
           angleSnap: !shiftPressed.current,
         })
-        const snapped = new Vector3(snappedPoint[0], event.position[1], snappedPoint[1])
-        endingPoint.current.copy(snapped)
-
-        // Position the cursor at the end of the wall being drawn
-        cursorRef.current.position.set(snapped.x, snapped.y, snapped.z)
+        endingPoint.current.set(snappedLocal[0], event.localPosition[1], snappedLocal[1])
+        cursorRef.current.position.copy(endingPoint.current)
 
         // Play snap sound only when the actual wall end position changes
-        const currentWallEnd: [number, number] = [endingPoint.current.x, endingPoint.current.z]
+        const currentWallEnd: [number, number] = [snappedLocal[0], snappedLocal[1]]
         if (
           previousWallEnd &&
           (currentWallEnd[0] !== previousWallEnd[0] || currentWallEnd[1] !== previousWallEnd[1])
@@ -111,43 +108,36 @@ export const WallTool: React.FC = () => {
         }
         previousWallEnd = currentWallEnd
 
-        // Update wall preview geometry
         updateWallPreview(wallPreviewRef.current, startingPoint.current, endingPoint.current)
       } else {
         // Not drawing a wall yet, show the snapped anchor point.
-        cursorRef.current.position.set(gridPosition[0], event.position[1], gridPosition[1])
+        cursorRef.current.position.set(gridPosition[0], event.localPosition[1], gridPosition[1])
       }
     }
 
     const onGridClick = (event: GridEvent) => {
       const walls = getCurrentLevelWalls()
-      const clickPoint: WallPlanPoint = [event.position[0], event.position[2]]
+      const localClick: WallPlanPoint = [event.localPosition[0], event.localPosition[2]]
 
       if (buildingState.current === 0) {
-        const snappedStart = snapWallDraftPoint({
-          point: clickPoint,
-          walls,
-        })
+        const snappedStart = snapWallDraftPoint({ point: localClick, walls })
         gridPosition = snappedStart
-        startingPoint.current.set(snappedStart[0], event.position[1], snappedStart[1])
+        startingPoint.current.set(snappedStart[0], event.localPosition[1], snappedStart[1])
         endingPoint.current.copy(startingPoint.current)
         buildingState.current = 1
         wallPreviewRef.current.visible = true
       } else if (buildingState.current === 1) {
         const snappedEnd = snapWallDraftPoint({
-          point: clickPoint,
+          point: localClick,
           walls,
           start: [startingPoint.current.x, startingPoint.current.z],
           angleSnap: !shiftPressed.current,
         })
-        endingPoint.current.set(snappedEnd[0], event.position[1], snappedEnd[1])
-        const dx = endingPoint.current.x - startingPoint.current.x
-        const dz = endingPoint.current.z - startingPoint.current.z
+        const dx = snappedEnd[0] - startingPoint.current.x
+        const dz = snappedEnd[1] - startingPoint.current.z
         if (dx * dx + dz * dz < 0.01 * 0.01) return
-        createWallOnCurrentLevel(
-          [startingPoint.current.x, startingPoint.current.z],
-          [endingPoint.current.x, endingPoint.current.z],
-        )
+        // Both start and end are building-local ✓
+        createWallOnCurrentLevel([startingPoint.current.x, startingPoint.current.z], snappedEnd)
         wallPreviewRef.current.visible = false
         buildingState.current = 0
       }

package/src/components/tools/window/move-window-tool.tsx

@@ -185,17 +185,26 @@ export const MoveWindowTool: React.FC<{ node: WindowNode }> = ({ node: movingWin
         movingWindowNode.height,
       )
 
-      useScene.getState().updateNode(movingWindowNode.id, {
-        position: [clampedX, clampedY, 0],
-        rotation: [0, itemRotation, 0],
-        side,
-        parentId: event.node.id,
-        wallId: event.node.id,
-      })
-
       if (currentWallId !== event.node.id) {
+        // Wall changed mid-move: must updateNode to reparent
+        useScene.getState().updateNode(movingWindowNode.id, {
+          position: [clampedX, clampedY, 0],
+          rotation: [0, itemRotation, 0],
+          side,
+          parentId: event.node.id,
+          wallId: event.node.id,
+        })
         markWallDirty(currentWallId)
         currentWallId = event.node.id
+      } else {
+        // Same wall: update Three.js mesh directly to avoid store churn
+        // collectCutoutBrushes reads cutoutMesh.matrixWorld, not scene store positions
+        const windowMesh = sceneRegistry.nodes.get(movingWindowNode.id as AnyNodeId)
+        if (windowMesh) {
+          windowMesh.position.set(clampedX, clampedY, 0)
+          windowMesh.rotation.set(0, itemRotation, 0)
+          windowMesh.updateMatrixWorld(true)
+        }
       }
       markWallDirty(event.node.id)
 

package/src/components/tools/window/window-math.ts

@@ -77,7 +77,7 @@ export function hasWallChildOverlap(
   const newLeft = clampedX - halfW
   const newRight = clampedX + halfW
 
-  for (const childId of wallNode.children) {
+  for (const childId of Array.isArray(wallNode.children) ? wallNode.children : []) {
     if (childId === ignoreId) continue
     const child = nodes[childId as AnyNodeId]
     if (!child) continue