feat(editor): door/window placement-feel polish + placement-state refactor (#411)

Round 8 of the opening-placement UX work. Make door/window placement feel
physical and predictable, and unify the validity/placement logic behind one
shared decision.

UX:
- Window default sill 0.5 m (DEFAULT_WINDOW_SILL_M) so fresh windows float
  slightly above the floor; existing windows keep their own sill.
- Dev-only floor "shadow" projection for windows during placement/move
  (footprint + dashed drop-line) so an elevated window's plan spot is legible.
- Move SFX: one soft grid-snap click per grid step — identical free-following
  over floor or sliding on a wall (keyed on the raw cursor; per-frame + step
  dedup), no separate snap cue (that was a "double"). Mirrored into the 2D
  floorplan-move so 2D and 3D match.
- Shift = force-place over a collision (commit allowed; ghost stays a red
  warning) + free-place (lands at the raw cursor but keeps the alignment guides
  visible). Tint flips green/red live when Shift is pressed/released stationary.
- On-wall preview is now the tinted ghost (green placeable / red colliding),
  matching the free-follow ghost, instead of a pale solid mesh + thin wireframe.
- R-flip fixes: always toggles (no initial no-op needing a second press),
  e.repeat filtered, ghost rebuilds with the live `side`, and the ghost's
  on-wall world yaw uses `itemRotation - wallAngle` so it faces exactly what
  commit places (cursorRotation was π off for the asymmetric ghost). R ownership
  follows the current pointer pane (capture-phase + stopImmediatePropagation in
  the 2D overlay) so 3D and 2D never double-flip or go dead.

Refactor / quality:
- New `resolveOpeningPlacement({collides,forcePlace}) -> {placeable,tint}` in
  shared/wall-attach-target.ts — the single source of truth the ghost tint AND
  the commit gates both consume, so they can't disagree under Shift.
- Consolidated the byte-identical `hasWallChildOverlap` into one shared impl
  (door-math/window-math re-export it).
- applyGhost gained a green "valid" tint.
- Removed dead `cursorRotation` from the move-tool targets after the yaw fix.

Docs: "2D <-> 3D behavioral parity" principle in wiki/architecture/tools.md
(+ README + AGENTS.md) — applicable behaviors must exist in both views.

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

packages/nodes/src/window/floor-projection.tsx

@@ -0,0 +1,111 @@
+'use client'
+
+import { EDITOR_LAYER } from '@pascal-app/editor'
+import { useEffect, useMemo } from 'react'
+import { BufferGeometry, Float32BufferAttribute, LineSegments } from 'three'
+import { LineBasicNodeMaterial } from 'three/webgpu'
+
+/**
+ * Floor "shadow" projection for a window during placement / move.
+ *
+ * Windows sit elevated above the floor, so over open ground (and on a wall)
+ * it's hard to read where the window actually is in plan. This draws its
+ * projection on the floor: a small footprint segment directly below the window
+ * (its plan extent along the wall) plus a DASHED vertical line dropping from the
+ * window centre to that footprint — like a shadow tether. Placement aid only;
+ * never shown on a committed window.
+ *
+ * Rendered in WORLD space (the tool positions the ghost in world space too), so
+ * it's mounted as a sibling of the ghost — NOT inside the ghost's rotated/offset
+ * group. `centerY` is the window centre's world Y; `floorY` is the level floor.
+ */
+
+const FOOTPRINT_COLOR = 0x38_bd_f8
+const DROP_COLOR = 0x38_bd_f8
+
+const footprintMaterial = new LineBasicNodeMaterial({
+  color: FOOTPRINT_COLOR,
+  transparent: true,
+  opacity: 0.85,
+  depthWrite: false,
+})
+const dropMaterial = new LineBasicNodeMaterial({
+  color: DROP_COLOR,
+  transparent: true,
+  opacity: 0.6,
+  depthWrite: false,
+})
+
+// Dash geometry for the vertical drop: alternating on/off segments so it reads
+// as a dashed tether without a dashed-line material (unavailable in three/webgpu).
+const DASH = 0.12
+const GAP = 0.08
+
+export function WindowFloorProjection({
+  centerX,
+  centerZ,
+  centerY,
+  floorY,
+  width,
+  rotationY,
+}: {
+  centerX: number
+  centerZ: number
+  centerY: number
+  floorY: number
+  width: number
+  rotationY: number
+}) {
+  // Footprint: a short segment of length `width` along the window's wall axis,
+  // centred under the window on the floor. The window faces `rotationY` about Y
+  // (its width runs along the wall), so the along-wall direction is
+  // (cos, -sin) in XZ.
+  const footprint = useMemo(() => {
+    const half = width / 2
+    const dirX = Math.cos(rotationY)
+    const dirZ = -Math.sin(rotationY)
+    const position = new Float32BufferAttribute(new Float32Array(6), 3)
+    const geometry = new BufferGeometry()
+    geometry.setAttribute('position', position)
+    const line = new LineSegments(geometry, footprintMaterial)
+    line.frustumCulled = false
+    line.layers.set(EDITOR_LAYER)
+    line.renderOrder = 1000
+    line.raycast = () => {}
+    position.setXYZ(0, centerX - dirX * half, floorY + 0.002, centerZ - dirZ * half)
+    position.setXYZ(1, centerX + dirX * half, floorY + 0.002, centerZ + dirZ * half)
+    position.needsUpdate = true
+    return line
+  }, [centerX, centerZ, floorY, width, rotationY])
+
+  // Dashed vertical tether from the window centre down to the footprint.
+  const drop = useMemo(() => {
+    const span = Math.max(centerY - floorY, 0)
+    const segs: number[] = []
+    let y = floorY
+    while (y < floorY + span) {
+      const top = Math.min(y + DASH, floorY + span)
+      segs.push(centerX, y, centerZ, centerX, top, centerZ)
+      y += DASH + GAP
+    }
+    const position = new Float32BufferAttribute(new Float32Array(segs), 3)
+    const geometry = new BufferGeometry()
+    geometry.setAttribute('position', position)
+    const line = new LineSegments(geometry, dropMaterial)
+    line.frustumCulled = false
+    line.layers.set(EDITOR_LAYER)
+    line.renderOrder = 1000
+    line.raycast = () => {}
+    return line
+  }, [centerX, centerZ, centerY, floorY])
+
+  useEffect(() => () => footprint.geometry.dispose(), [footprint])
+  useEffect(() => () => drop.geometry.dispose(), [drop])
+
+  return (
+    <>
+      <primitive object={footprint} />
+      <primitive object={drop} />
+    </>
+  )
+}

packages/nodes/src/window/floorplan-move.ts

@@ -8,15 +8,16 @@ import {
   WallNode as WallNodeSchema,
   type WindowNode,
 } from '@pascal-app/core'
-import { snapToHalf, usePlacementPreview } from '@pascal-app/editor'
+import { snapToHalf, triggerSFX, usePlacementPreview } from '@pascal-app/editor'
 import { createFloorplanCursorResolver } from '../shared/floorplan-cursor'
 import { getOpeningHostLevelId, getRoofHostedOpeningPlanPoint } from '../shared/roof-opening-host'
 import {
   findClosestWallInPlan,
   projectWallLocalPointToPlan,
+  resolveOpeningPlacement,
   snapLocalXToNeighbors,
 } from '../shared/wall-attach-target'
-import { clampToWall, hasWallChildOverlap } from './window-math'
+import { clampToWall, DEFAULT_WINDOW_SILL_M, hasWallChildOverlap } from './window-math'
 
 /**
  * 2D floor-plan move handler for window. Same shape as door (see
@@ -56,8 +57,8 @@ export const windowFloorplanMoveTarget: FloorplanMoveTarget<WindowNode> = ({ nod
   // created at y=0, which would sit the window's centre on the floor (half
   // below ground); default those to a realistic sill so it floats above
   // the floor in 2D too. Same rule as the 3D `MoveWindowTool` (`getSillCenterY`).
-  const DEFAULT_SILL = 0.9
-  const startLocalY = node.position[1] > 0.1 ? node.position[1] : DEFAULT_SILL + node.height / 2
+  const startLocalY =
+    node.position[1] > 0.1 ? node.position[1] : DEFAULT_WINDOW_SILL_M + node.height / 2
 
   // Track the last successful placement so `commit()` can write it
   // atomically — same deterministic-commit fix as `doorFloorplanMoveTarget`.
@@ -82,6 +83,23 @@ export const windowFloorplanMoveTarget: FloorplanMoveTarget<WindowNode> = ({ nod
   // See `doorFloorplanMoveTarget`: off-wall the window free-follows the cursor
   // as a ghost and isn't committable (it needs a wall). Starts true.
   let onWall = true
+  // Shift force-place (last apply's modifier) — lets `canCommit` allow an
+  // overlapping placement, matching the 3D move.
+  let forcePlace = false
+
+  // Move SFX — parity with the 3D `MoveWindowTool` (see `doorFloorplanMoveTarget`):
+  // ONE soft `sfx:grid-snap` click per grid step, identical free-following or on a
+  // wall, keyed on the RAW cursor. No separate floor→wall cue (that was the
+  // "double"). 2D `apply` runs once per pointermove, so the step-key dedup suffices.
+  const STEP_M = 0.1
+  let lastStepKey: string | null = null
+  const tickGridStep = (...coords: number[]) => {
+    const key = coords.map((c) => Math.round(c / STEP_M)).join(',')
+    if (key !== lastStepKey) {
+      lastStepKey = key
+      triggerSFX('sfx:grid-snap')
+    }
+  }
 
   const freeFollow = (planPoint: readonly [number, number]) => {
     onWall = false
@@ -95,14 +113,22 @@ export const windowFloorplanMoveTarget: FloorplanMoveTarget<WindowNode> = ({ nod
       end: [planPoint[0] + half, planPoint[1]],
       thickness: 0.1,
     })
+    // Reflect the R-flip on the floating ghost so it faces the side that will
+    // be committed (see `doorFloorplanMoveTarget.freeFollow`).
+    const ghostSide: WindowNode['side'] = flipped
+      ? node.side === 'front'
+        ? 'back'
+        : 'front'
+      : node.side
     const ghost = {
       ...node,
+      side: ghostSide,
       parentId: wall.id,
       wallId: wall.id,
       roofSegmentId: undefined,
       roofFace: undefined,
       position: [half, startLocalY, 0] as [number, number, number],
-      rotation: [0, 0, 0] as [number, number, number],
+      rotation: [0, flipped ? Math.PI : 0, 0] as [number, number, number],
       visible: true,
     } as WindowNode
     usePlacementPreview.getState().set(ghost, wall)
@@ -116,6 +142,7 @@ export const windowFloorplanMoveTarget: FloorplanMoveTarget<WindowNode> = ({ nod
     },
     apply({ planPoint, modifiers }) {
       lastApply = { planPoint, modifiers }
+      forcePlace = modifiers.shiftKey === true
       // Drop any stale live transform left by the 3D `MoveWindowTool` — see
       // `doorFloorplanMoveTarget.apply`. Without this the 2D registry layer
       // keeps rendering the window at the 3D tool's last hover (it prefers
@@ -129,6 +156,8 @@ export const windowFloorplanMoveTarget: FloorplanMoveTarget<WindowNode> = ({ nod
       const resolvedPlanPoint = resolveCursor(planPoint)
       const hit = findClosestWallInPlan(resolvedPlanPoint, nodes, startLevelId)
       if (!hit) {
+        // Off any wall — free-follow. Click per grid cell over open floor.
+        tickGridStep(resolvedPlanPoint[0], resolvedPlanPoint[1])
         freeFollow(resolvedPlanPoint)
         return
       }
@@ -160,6 +189,11 @@ export const windowFloorplanMoveTarget: FloorplanMoveTarget<WindowNode> = ({ nod
         node.height,
       )
 
+      // One click per grid step, keyed on the RAW along-wall cursor (`hit.localX`)
+      // so the wall slide ticks at the same cadence as the off-wall ghost — same
+      // SFX, no separate snap cue.
+      tickGridStep(hit.localX)
+
       const side: WindowNode['side'] = flipped
         ? hit.side === 'front'
           ? 'back'
@@ -192,7 +226,9 @@ export const windowFloorplanMoveTarget: FloorplanMoveTarget<WindowNode> = ({ nod
       if (!onWall) return false
       const live = useScene.getState().nodes[node.id as AnyNodeId] as WindowNode | undefined
       if (!live || live.type !== 'window') return false
-      const overlapping = hasWallChildOverlap(
+      // Block on overlap UNLESS Shift force-places — same `placeable` rule as
+      // the 3D move + the shared `resolveOpeningPlacement`.
+      const collides = hasWallChildOverlap(
         live.parentId as string,
         live.position[0],
         live.position[1],
@@ -200,7 +236,7 @@ export const windowFloorplanMoveTarget: FloorplanMoveTarget<WindowNode> = ({ nod
         live.height,
         live.id,
       )
-      return !overlapping
+      return resolveOpeningPlacement({ collides, forcePlace }).placeable
     },
     commit() {
       // Own the atomic write so the overlay takes the deterministic

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

@@ -14,7 +14,6 @@ import {
   WindowNode,
 } from '@pascal-app/core'
 import {
-  calculateCursorRotation,
   calculateItemRotation,
   consumePlacementDragRelease,
   EDITOR_LAYER,
@@ -27,7 +26,7 @@ import {
   useEditor,
 } from '@pascal-app/editor'
 import { useViewer } from '@pascal-app/viewer'
-import { useCallback, useEffect, useMemo, useRef } from 'react'
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import { BoxGeometry, EdgesGeometry, type Group } from 'three'
 import { LineBasicNodeMaterial } from 'three/webgpu'
 import {
@@ -40,8 +39,16 @@ import {
   type RoofWallOpeningTarget,
   resolveRoofWallOpeningTarget,
 } from '../shared/roof-wall-opening-placement'
+import { resolveOpeningPlacement } from '../shared/wall-attach-target'
 import { resolveWallSlideAlignment } from '../shared/wall-opening-alignment'
-import { clampToWall, hasWallChildOverlap, wallLocalToWorld } from './window-math'
+import { WindowFloorProjection } from './floor-projection'
+import WindowPreview from './preview'
+import {
+  clampToWall,
+  DEFAULT_WINDOW_SILL_M,
+  hasWallChildOverlap,
+  wallLocalToWorld,
+} from './window-math'
 
 const edgeMaterial = new LineBasicNodeMaterial({
   color: 0xef_44_44,
@@ -65,6 +72,38 @@ const edgeMaterial = new LineBasicNodeMaterial({
 const MoveWindowTool: React.FC<{ node: WindowNode }> = ({ node: movingWindowNode }) => {
   const cursorGroupRef = useRef<Group>(null!)
 
+  // The window preview ghost. Shown for the WHOLE move so the user always sees
+  // a translucent window tinted by placement state — red off-wall or colliding,
+  // green on a valid wall. The real node stays hidden until commit (the wall
+  // still cuts its hole from the node data). `null` = not previewing. See the
+  // matching `WindowPreview` tint and `MoveDoorTool` for the full rationale.
+  const [ghostPose, setGhostPose] = useState<{
+    position: [number, number, number]
+    rotationY: number
+    tint: 'valid' | 'invalid'
+    // Level floor world-Y, for the floor "shadow" projection (drop-line + footprint).
+    floorY: number
+    // Live facing side — R-flip changes it and the window geometry depends on it,
+    // so the ghost must rebuild with the live side (see `MoveDoorTool`).
+    side: WindowNode['side']
+  } | null>(null)
+
+  // Ghost preview node: the moving window with a zeroed transform + the live
+  // facing side (the ghost is positioned by the `<group position>` wrapper;
+  // `updateWindowMesh` bakes the node's own position/rotation in, so passing the
+  // live node would double-offset). Rebuilds on an R-flip so the preview matches
+  // what commit will place.
+  const ghostSide = ghostPose?.side ?? movingWindowNode.side
+  const ghostNode = useMemo(
+    () => ({
+      ...movingWindowNode,
+      side: ghostSide,
+      position: [0, 0, 0] as [number, number, number],
+      rotation: [0, 0, 0] as [number, number, number],
+    }),
+    [movingWindowNode, ghostSide],
+  )
+
   const exitMoveMode = useCallback(() => {
     useEditor.getState().setMovingNode(null)
   }, [])
@@ -91,6 +130,8 @@ const MoveWindowTool: React.FC<{ node: WindowNode }> = ({ node: movingWindowNode
       roofSegmentId: movingWindowNode.roofSegmentId,
       roofFace: movingWindowNode.roofFace,
       metadata: movingWindowNode.metadata,
+      // Free-follow hides the node (visible:false); revert paths restore this.
+      visible: movingWindowNode.visible,
     }
 
     // In move mode (existing window) mark it transient so its mesh skips the live wall CSG
@@ -113,6 +154,29 @@ const MoveWindowTool: React.FC<{ node: WindowNode }> = ({ node: movingWindowNode
     // mesh event owns the same pointermove — that's the only thing that snaps.
     let freeFollowing = false
     let lastMeshEventTime = -1
+    // Last open-floor cursor point (level-local X/Z), so an R-flip while free-
+    // following can re-run the ghost at the same spot with the new facing.
+    let lastFloorPoint: [number, number] | null = null
+    // Live Shift state (force-place) — lets the preview tint re-evaluate when
+    // Shift is pressed/released with the pointer stationary (see `MoveDoorTool`).
+    let shiftHeld = false
+    // Movement SFX: ONE soft `sfx:grid-snap` click per grid step — identical
+    // whether free-following over floor or sliding along a wall (the user's
+    // ask). Always keyed on the RAW cursor (continuous ~0.1m cadence), never the
+    // snapped along-wall value. Guards: `lastStepKey` (cell change) +
+    // `lastTickFrame` (one tick per DOM pointermove). No separate snap cue — a
+    // distinct floor→wall sound was the "double" the user heard. See `MoveDoorTool`.
+    const STEP_M = 0.1
+    let lastStepKey: string | null = null
+    let lastTickFrame = -1
+    const tickGridStep = (frame: number, ...coords: number[]) => {
+      if (frame === lastTickFrame) return
+      const key = coords.map((c) => Math.round(c / STEP_M)).join(',')
+      if (key === lastStepKey) return
+      lastStepKey = key
+      lastTickFrame = frame
+      triggerSFX('sfx:grid-snap')
+    }
     // The window's chosen facing side. R flips it mid-placement (front ↔ back),
     // matching the committed-selected R flip. Initialised from the moving node.
     let sideOverride: WindowNode['side'] = movingWindowNode.side
@@ -128,7 +192,6 @@ const MoveWindowTool: React.FC<{ node: WindowNode }> = ({ node: movingWindowNode
       wallId: string
       side: WindowNode['side']
       itemRotation: number
-      cursorRotation: number
       clampedX: number
       clampedY: number
       valid: boolean
@@ -160,12 +223,11 @@ const MoveWindowTool: React.FC<{ node: WindowNode }> = ({ node: movingWindowNode
     // Sill-center height used while the window isn't on a wall (free-follow and
     // proximity). Fresh preset clones are created at position [0,0,0], which
     // would bury half the window below the floor; default such windows to a
-    // ~0.9m sill so the ghost floats at a realistic height. An existing window
-    // keeps its own sill.
-    const DEFAULT_SILL = 0.9
+    // small sill so the ghost floats slightly above the ground. An existing
+    // window keeps its own sill.
     const getSillCenterY = () => {
       const y = movingWindowNode.position[1]
-      return y > 0.1 ? y : DEFAULT_SILL + movingWindowNode.height / 2
+      return y > 0.1 ? y : DEFAULT_WINDOW_SILL_M + movingWindowNode.height / 2
     }
     const getSlabElevation = (wallEvent: WallEvent) =>
       spatialGridManager.getSlabElevationForWall(
@@ -178,6 +240,7 @@ const MoveWindowTool: React.FC<{ node: WindowNode }> = ({ node: movingWindowNode
       if (cursorGroupRef.current) cursorGroupRef.current.visible = false
       useAlignmentGuides.getState().clear()
       clearOpeningGuides3D()
+      setGhostPose(null)
     }
 
     // Alignment candidates — anchors of every OTHER alignable object (the
@@ -214,8 +277,6 @@ const MoveWindowTool: React.FC<{ node: WindowNode }> = ({ node: movingWindowNode
       const side = sideOverride ?? faceSide
       const rotationOffset = side !== faceSide ? Math.PI : 0
       const itemRotation = calculateItemRotation(event.normal) + rotationOffset
-      const cursorRotation =
-        calculateCursorRotation(event.normal, event.node.start, event.node.end) + rotationOffset
 
       const rawLocalX = event.localPosition[0]
       const rawLocalY = event.localPosition[1]
@@ -256,8 +317,10 @@ const MoveWindowTool: React.FC<{ node: WindowNode }> = ({ node: movingWindowNode
         rawLocalX: targetLocalX,
         width: movingWindowNode.width,
         candidates: alignmentCandidates,
-        bypass: event.nativeEvent?.altKey === true || event.nativeEvent?.shiftKey === true,
-        bypassSnap: event.nativeEvent?.shiftKey === true,
+        // Alt still hard-disables alignment (no guides). Shift = free-place:
+        // land at the raw cursor but keep showing the along-wall guides.
+        bypass: event.nativeEvent?.altKey === true,
+        freePlace: event.nativeEvent?.shiftKey === true,
       })
       const { clampedX, clampedY } = clampToWall(
         event.node,
@@ -281,7 +344,6 @@ const MoveWindowTool: React.FC<{ node: WindowNode }> = ({ node: movingWindowNode
         wallId: event.node.id,
         side,
         itemRotation,
-        cursorRotation,
         clampedX,
         clampedY,
         valid,
@@ -290,6 +352,14 @@ const MoveWindowTool: React.FC<{ node: WindowNode }> = ({ node: movingWindowNode
     }
 
     const applyPreview = (target: NonNullable<typeof lastTarget>) => {
+      // Same click as the off-wall ghost: one grid-snap tick per grid step,
+      // keyed on the RAW cursor along-wall position (not the snapped clampedX).
+      // Per-frame guard collapses duplicate wall events on the same pointermove.
+      tickGridStep(target.event.nativeEvent?.timeStamp ?? -1, target.event.localPosition[0])
+      // Keep the REAL node hidden and show a tinted ghost in the wall opening —
+      // green when placeable, red when it collides — matching the free-follow
+      // ghost so validity reads at a glance (see MoveDoorTool). The node position
+      // is still written so the wall cuts the hole at the right spot.
       if (currentHostId !== target.wallId) {
         useScene.getState().updateNode(movingWindowNode.id, {
           position: [target.clampedX, target.clampedY, 0],
@@ -299,6 +369,7 @@ const MoveWindowTool: React.FC<{ node: WindowNode }> = ({ node: movingWindowNode
           wallId: target.wallId,
           roofSegmentId: undefined,
           roofFace: undefined,
+          visible: false,
         })
         markHostDirty(currentHostId)
         currentHostId = target.wallId
@@ -316,17 +387,28 @@ const MoveWindowTool: React.FC<{ node: WindowNode }> = ({ node: movingWindowNode
       })
       markHostDirtyThrottled(target.wallId)
 
-      updateCursor(
-        wallLocalToWorld(
+      if (cursorGroupRef.current) cursorGroupRef.current.visible = false
+      const placement = resolveOpeningPlacement({ collides: !target.valid, forcePlace: shiftHeld })
+      // Ghost world yaw must equal the committed wall-CHILD's world yaw
+      // (-wallAngle + itemRotation); `cursorRotation` is π off here. See
+      // `MoveDoorTool.applyPreview`.
+      const wallAngle = Math.atan2(
+        target.wallNode.end[1] - target.wallNode.start[1],
+        target.wallNode.end[0] - target.wallNode.start[0],
+      )
+      setGhostPose({
+        position: wallLocalToWorld(
           target.wallNode,
           target.clampedX,
           target.clampedY,
           getLevelYOffset(),
           getSlabElevation(target.event),
         ),
-        target.cursorRotation,
-        target.valid,
-      )
+        rotationY: target.itemRotation - wallAngle,
+        tint: placement.tint,
+        floorY: getLevelYOffset() + getSlabElevation(target.event),
+        side: target.side,
+      })
 
       publishOpeningGuidesForWallEvent({
         wall: target.wallNode,
@@ -410,6 +492,8 @@ const MoveWindowTool: React.FC<{ node: WindowNode }> = ({ node: movingWindowNode
           parentId: target.wallId,
           roofSegmentId: undefined,
           roofFace: undefined,
+          // Hidden during free-follow; the committed window must be visible.
+          visible: true,
         })
         useScene.getState().createNode(node, target.wallId as AnyNodeId)
         placedId = node.id
@@ -425,6 +509,7 @@ const MoveWindowTool: React.FC<{ node: WindowNode }> = ({ node: movingWindowNode
           roofSegmentId: original.roofSegmentId,
           roofFace: original.roofFace,
           metadata: original.metadata,
+          visible: original.visible,
         })
         useScene.temporal.getState().resume()
 
@@ -436,6 +521,7 @@ const MoveWindowTool: React.FC<{ node: WindowNode }> = ({ node: movingWindowNode
           wallId: target.wallId,
           roofSegmentId: undefined,
           metadata: {},
+          visible: true,
         })
 
         if (original.parentId && original.parentId !== target.wallId) {
@@ -462,7 +548,11 @@ const MoveWindowTool: React.FC<{ node: WindowNode }> = ({ node: movingWindowNode
       if (event.node.parentId !== getLevelId()) return
 
       const target = lastTarget?.wallId === event.node.id ? lastTarget : resolveMoveTarget(event)
-      if (!target?.valid) return
+      // Shift force-places: commit even when the window overlaps another opening.
+      // The preview keeps its red invalid tint as a warning; Shift just lifts the
+      // commit block. Read shift from THIS event so it's never stale at commit.
+      if (!target) return
+      if (!target.valid && event.nativeEvent?.shiftKey !== true) return
       commitToWall(target)
       event.stopPropagation()
     }
@@ -480,13 +570,28 @@ const MoveWindowTool: React.FC<{ node: WindowNode }> = ({ node: movingWindowNode
       lastRoofEvent = null
     }
 
-    // Free-follow: the window rides the cursor over empty floor, parented to
-    // the level like an item node, kept at a sensible sill height. No wall to
-    // attach to, so it is not committable here.
-    const freeFollowAt = (localX: number, localZ: number) => {
+    // Reveal the real window node + drop the ghost. Used by the roof-face path,
+    // which previews with the real mesh (the ghost-tint flow is wall-specific).
+    const revealRealNode = () => {
+      setGhostPose(null)
+      const live = useScene.getState().nodes[movingWindowNode.id as AnyNodeId] as
+        | WindowNode
+        | undefined
+      if (live && live.visible === false) {
+        useScene.getState().updateNode(movingWindowNode.id, { visible: true })
+      }
+    }
+
+    // Free-follow: over open floor there's no wall to host the window, so hide
+    // the real (pale, near-invisible-on-grid) node and float a red translucent
+    // ghost at the cursor — same treatment the raw `WindowTool` build path uses.
+    const freeFollowAt = (localX: number, localZ: number, frame: number) => {
       freeFollowing = true
       lastTarget = null
       lastRoofEvent = null
+      // Click per grid cell as the ghost slides over open floor (X+Z) — the
+      // same `tickGridStep` the on-wall slide uses, so both feel identical.
+      tickGridStep(frame, localX, localZ)
       hideCursor()
       useLiveTransforms.getState().clear(movingWindowNode.id)
       const levelId = getLevelId()
@@ -503,6 +608,7 @@ const MoveWindowTool: React.FC<{ node: WindowNode }> = ({ node: movingWindowNode
           wallId: undefined,
           roofSegmentId: undefined,
           roofFace: undefined,
+          visible: false,
         })
         currentHostId = levelId
       } else {
@@ -510,8 +616,18 @@ const MoveWindowTool: React.FC<{ node: WindowNode }> = ({ node: movingWindowNode
           position: [localX, sillCenterY, localZ],
           rotation: [0, yaw, 0],
           side: sideOverride,
+          visible: false,
         })
       }
+      // Float the red (invalid — no wall) ghost at the cursor, level-Y lifted to
+      // the sill center (sideOverride carries the R-flip so the ghost matches).
+      setGhostPose({
+        position: [localX, getLevelYOffset() + sillCenterY, localZ],
+        rotationY: yaw,
+        tint: 'invalid',
+        floorY: getLevelYOffset(),
+        side: sideOverride,
+      })
     }
 
     const onGridMove = (event: GridEvent) => {
@@ -523,7 +639,8 @@ const MoveWindowTool: React.FC<{ node: WindowNode }> = ({ node: movingWindowNode
       // snapping engages only when the cursor ray actually hovers a wall.
       if (event.nativeEvent?.timeStamp === lastMeshEventTime) return
       const [x, , z] = event.localPosition
-      freeFollowAt(x, z)
+      lastFloorPoint = [x, z]
+      freeFollowAt(x, z, event.nativeEvent?.timeStamp ?? -1)
     }
 
     // ── Roof-segment wall faces ─────────────────────────────────────
@@ -564,6 +681,8 @@ const MoveWindowTool: React.FC<{ node: WindowNode }> = ({ node: movingWindowNode
       useLiveTransforms.getState().clear(movingWindowNode.id)
       // Opening guides are wall-specific; clear them when over a roof face.
       clearOpeningGuides3D()
+      // On a roof face the real mesh is the preview — drop the ghost + reveal.
+      revealRealNode()
       if (currentHostId !== target.segment.id) {
         useScene.getState().updateNode(movingWindowNode.id, {
           position: target.position,
@@ -573,6 +692,7 @@ const MoveWindowTool: React.FC<{ node: WindowNode }> = ({ node: movingWindowNode
           wallId: undefined,
           roofSegmentId: target.segment.id,
           roofFace: target.face.id,
+          visible: true,
         })
         markHostDirty(currentHostId)
         currentHostId = target.segment.id
@@ -590,7 +710,9 @@ const MoveWindowTool: React.FC<{ node: WindowNode }> = ({ node: movingWindowNode
     const onRoofClick = (event: RoofEvent) => {
       if (committed) return
       const target = resolveRoofMoveTarget(event)
-      if (!target?.valid) return
+      // Shift force-places over a colliding roof-face target too (see onWallClick).
+      if (!target) return
+      if (!target.valid && event.nativeEvent?.shiftKey !== true) return
       committed = true
       const segmentId = target.segment.id
 
@@ -613,6 +735,7 @@ const MoveWindowTool: React.FC<{ node: WindowNode }> = ({ node: movingWindowNode
           roofSegmentId: segmentId,
           roofFace: target.face.id,
           parentId: segmentId,
+          visible: true,
         })
         useScene.getState().createNode(node, segmentId as AnyNodeId)
         placedId = node.id
@@ -626,6 +749,7 @@ const MoveWindowTool: React.FC<{ node: WindowNode }> = ({ node: movingWindowNode
           roofSegmentId: original.roofSegmentId,
           roofFace: original.roofFace,
           metadata: original.metadata,
+          visible: original.visible,
         })
         useScene.temporal.getState().resume()
 
@@ -638,6 +762,7 @@ const MoveWindowTool: React.FC<{ node: WindowNode }> = ({ node: movingWindowNode
           roofSegmentId: segmentId,
           roofFace: target.face.id,
           metadata: {},
+          visible: true,
         })
 
         if (original.parentId && original.parentId !== segmentId) {
@@ -682,6 +807,7 @@ const MoveWindowTool: React.FC<{ node: WindowNode }> = ({ node: movingWindowNode
           roofSegmentId: original.roofSegmentId,
           roofFace: original.roofFace,
           metadata: original.metadata,
+          visible: original.visible,
         })
         if (original.parentId) markHostDirty(original.parentId)
       }
@@ -693,8 +819,10 @@ const MoveWindowTool: React.FC<{ node: WindowNode }> = ({ node: movingWindowNode
     const onPlacementDragPointerUp = (event: PointerEvent) => {
       if (!consumePlacementDragRelease(event)) return
       // Free-following over open floor can't commit (no wall). A wall hover
-      // target commits via commitToWall; a roof face via onRoofClick.
-      if (lastTarget?.valid && !freeFollowing) {
+      // target commits via commitToWall; a roof face via onRoofClick. Shift
+      // force-places over a colliding wall target (tint stays red as a warning);
+      // read shift from this pointerup so it's current at commit.
+      if (lastTarget && !freeFollowing && (lastTarget.valid || event.shiftKey)) {
         commitToWall(lastTarget)
         return
       }
@@ -714,18 +842,27 @@ const MoveWindowTool: React.FC<{ node: WindowNode }> = ({ node: movingWindowNode
       ) {
         return
       }
-      const onWall = lastTarget !== null
-      if (!(onWall || freeFollowing)) return
+      // Ignore OS key-repeat so a held R doesn't flip many times per press.
+      if (e.repeat) return
       e.preventDefault()
+      // ALWAYS toggle the persistent flip intent — never a no-op (the old gate
+      // dropped R before the first pointermove). Then re-render the current
+      // preview so the flip shows live and matches commit. See `MoveDoorTool`.
       sideOverride = sideOverride === 'front' ? 'back' : 'front'
       triggerSFX('sfx:item-rotate')
-      if (onWall) {
-        const next = resolveMoveTarget(lastTarget!.event)
+      if (lastTarget) {
+        const next = resolveMoveTarget(lastTarget.event)
         if (next) {
           lastTarget = next
           applyPreview(next)
         }
+      } else if (lastFloorPoint) {
+        // Free-following: re-run at the same spot so the floating ghost rebuilds
+        // with the flipped side.
+        freeFollowAt(lastFloorPoint[0], lastFloorPoint[1], -1)
       } else {
+        // No preview yet (R before the first pointermove): flip the hidden node
+        // so the first preview/commit already reflects the chosen side.
         useScene.getState().updateNode(movingWindowNode.id, {
           side: sideOverride,
           rotation: [0, sideOverride === 'back' ? Math.PI : 0, 0],
@@ -733,6 +870,16 @@ const MoveWindowTool: React.FC<{ node: WindowNode }> = ({ node: movingWindowNode
       }
     }
 
+    // Shift toggles force-place — re-run the on-wall preview so the tint flips
+    // green↔red live (pointer stationary). Commit gates still read shift fresh.
+    const onShiftToggle = (e: KeyboardEvent) => {
+      if (e.key !== 'Shift') return
+      const held = e.type === 'keydown'
+      if (held === shiftHeld) return
+      shiftHeld = held
+      if (!committed && lastTarget) applyPreview(lastTarget)
+    }
+
     emitter.on('wall:enter', onWallEnter)
     emitter.on('wall:move', onWallMove)
     emitter.on('wall:click', onWallClick)
@@ -745,6 +892,8 @@ const MoveWindowTool: React.FC<{ node: WindowNode }> = ({ node: movingWindowNode
     emitter.on('tool:cancel', onCancel)
     window.addEventListener('pointerup', onPlacementDragPointerUp)
     window.addEventListener('keydown', onKeyDown)
+    window.addEventListener('keydown', onShiftToggle)
+    window.addEventListener('keyup', onShiftToggle)
 
     return () => {
       // Safety cleanup: if still transient on unmount (e.g. phase switch mid-move)
@@ -766,9 +915,15 @@ const MoveWindowTool: React.FC<{ node: WindowNode }> = ({ node: movingWindowNode
             roofSegmentId: original.roofSegmentId,
             roofFace: original.roofFace,
             metadata: original.metadata,
+            visible: original.visible,
           })
           if (original.parentId) markHostDirty(original.parentId)
         }
+      } else if (current && current.visible === false) {
+        // Safety net: a fresh (isNew) clone isn't marked `isTransient`; if we
+        // unmount mid-free-follow it would be left hidden. Reveal it so it never
+        // becomes an invisible orphan (place-preset deletes a true cancel).
+        useScene.getState().updateNode(movingWindowNode.id, { visible: true })
       }
       useLiveTransforms.getState().clear(movingWindowNode.id)
       useAlignmentGuides.getState().clear()
@@ -786,6 +941,8 @@ const MoveWindowTool: React.FC<{ node: WindowNode }> = ({ node: movingWindowNode
       emitter.off('tool:cancel', onCancel)
       window.removeEventListener('pointerup', onPlacementDragPointerUp)
       window.removeEventListener('keydown', onKeyDown)
+      window.removeEventListener('keydown', onShiftToggle)
+      window.removeEventListener('keyup', onShiftToggle)
     }
   }, [movingWindowNode, exitMoveMode])
 
@@ -802,9 +959,35 @@ const MoveWindowTool: React.FC<{ node: WindowNode }> = ({ node: movingWindowNode
   useEffect(() => () => edgesGeo.dispose(), [edgesGeo])
 
   return (
-    <group ref={cursorGroupRef} visible={false}>
-      <lineSegments geometry={edgesGeo} layers={EDITOR_LAYER} material={edgeMaterial} />
-    </group>
+    <>
+      <group ref={cursorGroupRef} visible={false}>
+        <lineSegments geometry={edgesGeo} layers={EDITOR_LAYER} material={edgeMaterial} />
+      </group>
+      {/* Placement ghost shown for the whole move (the real pale node stays
+          hidden): red off-wall / colliding, green on a valid wall. */}
+      {ghostPose && (
+        <group position={ghostPose.position} rotation-y={ghostPose.rotationY}>
+          <WindowPreview
+            invalid={ghostPose.tint === 'invalid'}
+            node={ghostNode}
+            valid={ghostPose.tint === 'valid'}
+          />
+        </group>
+      )}
+      {/* Floor "shadow" projection: footprint + dashed drop-line, so an elevated
+          window's plan position is legible while placing. World-space, so it's a
+          sibling of the ghost group, not a child. */}
+      {ghostPose && (
+        <WindowFloorProjection
+          centerX={ghostPose.position[0]}
+          centerY={ghostPose.position[1]}
+          centerZ={ghostPose.position[2]}
+          floorY={ghostPose.floorY}
+          rotationY={ghostPose.rotationY}
+          width={movingWindowNode.width}
+        />
+      )}
+    </>
   )
 }
 

packages/nodes/src/window/preview.tsx

@@ -16,7 +16,15 @@ import type { WindowNode } from './schema'
  * The root mesh's layer is set to EDITOR_LAYER because the invisible hitbox
  * material on SCENE_LAYER would poison the WebGPU MRT pass (project gotcha).
  */
-const WindowPreview = ({ node, invalid }: { node: WindowNode; invalid?: boolean }) => {
+const WindowPreview = ({
+  node,
+  invalid,
+  valid,
+}: {
+  node: WindowNode
+  invalid?: boolean
+  valid?: boolean
+}) => {
   const mesh = useMemo(() => {
     const m = buildWindowPreviewMesh(node)
     m.layers.set(EDITOR_LAYER)
@@ -32,9 +40,9 @@ const WindowPreview = ({ node, invalid }: { node: WindowNode; invalid?: boolean
     node.sillThickness,
   ])
 
-  // Ghost treatment (clone + tint + raycast-off) re-applies if `invalid`
-  // flips; its cleanup only disposes the clones it made.
-  useEffect(() => applyGhost(mesh, { invalid }), [mesh, invalid])
+  // Ghost treatment (clone + tint + raycast-off) re-applies if the tint flips;
+  // its cleanup only disposes the clones it made.
+  useEffect(() => applyGhost(mesh, { invalid, valid }), [mesh, invalid, valid])
 
   // Geometry is freshly built per `mesh` and owned here — dispose it only
   // when the mesh itself is replaced/unmounted, never on an `invalid` toggle.

packages/nodes/src/window/tool.tsx

@@ -39,8 +39,14 @@ import {
   worldToSelectedBuildingLocal,
 } from '../shared/roof-wall-opening-placement'
 import { resolveWallSlideAlignment } from '../shared/wall-opening-alignment'
+import { WindowFloorProjection } from './floor-projection'
 import WindowPreview from './preview'
-import { clampToWall, hasWallChildOverlap, wallLocalToWorld } from './window-math'
+import {
+  clampToWall,
+  DEFAULT_WINDOW_SILL_M,
+  hasWallChildOverlap,
+  wallLocalToWorld,
+} from './window-math'
 
 // Shared edge material — reuse across renders, just toggle color
 const edgeMaterial = new LineBasicNodeMaterial({
@@ -52,10 +58,12 @@ const edgeMaterial = new LineBasicNodeMaterial({
 
 const FALLBACK_WIDTH = 1.5
 const FALLBACK_HEIGHT = 1.5
-const FALLBACK_SILL_LIFT = 0.45
+// Off-wall ghost lift = the default sill, so the floating preview matches the
+// sill the floor-cursor placement commits at.
+const FALLBACK_SILL_LIFT = DEFAULT_WINDOW_SILL_M
 // Default sill centre for a window snapped from the floor (the floor cursor
-// carries no wall-face height). 0.9 m sill + half the 1.5 m default height.
-const DEFAULT_SILL_CENTER_Y = 0.9 + FALLBACK_HEIGHT / 2
+// carries no wall-face height): the default sill + half the default height.
+const DEFAULT_SILL_CENTER_Y = DEFAULT_WINDOW_SILL_M + FALLBACK_HEIGHT / 2
 const roofFallbackPoint = new Vector3()
 
 // What currently owns the cursor frame: a wall/roof mesh hover, or null when
@@ -79,14 +87,24 @@ const WindowTool: React.FC = () => {
 
   // Off-host floating ghost: the real window geometry follows the cursor
   // over the grid (tinted invalid). Mutually exclusive with the on-host draft.
+  // `floorY` feeds the floor "shadow" projection; `side` carries the R-flip so
+  // the floating ghost faces the side that will be committed.
   const [fallbackPose, setFallbackPose] = useState<{
     position: [number, number, number]
     rotationY: number
+    floorY: number
+    side: WindowNode['side']
   } | null>(null)
 
+  // Ghost preview node — zeroed transform + the live facing side (rebuilds on R).
   const ghostStub = useMemo(
-    () => WindowNode.parse({ position: [0, 0, 0], rotation: [0, 0, 0] }),
-    [],
+    () =>
+      WindowNode.parse({
+        position: [0, 0, 0],
+        rotation: [0, 0, 0],
+        side: fallbackPose?.side ?? 'front',
+      }),
+    [fallbackPose?.side],
   )
 
   useEffect(() => {
@@ -104,6 +122,9 @@ const WindowTool: React.FC = () => {
     // to the last wall hover so the flip shows live before commit.
     let sideFlip = false
     let lastWallEvent: WallEvent | null = null
+    // Last open-floor cursor point (level-local X/Z) + floor Y, so an R-flip
+    // while free-following can re-render the floating ghost with the new facing.
+    let lastFloorPoint: { pos: [number, number, number]; floorY: number } | null = null
 
     const getLevelId = () => useViewer.getState().selection.levelId
     const getLevelYOffset = () => {
@@ -157,21 +178,34 @@ const WindowTool: React.FC = () => {
 
     // Off-host fallback: hide the wireframe outline and float the real window
     // geometry (tinted invalid) at the cursor so the armed tool is visible.
-    const showGhostAt = (position: [number, number, number]) => {
+    const showGhostAt = (position: [number, number, number], floorY: number) => {
       if (cursorGroupRef.current) cursorGroupRef.current.visible = false
-      setFallbackPose({ position, rotationY: 0 })
+      lastFloorPoint = { pos: position, floorY }
+      // `sideFlip` (R) flips the facing — back is a π yaw on the floating ghost.
+      setFallbackPose({
+        position,
+        rotationY: sideFlip ? Math.PI : 0,
+        floorY,
+        side: sideFlip ? 'back' : 'front',
+      })
       useAlignmentGuides.getState().clear()
       clearOpeningGuides3D()
     }
 
     const showRoofFallbackCursor = (event: RoofEvent) => {
       const [x, , z] = worldToSelectedBuildingLocal(roofFallbackPoint.set(...event.position))
-      showGhostAt([x, getLevelYOffset() + FALLBACK_HEIGHT / 2 + FALLBACK_SILL_LIFT, z])
+      showGhostAt(
+        [x, getLevelYOffset() + FALLBACK_HEIGHT / 2 + FALLBACK_SILL_LIFT, z],
+        getLevelYOffset(),
+      )
     }
 
     const showWallFallbackCursor = (event: WallEvent) => {
       const [x, , z] = worldToSelectedBuildingLocal(roofFallbackPoint.set(...event.position))
-      showGhostAt([x, getLevelYOffset() + FALLBACK_HEIGHT / 2 + FALLBACK_SILL_LIFT, z])
+      showGhostAt(
+        [x, getLevelYOffset() + FALLBACK_HEIGHT / 2 + FALLBACK_SILL_LIFT, z],
+        getLevelYOffset(),
+      )
     }
 
     // Sill alignment (snap + guide): a sibling sill/centre/top wins over the
@@ -211,13 +245,16 @@ const WindowTool: React.FC = () => {
       bypassSnap: boolean,
       ignoreId?: string,
     ) => {
+      // bypassSnap is set by Shift (see callers). Shift = free-place: land at the
+      // raw cursor but keep the along-wall guides visible. bypass (Alt) still
+      // hard-disables alignment.
       const localX = resolveWallSlideAlignment({
         wallNode: wall,
         rawLocalX,
         width,
         candidates: alignmentCandidates,
-        bypass,
-        bypassSnap,
+        bypass: bypass && !bypassSnap,
+        freePlace: bypassSnap,
       })
       const localY = resolvePlacementY({
         wall,
@@ -454,7 +491,8 @@ const WindowTool: React.FC = () => {
         bypassSnap,
         draftRef.current.id,
       )
-      if (!valid) return
+      // Shift force-places over a collision (the draft stays red as a warning).
+      if (!valid && !bypassSnap) return
 
       commitWindowAtWall(event.node, clampedX, clampedY, side, itemRotation)
       event.stopPropagation()
@@ -485,7 +523,7 @@ const WindowTool: React.FC = () => {
       lastWallEvent = null
       const [x, y, z] = event.localPosition
       destroyDraft()
-      showGhostAt([x, y + FALLBACK_HEIGHT / 2 + FALLBACK_SILL_LIFT, z])
+      showGhostAt([x, y + FALLBACK_HEIGHT / 2 + FALLBACK_SILL_LIFT, z], y)
     }
 
     // ── Roof-segment wall faces ─────────────────────────────────────
@@ -553,7 +591,9 @@ const WindowTool: React.FC = () => {
     const onRoofClick = (event: RoofEvent) => {
       if (!draftRef.current?.roofSegmentId) return
       const target = resolveRoofTarget(event)
-      if (!target?.valid) return
+      // Shift force-places over a colliding roof-face target (see onWallClick).
+      if (!target) return
+      if (!target.valid && event.nativeEvent?.shiftKey !== true) return
       const { segment, face, position } = target
 
       const draft = draftRef.current
@@ -617,19 +657,24 @@ const WindowTool: React.FC = () => {
       hostKind = null
     }
 
-    // R flips the window's facing side mid-placement (front ↔ back), like the
-    // committed-selected R flip. Only meaningful while snapped to a wall (the
-    // off-wall ghost has no orientation), so it acts only then — re-applying
-    // the last wall hover so the snapped preview flips live.
+    // R flips the window's facing side mid-placement (front ↔ back). ALWAYS
+    // toggles the persistent flip intent — never a no-op (the old `!lastWallEvent`
+    // guard dropped R off-wall / before the first hover). Then re-renders the
+    // current preview so the flip shows live and matches commit.
     const onKeyDown = (e: KeyboardEvent) => {
       if (e.key !== 'r' && e.key !== 'R') return
-      if (!lastWallEvent) return
+      if (e.repeat) return
       const t = e.target as HTMLElement | null
       if (t && (t.tagName === 'INPUT' || t.tagName === 'TEXTAREA' || t.isContentEditable)) return
       e.preventDefault()
       sideFlip = !sideFlip
       triggerSFX('sfx:item-rotate')
-      onWallHover(lastWallEvent)
+      if (lastWallEvent) {
+        onWallHover(lastWallEvent)
+      } else if (lastFloorPoint) {
+        showGhostAt(lastFloorPoint.pos, lastFloorPoint.floorY)
+      }
+      // else: no preview yet — `sideFlip` is set, so the first hover/follow uses it.
     }
 
     emitter.on('wall:enter', onWallHover)
@@ -690,6 +735,18 @@ const WindowTool: React.FC = () => {
           <WindowPreview invalid node={ghostStub} />
         </group>
       )}
+      {/* Floor "shadow" projection for the off-host ghost (drop-line + footprint)
+          so the elevated window's plan position is legible while placing. */}
+      {fallbackPose && (
+        <WindowFloorProjection
+          centerX={fallbackPose.position[0]}
+          centerY={fallbackPose.position[1]}
+          centerZ={fallbackPose.position[2]}
+          floorY={fallbackPose.floorY}
+          rotationY={fallbackPose.rotationY}
+          width={FALLBACK_WIDTH}
+        />
+      )}
     </>
   )
 }

packages/nodes/src/window/window-math.ts

@@ -1,12 +1,13 @@
-import {
-  type AnyNodeId,
-  type DoorNode,
-  getScaledDimensions,
-  type ItemNode,
-  useScene,
-  type WallNode,
-  type WindowNode,
-} from '@pascal-app/core'
+import type { WallNode } from '@pascal-app/core'
+
+/**
+ * Default sill height (metres from the floor to the BOTTOM of a window) for a
+ * fresh window that has no wall-face height yet — the off-wall ghost and the
+ * floor-cursor placement use it so a new window floats slightly above the
+ * ground rather than sitting on it. The committed Y is the window's CENTRE, so
+ * callers add `height / 2`. An existing window keeps its own sill.
+ */
+export const DEFAULT_WINDOW_SILL_M = 0.5
 
 /**
  * Converts wall-local (X along wall, Y = height above wall base) to world XYZ.
@@ -54,64 +55,8 @@ export function clampToWall(
 }
 
 /**
- * Directly checks the wall's children for bounding-box overlap with a proposed window.
- * Works for both `item` type (position[1] = bottom) and `window` type (position[1] = center).
- * The spatial grid only tracks `item` nodes, so windows must be checked this way.
- * Reads the wall's latest children from the store (not the event node) to avoid stale data.
+ * Wall-child overlap is shared by door + window placement (one source of
+ * truth in `shared/wall-attach-target.ts`). Re-exported here so existing
+ * `./window-math` importers don't change.
  */
-export function hasWallChildOverlap(
-  wallId: string,
-  clampedX: number,
-  clampedY: number,
-  width: number,
-  height: number,
-  ignoreId?: string,
-): boolean {
-  const nodes = useScene.getState().nodes
-  const wallNode = nodes[wallId as AnyNodeId] as WallNode | undefined
-  if (!wallNode) return true // Block if wall not found
-  const halfW = width / 2
-  const halfH = height / 2
-  const newBottom = clampedY - halfH
-  const newTop = clampedY + halfH
-  const newLeft = clampedX - halfW
-  const newRight = clampedX + halfW
-
-  for (const childId of Array.isArray(wallNode.children) ? wallNode.children : []) {
-    if (childId === ignoreId) continue
-    const child = nodes[childId as AnyNodeId]
-    if (!child) continue
-
-    let childLeft: number, childRight: number, childBottom: number, childTop: number
-
-    if (child.type === 'item') {
-      const item = child as ItemNode
-      if (item.asset.attachTo !== 'wall' && item.asset.attachTo !== 'wall-side') continue
-      const [w, h] = getScaledDimensions(item)
-      childLeft = item.position[0] - w / 2
-      childRight = item.position[0] + w / 2
-      childBottom = item.position[1] // items store bottom Y
-      childTop = item.position[1] + h
-    } else if (child.type === 'window') {
-      const win = child as WindowNode
-      childLeft = win.position[0] - win.width / 2
-      childRight = win.position[0] + win.width / 2
-      childBottom = win.position[1] - win.height / 2 // windows store center Y
-      childTop = win.position[1] + win.height / 2
-    } else if (child.type === 'door') {
-      const door = child as DoorNode
-      childLeft = door.position[0] - door.width / 2
-      childRight = door.position[0] + door.width / 2
-      childBottom = door.position[1] - door.height / 2 // doors store center Y
-      childTop = door.position[1] + door.height / 2
-    } else {
-      continue
-    }
-
-    const xOverlap = newLeft < childRight && newRight > childLeft
-    const yOverlap = newBottom < childTop && newTop > childBottom
-    if (xOverlap && yOverlap) return true
-  }
-
-  return false
-}
+export { hasWallChildOverlap } from '../shared/wall-attach-target'