@pascal-app/editor 0.9.1 → 1.0.0-beta.1

package/src/components/tools/item/placement-strategies.ts

@@ -6,19 +6,28 @@ import type {
   GridEvent,
   ItemEvent,
   ItemNode,
+  RoofEvent,
+  RoofNode,
+  RoofSegmentNode,
+  RoofWallFaceId,
   ShelfEvent,
   ShelfNode,
   WallEvent,
   WallNode,
 } from '@pascal-app/core'
 import {
+  canHostOnTop,
+  clampRectToRoofWallFace,
+  getRoofSegmentWallFace,
   getScaledDimensions,
   isLowProfileItemSurface,
   nodeRegistry,
+  roofFacePointToSegment,
   sceneRegistry,
   useScene,
 } from '@pascal-app/core'
 import { Euler, Matrix3, Quaternion, Vector3 } from 'three'
+import { hasRoofFaceChildOverlap, resolveRoofWallHit } from '../../../lib/roof-wall-hit'
 import { snapWorldXZForActiveBuilding } from '../../../lib/world-grid-snap'
 import {
   calculateCursorRotation,
@@ -56,6 +65,7 @@ function isUpwardItemSurfaceHit(event: ItemEvent): boolean {
 }
 
 function getSurfacePlacementHeight(surfaceItem: ItemNode, event: ItemEvent, localPos: Vector3) {
+  if (!canHostOnTop(surfaceItem)) return null
   if (isLowProfileItemSurface(surfaceItem)) return null
   if (!isUpwardItemSurfaceHit(event)) return null
 
@@ -105,10 +115,13 @@ export const floorStrategy = {
     // is rotated; then project the world point back into building-local
     // for storage. Without this, a rotated building drags placement off
     // the world grid.
-    const snappedWorldX = snapToGrid(event.position[0], swapDims ? dimZ : dimX)
-    const snappedWorldZ = snapToGrid(event.position[2], swapDims ? dimX : dimZ)
-    const { local } = snapWorldXZForActiveBuilding(snappedWorldX, snappedWorldZ, 0)
-    const [x, z] = local
+    // Snapping is governed by the active mode (snapToGrid returns raw in Off /
+    // non-grid modes); Alt is force-place only and never bypasses snapping here.
+    const [x, z] = snapWorldXZForActiveBuilding(
+      snapToGrid(event.position[0], swapDims ? dimZ : dimX),
+      snapToGrid(event.position[2], swapDims ? dimX : dimZ),
+      0,
+    ).local
     const y = ctx.gridPosition.y
 
     return {
@@ -132,6 +145,7 @@ export const floorStrategy = {
   ): CommitResult | null {
     if (ctx.state.surface !== 'floor') return null
     if (!(ctx.levelId && ctx.draftItem)) return null
+    if (ctx.draftItem.asset.attachTo) return null
 
     const pos: [number, number, number] = [
       ctx.gridPosition.x,
@@ -211,10 +225,13 @@ export const wallStrategy = {
     const adjustedY = validation.adjustedY ?? y
 
     return {
-      stateUpdate: { surface: 'wall', wallId: event.node.id },
+      stateUpdate: { surface: 'wall', wallId: event.node.id, roofSegmentId: null },
       nodeUpdate: {
         position: [x, adjustedY, z],
         parentId: event.node.id,
+        // The draft may arrive from a roof-segment wall face.
+        roofSegmentId: undefined,
+        roofFace: undefined,
         side,
         rotation: [0, itemRotation, 0],
       },
@@ -313,6 +330,8 @@ export const wallStrategy = {
       nodeUpdate: {
         position: [ctx.gridPosition.x, ctx.gridPosition.y, ctx.gridPosition.z],
         parentId: event.node.id,
+        roofSegmentId: undefined,
+        roofFace: undefined,
         side: ctx.draftItem.side,
         rotation: ctx.draftItem.rotation,
         metadata: stripTransient(ctx.draftItem.metadata),
@@ -342,6 +361,225 @@ export const wallStrategy = {
   },
 }
 
+// ============================================================================
+// ROOF WALL STRATEGY
+// ============================================================================
+
+type RoofWallTarget = {
+  segment: RoofSegmentNode
+  faceId: RoofWallFaceId
+  faceYaw: number
+  /** Stored node position: FACE-LOCAL, y = bottom edge. */
+  position: [number, number, number]
+  /** Face-coord center of the placed rect (for the overlap guard). */
+  centerU: number
+  centerV: number
+  width: number
+  height: number
+  cursorPosition: [number, number, number]
+  cursorRotationY: number
+}
+
+/**
+ * Resolve a roof pointer event to an item placement on a segment wall
+ * face. Items snap u / bottom-v to the 0.5m grid, then the rect is
+ * clamped inside the face profile (sliding under the gable slopes).
+ * Position frame matches wall hosting: y anchors the BOTTOM edge;
+ * `wall-side` items mount on the outer surface, `wall` items center in
+ * the wall thickness.
+ *
+ * `freePlace` mirrors the wall flow's Alt override (stubbed
+ * validators): the profile clamp is skipped, so the rect may overhang
+ * the face edges — placement follows the snapped cursor as-is.
+ */
+function resolveRoofWallTarget(
+  ctx: PlacementContext,
+  event: RoofEvent,
+  freePlace = false,
+): RoofWallTarget | null {
+  const attachTo = ctx.asset.attachTo
+  if (attachTo !== 'wall' && attachTo !== 'wall-side') return null
+
+  const hit = resolveRoofWallHit(event.node as RoofNode, event.position, event.normal, event.object)
+  if (!hit) return null
+
+  const rawDims = ctx.draftItem
+    ? getScaledDimensions(ctx.draftItem)
+    : (ctx.asset.dimensions ?? DEFAULT_DIMENSIONS)
+  const dims = getGridAlignedDimensions(rawDims, attachTo)
+  const [width, height] = dims
+
+  // Snap follows the active mode (snapToHalf returns raw in Off/non-grid);
+  // `freePlace` (Alt) is force-place — it only skips the face-fit validity gate.
+  const u = snapToHalf(hit.u)
+  const centerV = snapToHalf(hit.v) + height / 2
+  const fitted = freePlace ? null : clampRectToRoofWallFace(hit.face, u, centerV, width, height)
+  if (!fitted && !freePlace) return null
+  const finalU = fitted?.u ?? u
+  const finalV = fitted?.v ?? centerV
+
+  // FACE-LOCAL storage (z = 0 → wall mid-plane; ItemSystem pushes
+  // wall-side items to the outer surface, exactly like wall hosting).
+  // The renderer mounts the node inside the live face frame, so items
+  // track segment resizes without any re-anchoring.
+  const position: [number, number, number] = [finalU, finalV - height / 2, 0]
+
+  const segObj = sceneRegistry.nodes.get(hit.segment.id)
+  if (!segObj) return null
+  segObj.updateWorldMatrix(true, false)
+  const segLocal = roofFacePointToSegment(hit.segment, hit.face.id, position)
+  const worldPos = segObj.localToWorld(new Vector3(segLocal[0], segLocal[1], segLocal[2]))
+
+  const nodes = useScene.getState().nodes
+  const roof = hit.segment.parentId
+    ? (nodes[hit.segment.parentId as AnyNodeId] as RoofNode | undefined)
+    : undefined
+
+  return {
+    segment: hit.segment,
+    faceId: hit.face.id,
+    faceYaw: hit.face.yaw,
+    position,
+    centerU: finalU,
+    centerV: finalV,
+    width,
+    height,
+    cursorPosition: [worldPos.x, worldPos.y, worldPos.z],
+    cursorRotationY: (roof?.rotation ?? 0) + (hit.segment.rotation ?? 0) + hit.face.yaw,
+  }
+}
+
+/** Validation half of `checkCanPlace` for the roof-wall surface. */
+function canPlaceOnRoofWall(ctx: PlacementContext): boolean {
+  const segmentId = ctx.state.roofSegmentId
+  if (!(segmentId && ctx.draftItem)) return false
+  const segment = useScene.getState().nodes[segmentId as AnyNodeId] as RoofSegmentNode | undefined
+  if (segment?.type !== 'roof-segment') return false
+  const faceId = ctx.draftItem.roofFace
+  if (!faceId) return false
+  const face = getRoofSegmentWallFace(segment, faceId)
+
+  const dims = getGridAlignedDimensions(
+    getScaledDimensions(ctx.draftItem),
+    ctx.draftItem.asset.attachTo,
+  )
+  const [width, height] = dims
+  // gridPosition carries the stored FACE-LOCAL coords (u, bottom-v, z).
+  const u = ctx.gridPosition.x
+  const centerV = ctx.gridPosition.y + height / 2
+  const clamped = clampRectToRoofWallFace(face, u, centerV, width, height)
+  if (!clamped || Math.abs(clamped.u - u) > 1e-3 || Math.abs(clamped.v - centerV) > 1e-3) {
+    return false
+  }
+  return !hasRoofFaceChildOverlap(segment, faceId, u, centerV, width, height, ctx.draftItem.id)
+}
+
+export const roofWallStrategy = {
+  /**
+   * Handle roof:enter / first hover — transition onto a segment wall
+   * face. Returns null when the item doesn't wall-attach or the pointer
+   * isn't over a placeable face.
+   */
+  enter(ctx: PlacementContext, event: RoofEvent, freePlace = false): TransitionResult | null {
+    const target = resolveRoofWallTarget(ctx, event, freePlace)
+    if (!target) return null
+
+    return {
+      stateUpdate: { surface: 'roof-wall', roofSegmentId: target.segment.id, wallId: null },
+      nodeUpdate: {
+        position: target.position,
+        parentId: target.segment.id,
+        roofSegmentId: target.segment.id,
+        roofFace: target.faceId,
+        wallId: undefined,
+        side: 'front',
+        rotation: [0, 0, 0],
+      },
+      cursorRotationY: target.cursorRotationY,
+      gridPosition: target.position,
+      cursorPosition: target.cursorPosition,
+      stopPropagation: true,
+    }
+  },
+
+  /**
+   * Handle roof:move while on a segment wall face. Returns null when the
+   * pointer resolves to a DIFFERENT segment (the coordinator re-enters —
+   * segment transitions inside one roof never re-fire roof:enter) or to
+   * no placeable face.
+   */
+  move(ctx: PlacementContext, event: RoofEvent, freePlace = false): PlacementResult | null {
+    if (ctx.state.surface !== 'roof-wall') return null
+    if (!ctx.draftItem) return null
+
+    const target = resolveRoofWallTarget(ctx, event, freePlace)
+    if (!target) return null
+    if (target.segment.id !== ctx.state.roofSegmentId) return null
+
+    return {
+      gridPosition: target.position,
+      cursorPosition: target.cursorPosition,
+      cursorRotationY: target.cursorRotationY,
+      nodeUpdate: {
+        position: target.position,
+        side: 'front',
+        rotation: [0, 0, 0],
+        roofFace: target.faceId,
+      },
+      stopPropagation: true,
+      // Items don't cut the roof — no geometry rebuild needed.
+      dirtyNodeId: null,
+    }
+  },
+
+  /**
+   * Handle roof:click — commit placement on the segment wall face.
+   */
+  click(ctx: PlacementContext, _event: RoofEvent, freePlace = false): CommitResult | null {
+    if (ctx.state.surface !== 'roof-wall') return null
+    if (!(ctx.draftItem && ctx.state.roofSegmentId)) return null
+    // Alt mirrors the wall flow's stubbed validators: skip profile-fit
+    // and overlap checks entirely.
+    if (!freePlace && !canPlaceOnRoofWall(ctx)) return null
+
+    return {
+      nodeUpdate: {
+        position: [ctx.gridPosition.x, ctx.gridPosition.y, ctx.gridPosition.z],
+        parentId: ctx.state.roofSegmentId,
+        roofSegmentId: ctx.state.roofSegmentId,
+        roofFace: ctx.draftItem.roofFace,
+        wallId: undefined,
+        side: 'front',
+        rotation: [0, 0, 0],
+        metadata: stripTransient(ctx.draftItem.metadata),
+      },
+      stopPropagation: true,
+      dirtyNodeId: null,
+    }
+  },
+
+  /**
+   * Handle roof:leave — transition back to floor surface.
+   */
+  leave(ctx: PlacementContext): TransitionResult | null {
+    if (ctx.state.surface !== 'roof-wall') return null
+
+    return {
+      stateUpdate: { surface: 'floor', roofSegmentId: null },
+      nodeUpdate: {
+        position: [ctx.gridPosition.x, ctx.gridPosition.y, ctx.gridPosition.z],
+        parentId: ctx.levelId,
+        roofSegmentId: undefined,
+        roofFace: undefined,
+      },
+      cursorRotationY: 0,
+      gridPosition: [ctx.gridPosition.x, ctx.gridPosition.y, ctx.gridPosition.z],
+      cursorPosition: [ctx.gridPosition.x, ctx.gridPosition.y, ctx.gridPosition.z],
+      stopPropagation: true,
+    }
+  },
+}
+
 // ============================================================================
 // CEILING STRATEGY
 // ============================================================================
@@ -794,6 +1032,9 @@ export function checkCanPlace(ctx: PlacementContext, validators: SpatialValidato
   }
 
   if (attachTo === 'wall' || attachTo === 'wall-side') {
+    if (ctx.state.surface === 'roof-wall') {
+      return canPlaceOnRoofWall(ctx)
+    }
     if (ctx.state.surface !== 'wall' || !ctx.state.wallId) return false
     return validators.canPlaceOnWall(
       ctx.levelId,

package/src/components/tools/item/placement-types.ts

@@ -12,7 +12,13 @@ import type { Vector3 } from 'three'
 // PLACEMENT STATE
 // ============================================================================
 
-export type SurfaceType = 'floor' | 'wall' | 'ceiling' | 'item-surface' | 'shelf-surface'
+export type SurfaceType =
+  | 'floor'
+  | 'wall'
+  | 'roof-wall'
+  | 'ceiling'
+  | 'item-surface'
+  | 'shelf-surface'
 
 /**
  * Tracks which surface the draft item is currently on.
@@ -21,6 +27,12 @@ export type SurfaceType = 'floor' | 'wall' | 'ceiling' | 'item-surface' | 'shelf
 export interface PlacementState {
   surface: SurfaceType
   wallId: string | null
+  /**
+   * Active roof-segment when `surface === 'roof-wall'` — wall-attach
+   * items also host on the vertical wall faces a roof segment generates
+   * (base walls + coplanar gable ends).
+   */
+  roofSegmentId: string | null
   ceilingId: string | null
   surfaceItemId: string | null
   /**

package/src/components/tools/item/use-draft-node.ts

@@ -2,12 +2,14 @@ import {
   type AnyNodeId,
   type AssetInput,
   ItemNode,
+  resolveSupportSlabPatch,
   sceneRegistry,
   useScene,
 } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
 import { useCallback, useMemo, useRef } from 'react'
 import type { Vector3 } from 'three'
+import usePlacementPreview from '../../../store/use-placement-preview'
 import { stripTransient } from './placement-math'
 
 interface OriginalState {
@@ -15,6 +17,10 @@ interface OriginalState {
   rotation: [number, number, number]
   side: ItemNode['side']
   parentId: string | null
+  // Roof-segment wall hosting — cleared/changed by surface transitions
+  // mid-move, so reverts must restore it alongside parentId.
+  roofSegmentId: ItemNode['roofSegmentId']
+  roofFace: ItemNode['roofFace']
   metadata: ItemNode['metadata']
 }
 
@@ -23,17 +29,25 @@ export interface DraftNodeHandle {
   readonly current: ItemNode | null
   /** Whether the current draft was adopted (move mode) vs created (create mode) */
   readonly isAdopted: boolean
-  /** Create a new draft item at the given position. Returns the created node or null. */
+  /** Create a new draft item at the given position. Returns the created node or null.
+   *  `slots` seeds painted slot overrides so duplicates keep their materials. */
   create: (
     gridPosition: Vector3,
     asset: AssetInput,
     rotation?: [number, number, number],
     scale?: [number, number, number],
+    slots?: ItemNode['slots'],
   ) => ItemNode | null
   /** Take ownership of an existing scene node as the draft (for move mode). */
   adopt: (node: ItemNode) => void
-  /** Commit the current draft. Create mode: delete+recreate. Move mode: update in place. */
-  commit: (finalUpdate: Partial<ItemNode>) => string | null
+  /** Commit the current draft. Create mode: delete+recreate. Move mode: update in place.
+   *  `supportElevationCap` (floor commits) is the pointer-decided surface
+   *  elevation — it caps the persisted `supportSlabId` election so the
+   *  commit lands on the surface the cursor pointed at. */
+  commit: (
+    finalUpdate: Partial<ItemNode>,
+    options?: { supportElevationCap?: number | null },
+  ) => string | null
   /** Destroy the current draft. Create mode: delete node. Move mode: restore original state. */
   destroy: () => void
 }
@@ -57,6 +71,7 @@ export function useDraftNode(): DraftNodeHandle {
       asset: AssetInput,
       rotation?: [number, number, number],
       scale?: [number, number, number],
+      slots?: ItemNode['slots'],
     ): ItemNode | null => {
       const currentLevelId = useViewer.getState().selection.levelId
       if (!currentLevelId) return null
@@ -69,9 +84,13 @@ export function useDraftNode(): DraftNodeHandle {
         asset,
         parentId: currentLevelId,
         metadata: { isTransient: true },
+        ...(slots ? { slots } : {}),
       })
 
       useScene.getState().createNode(node, currentLevelId)
+      usePlacementPreview
+        .getState()
+        .set(node, useScene.getState().nodes[currentLevelId as AnyNodeId] ?? null)
       draftRef.current = node
       adoptedRef.current = false
       originalStateRef.current = null
@@ -92,6 +111,8 @@ export function useDraftNode(): DraftNodeHandle {
       rotation: [...node.rotation] as [number, number, number],
       side: node.side,
       parentId: node.parentId,
+      roofSegmentId: node.roofSegmentId,
+      roofFace: node.roofFace,
       metadata: node.metadata,
     }
 
@@ -102,82 +123,142 @@ export function useDraftNode(): DraftNodeHandle {
     useScene.getState().updateNode(node.id, {
       metadata: { ...meta, isTransient: true },
     })
+    usePlacementPreview
+      .getState()
+      .set(
+        node,
+        node.parentId ? (useScene.getState().nodes[node.parentId as AnyNodeId] ?? null) : null,
+      )
   }, [])
 
-  const commit = useCallback((finalUpdate: Partial<ItemNode>): string | null => {
-    const draft = draftRef.current
-    if (!draft) return null
+  const commit = useCallback(
+    (
+      finalUpdate: Partial<ItemNode>,
+      options?: { supportElevationCap?: number | null },
+    ): string | null => {
+      const draft = draftRef.current
+      if (!draft) return null
+
+      if (adoptedRef.current) {
+        // Move mode: update in place (single undoable action)
+        const { parentId: newParentId, ...updateProps } = finalUpdate
+        const parentId =
+          newParentId ??
+          originalStateRef.current?.parentId ??
+          useViewer.getState().selection.levelId
+        const original = originalStateRef.current!
+
+        // Restore original state while paused — so the undo baseline is clean
+        useScene.getState().updateNode(draft.id, {
+          position: original.position,
+          rotation: original.rotation,
+          side: original.side,
+          parentId: original.parentId,
+          roofSegmentId: original.roofSegmentId,
+          roofFace: original.roofFace,
+          metadata: original.metadata,
+        })
+
+        // Resume → tracked update (undo reverts to original)
+        useScene.temporal.getState().resume()
+
+        const effectiveNode = ItemNode.parse({
+          ...draft,
+          ...updateProps,
+          parentId,
+          metadata: updateProps.metadata ?? stripTransient(draft.metadata),
+        })
 
-    if (adoptedRef.current) {
-      // Move mode: update in place (single undoable action)
+        useScene.getState().updateNode(draft.id, {
+          position: updateProps.position ?? draft.position,
+          rotation: updateProps.rotation ?? draft.rotation,
+          side: updateProps.side ?? draft.side,
+          metadata: updateProps.metadata ?? stripTransient(draft.metadata),
+          parentId: parentId as string,
+          // Forward the roof host explicitly: strategies set it on every
+          // commit (segment id on a roof face, undefined elsewhere), and
+          // dropping it here strands the item in the roof frame without
+          // the segment transform.
+          roofSegmentId: updateProps.roofSegmentId,
+          roofFace: updateProps.roofFace,
+          // Only when the strategy decided about wallId (roof commits clear
+          // it) — floor/ceiling commits never managed the field.
+          ...('wallId' in updateProps ? { wallId: updateProps.wallId } : {}),
+          ...resolveSupportSlabPatch(effectiveNode, useScene.getState().nodes, {
+            maxElevation: options?.supportElevationCap,
+          }),
+        })
+
+        useScene.temporal.getState().pause()
+
+        const id = draft.id
+        if (usePlacementPreview.getState().node?.id === id) {
+          usePlacementPreview.getState().clear()
+        }
+        draftRef.current = null
+        adoptedRef.current = false
+        originalStateRef.current = null
+        return id
+      }
+
+      // Create mode: delete draft (paused), resume, create fresh node (tracked), re-pause
       const { parentId: newParentId, ...updateProps } = finalUpdate
-      const parentId =
-        newParentId ?? originalStateRef.current?.parentId ?? useViewer.getState().selection.levelId
-      const original = originalStateRef.current!
+      const parentId = (newParentId ?? useViewer.getState().selection.levelId) as AnyNodeId
+      if (!parentId) return null
 
-      // Restore original state while paused — so the undo baseline is clean
-      useScene.getState().updateNode(draft.id, {
-        position: original.position,
-        rotation: original.rotation,
-        side: original.side,
-        parentId: original.parentId,
-        metadata: original.metadata,
-      })
+      // Delete draft while paused (invisible to undo)
+      useScene.getState().deleteNode(draft.id)
+      draftRef.current = null
 
-      // Resume → tracked update (undo reverts to original)
+      // Briefly resume → create fresh node (the single undoable action)
       useScene.temporal.getState().resume()
 
-      useScene.getState().updateNode(draft.id, {
+      const finalNode = ItemNode.parse({
+        name: draft.name,
+        asset: draft.asset,
         position: updateProps.position ?? draft.position,
         rotation: updateProps.rotation ?? draft.rotation,
+        scale: updateProps.scale ?? draft.scale,
         side: updateProps.side ?? draft.side,
+        // Carry painted slot overrides so a duplicated item keeps its materials.
+        ...(draft.slots ? { slots: draft.slots } : {}),
+        // Roof host — see the move-mode commit above for why this must be
+        // forwarded explicitly.
+        roofSegmentId: updateProps.roofSegmentId,
+        roofFace: updateProps.roofFace,
+        ...('wallId' in updateProps ? { wallId: updateProps.wallId } : {}),
         metadata: updateProps.metadata ?? stripTransient(draft.metadata),
-        parentId: parentId as string,
+        parentId,
       })
+      const nodes = useScene.getState().nodes
+      const committedNode = ItemNode.parse({
+        ...finalNode,
+        ...resolveSupportSlabPatch(
+          finalNode,
+          { ...nodes, [finalNode.id]: finalNode },
+          { maxElevation: options?.supportElevationCap },
+        ),
+      })
+      useScene.getState().createNode(committedNode, parentId)
+      if (usePlacementPreview.getState().node?.id === draft.id) {
+        usePlacementPreview.getState().clear()
+      }
 
+      // Re-pause for next draft cycle
       useScene.temporal.getState().pause()
 
-      const id = draft.id
-      draftRef.current = null
       adoptedRef.current = false
       originalStateRef.current = null
-      return id
-    }
-
-    // Create mode: delete draft (paused), resume, create fresh node (tracked), re-pause
-    const { parentId: newParentId, ...updateProps } = finalUpdate
-    const parentId = (newParentId ?? useViewer.getState().selection.levelId) as AnyNodeId
-    if (!parentId) return null
-
-    // Delete draft while paused (invisible to undo)
-    useScene.getState().deleteNode(draft.id)
-    draftRef.current = null
-
-    // Briefly resume → create fresh node (the single undoable action)
-    useScene.temporal.getState().resume()
-
-    const finalNode = ItemNode.parse({
-      name: draft.name,
-      asset: draft.asset,
-      position: updateProps.position ?? draft.position,
-      rotation: updateProps.rotation ?? draft.rotation,
-      scale: updateProps.scale ?? draft.scale,
-      side: updateProps.side ?? draft.side,
-      metadata: updateProps.metadata ?? stripTransient(draft.metadata),
-    })
-    useScene.getState().createNode(finalNode, parentId)
-
-    // Re-pause for next draft cycle
-    useScene.temporal.getState().pause()
-
-    adoptedRef.current = false
-    originalStateRef.current = null
-    return finalNode.id
-  }, [])
+      return committedNode.id
+    },
+    [],
+  )
 
   const destroy = useCallback(() => {
     if (!draftRef.current) return
 
+    const draftId = draftRef.current.id
+
     if (adoptedRef.current && originalStateRef.current) {
       // Move mode: restore original state instead of deleting — but only
       // if no other system has already committed a new position for this
@@ -199,6 +280,9 @@ export function useDraftNode(): DraftNodeHandle {
         draftRef.current = null
         adoptedRef.current = false
         originalStateRef.current = null
+        if (usePlacementPreview.getState().node?.id === draftId) {
+          usePlacementPreview.getState().clear()
+        }
         return
       }
 
@@ -207,6 +291,8 @@ export function useDraftNode(): DraftNodeHandle {
         rotation: original.rotation,
         side: original.side,
         parentId: original.parentId,
+        roofSegmentId: original.roofSegmentId,
+        roofFace: original.roofFace,
         metadata: original.metadata,
       })
 
@@ -227,6 +313,9 @@ export function useDraftNode(): DraftNodeHandle {
     draftRef.current = null
     adoptedRef.current = false
     originalStateRef.current = null
+    if (usePlacementPreview.getState().node?.id === draftId) {
+      usePlacementPreview.getState().clear()
+    }
   }, [])
 
   return useMemo(