@pascal-app/nodes 1.0.0-beta.4 → 1.0.0

package/dist/window/move-tool.js

@@ -1,11 +1,13 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import { emitter, isCurvedWall, sceneRegistry, spatialGridManager, useLiveTransforms, useScene, WindowNode, } from '@pascal-app/core';
-import { calculateItemRotation, clearPlacementSurface, consumePlacementDragRelease, EDITOR_LAYER, getSideFromNormal, isGridSnapActive, isMagneticSnapActive, isValidWallSideFace, publishPlacementSurface, snapToHalf, stripPlacementMetadataFlags, triggerSFX, useAlignmentGuides, useEditor, useFacingPose, } from '@pascal-app/editor';
-import { useViewer } from '@pascal-app/viewer';
+import { dormerWallFacePointToDormer, emitter, holdHiddenWallPointerEvents, isCurvedWall, sceneRegistry, spatialGridManager, useLiveNodeOverrides, useLiveTransforms, useScene, WindowNode, } from '@pascal-app/core';
+import { calculateItemRotation, clearPlacementSurface, consumePlacementDragRelease, EDITOR_LAYER, getSideFromNormal, isGridSnapActive, isMagneticSnapActive, isValidWallSideFace, publishPlacementSurface, snapToHalf, stripPlacementMetadataFlags, triggerSFX, useAlignmentGuides, useEditor, useFacingPose, useRegistryToolContext, } from '@pascal-app/editor';
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { BoxGeometry, EdgesGeometry, Vector3 } from 'three';
 import { LineBasicNodeMaterial } from 'three/webgpu';
+import { dormerEventFromHostedWindow, getDormerWindowWorldNormal, getDormerWindowWorldYaw, resolveDormerWindowTarget, } from '../shared/dormer-wall-opening-placement';
 import { clearOpeningGuides3D, publishOpeningGuidesForWallEvent, resolveSillSnap, } from '../shared/opening-guides-runtime';
+import { beginOpeningMoveHistorySession } from '../shared/opening-move-history';
+import { isWallMeshHidden, shouldIgnoreWallEventForOpeningMove, } from '../shared/opening-move-wall-gate';
 import { getRoofWallOpeningCursorPose, resolveRoofWallOpeningTarget, } from '../shared/roof-wall-opening-placement';
 import { resolveOpeningPlacement } from '../shared/wall-attach-target';
 import { collectWallOpeningAlignmentCandidates, resolveWallSlideAlignment, } from '../shared/wall-opening-alignment';
@@ -22,15 +24,18 @@ const edgeMaterial = new LineBasicNodeMaterial({
  * Move/duplicate tool for WindowNodes — wall-only, same guardrails as WindowTool.
  *
  * Move mode (metadata.isNew falsy):
- *   Adopts the existing window, pauses temporal. On commit: restores original state
- *   (clean undo baseline) then resumes + updateNode (undo reverts to original position).
- *   On cancel: restores original state.
+ *   Adopts the existing window and holds a refcounted history pause for the
+ *   gesture. On commit: restores original state (clean undo baseline) then runs
+ *   updateNode as the gesture's single tracked write (undo reverts to the
+ *   original position). On cancel: restores original state, never tracked.
  *
  * Duplicate mode (metadata.isNew = true):
- *   The node is a freshly created transient copy. On commit: deletes transient + resumes
- *   + createNode (undo removes the new window entirely). On cancel: deletes the node.
+ *   The node is a freshly created transient copy. On commit: deletes the
+ *   transient paused + createNode as the single tracked write (undo removes the
+ *   new window entirely). On cancel: deletes the node.
  */
 const MoveWindowTool = ({ node: movingWindowNode }) => {
+    const { activeLevelId, isCameraDragging, selectNode } = useRegistryToolContext();
     const cursorGroupRef = useRef(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,
@@ -54,7 +59,19 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
         useEditor.getState().setMovingNode(null);
     }, []);
     useEffect(() => {
-        useScene.temporal.getState().pause();
+        // One undo entry per gesture: hold the REFCOUNTED history pause for the
+        // move's lifetime (a raw `temporal.pause()` is invisible to
+        // `getSceneHistoryPauseDepth()`, so a cooperating system's balanced
+        // pause/resume pair could zero the refcount mid-drag and resume tracking
+        // — every mid-drag write then became its own undo entry). The commit
+        // paths run their single tracked write through `history.commitStep`.
+        const history = beginOpeningMoveHistorySession();
+        // This tool's whole cursor model is the wall surface (`wall:enter` /
+        // `wall:move` / `wall:click`). Walls hidden by the wall-mode pass (X-ray
+        // 'down' mode) are pointer-transparent for selection; hold their pointer
+        // events for the move's lifetime so the window keeps sliding along its
+        // wall instead of detaching into the floor free-follow.
+        const releaseHiddenWallHold = holdHiddenWallPointerEvents();
         const meta = typeof movingWindowNode.metadata === 'object' && movingWindowNode.metadata !== null
             ? movingWindowNode.metadata
             : {};
@@ -66,6 +83,8 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             side: movingWindowNode.side,
             parentId: movingWindowNode.parentId,
             wallId: movingWindowNode.wallId,
+            dormerId: movingWindowNode.dormerId,
+            dormerFace: movingWindowNode.dormerFace,
             // Windows can be hosted on a roof-segment wall face. Moving onto a
             // wall re-anchors as wall-hosted (roofSegmentId cleared); reverts
             // must restore the roof host.
@@ -144,6 +163,8 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
         let grabWallId = movingWindowNode.parentId;
         let lastTarget = null;
         let lastRoofEvent = null;
+        let lastDormerEvent = null;
+        let lastDormerTarget = null;
         const markHostDirty = (hostId) => {
             if (hostId)
                 useScene.getState().dirtyNodes.add(hostId);
@@ -160,7 +181,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                 markHostDirty(hostId);
             }
         };
-        const getLevelId = () => useViewer.getState().selection.levelId;
+        const getLevelId = () => activeLevelId;
         const getLevelYOffset = () => {
             const id = getLevelId();
             return id ? (sceneRegistry.nodes.get(id)?.position.y ?? 0) : 0;
@@ -197,6 +218,20 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             group.rotation.y = cursorRotationY;
             edgeMaterial.color.setHex(valid ? 0x22_c5_5e : 0xef_44_44);
         };
+        // While MOVING an existing window, a HIDDEN wall may drive the drag only
+        // if it is the window's own wall (grab wall / current mid-drag host) — an
+        // interposed hidden wall between the camera and the window's wall must
+        // not capture the drag and silently re-parent the window on commit
+        // (night-6 QA: an X-ray drag rode an invisible wall at z=-2.5 instead of
+        // the window's own wall at z=0). Ignored events are NOT
+        // stopPropagation'd, so the ray falls through to the own wall behind.
+        // Fresh placements (`isNew`) keep the all-walls behavior.
+        const wallEventIgnored = (event) => !isNew &&
+            shouldIgnoreWallEventForOpeningMove({
+                eventWallId: event.node.id,
+                eventWallHidden: isWallMeshHidden(event.node.id),
+                ownWallIds: [original.wallId, currentHostId],
+            });
         const resolveMoveTarget = (event) => {
             if (!isValidWallSideFace(event.normal))
                 return;
@@ -257,7 +292,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                 applySnap: isMagneticSnapActive(),
             });
             const { clampedX, clampedY } = clampToWall(event.node, localX, targetLocalY, movingWindowNode.width, movingWindowNode.height, useScene.getState().nodes);
-            const valid = !hasWallChildOverlap(event.node.id, clampedX, clampedY, movingWindowNode.width, movingWindowNode.height, movingWindowNode.id);
+            const valid = !hasWallChildOverlap(event.node.id, useScene.getState().nodes, clampedX, clampedY, movingWindowNode.width, movingWindowNode.height, movingWindowNode.id);
             return {
                 wallNode: event.node,
                 wallId: event.node.id,
@@ -278,8 +313,13 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             tickGridStep(target.event.nativeEvent?.timeStamp ?? -1, target.clampedX);
             // 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.
+            // ghost so validity reads at a glance (see MoveDoorTool). Reparenting
+            // MUST be a scene write: the wall's CSG merge and the renderer's nesting
+            // walk the wall's `children` array, which a live override never joins —
+            // an override-only reparent left the window uncut and rendered against
+            // its stale parent (no on-wall preview at all). A stale override from a
+            // free-follow / dormer hop would shadow those scene fields, so drop it.
+            useLiveNodeOverrides.getState().clear(movingWindowNode.id);
             if (currentHostId !== target.wallId) {
                 useScene.getState().updateNode(movingWindowNode.id, {
                     position: [target.clampedX, target.clampedY, 0],
@@ -289,6 +329,8 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                     wallId: target.wallId,
                     roofSegmentId: undefined,
                     roofFace: undefined,
+                    dormerId: undefined,
+                    dormerFace: undefined,
                     visible: false,
                 });
                 markHostDirty(currentHostId);
@@ -351,6 +393,11 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             });
         };
         const onWallEnter = (event) => {
+            // Interposed hidden wall: ignore WITHOUT tearing down the current
+            // preview or stopping propagation — the own wall behind it (a later,
+            // farther intersection on this same ray) emits its own event.
+            if (wallEventIgnored(event))
+                return;
             const target = resolveMoveTarget(event);
             if (!target) {
                 onWallLeave();
@@ -366,6 +413,9 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             event.stopPropagation();
         };
         const onWallMove = (event) => {
+            // See onWallEnter — interposed hidden walls never own the move.
+            if (wallEventIgnored(event))
+                return;
             if (!isValidWallSideFace(event.normal)) {
                 onWallLeave();
                 return;
@@ -401,10 +451,10 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             committed = true;
             let placedId;
             if (isNew) {
-                // Duplicate mode: delete transient + resume + createNode
-                // Undo will remove the newly created node entirely
+                // Duplicate mode: delete the transient draft while history is still
+                // paused, then create the real node as the gesture's ONE tracked
+                // write — undo removes the new window entirely.
                 useScene.getState().deleteNode(movingWindowNode.id);
-                useScene.temporal.getState().resume();
                 const cloned = structuredClone(movingWindowNode);
                 delete cloned.id;
                 cloned.metadata = stripPlacementMetadataFlags(cloned.metadata);
@@ -420,33 +470,39 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                     // Hidden during free-follow; the committed window must be visible.
                     visible: true,
                 });
-                useScene.getState().createNode(node, target.wallId);
+                history.commitStep(() => {
+                    useScene.getState().createNode(node, target.wallId);
+                });
                 placedId = node.id;
             }
             else {
-                // Move mode: restore original (clean baseline) + resume + updateNode
-                // Undo will revert to the original position
+                // Move mode: restore the exact pre-drag state while history is still
+                // paused (the clean undo baseline), then apply the drop as the
+                // gesture's ONE tracked write — undo reverts to the original state.
                 useScene.getState().updateNode(movingWindowNode.id, {
                     position: original.position,
                     rotation: original.rotation,
                     side: original.side,
                     parentId: original.parentId,
                     wallId: original.wallId,
+                    dormerId: original.dormerId,
+                    dormerFace: original.dormerFace,
                     roofSegmentId: original.roofSegmentId,
                     roofFace: original.roofFace,
                     metadata: original.metadata,
                     visible: original.visible,
                 });
-                useScene.temporal.getState().resume();
-                useScene.getState().updateNode(movingWindowNode.id, {
-                    position: [target.clampedX, target.clampedY, 0],
-                    rotation: [0, target.itemRotation, 0],
-                    side: target.side,
-                    parentId: target.wallId,
-                    wallId: target.wallId,
-                    roofSegmentId: undefined,
-                    metadata: {},
-                    visible: true,
+                history.commitStep(() => {
+                    useScene.getState().updateNode(movingWindowNode.id, {
+                        position: [target.clampedX, target.clampedY, 0],
+                        rotation: [0, target.itemRotation, 0],
+                        side: target.side,
+                        parentId: target.wallId,
+                        wallId: target.wallId,
+                        roofSegmentId: undefined,
+                        metadata: {},
+                        visible: true,
+                    });
                 });
                 if (original.parentId && original.parentId !== target.wallId) {
                     markHostDirty(original.parentId);
@@ -455,15 +511,18 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             }
             markHostDirty(target.wallId);
             useLiveTransforms.getState().clear(movingWindowNode.id);
-            useScene.temporal.getState().pause();
             triggerSFX('sfx:structure-build');
             hideCursor();
-            useViewer.getState().setSelection({ selectedIds: [placedId] });
+            selectNode(placedId);
             exitMoveMode();
         };
         const onWallClick = (event) => {
             if (committed)
                 return;
+            // A click on an interposed hidden wall must not commit / re-parent;
+            // let it fall through to the own wall behind (see onWallEnter).
+            if (wallEventIgnored(event))
+                return;
             if (!isValidWallSideFace(event.normal))
                 return;
             if (isCurvedWall(event.node))
@@ -500,10 +559,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             setGhostPose(null);
             useFacingPose.getState().clear();
             clearPlacementSurface();
-            const live = useScene.getState().nodes[movingWindowNode.id];
-            if (live && live.visible === false) {
-                useScene.getState().updateNode(movingWindowNode.id, { visible: true });
-            }
+            useLiveNodeOverrides.getState().set(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
@@ -512,6 +568,8 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             freeFollowing = true;
             lastTarget = null;
             lastRoofEvent = null;
+            lastDormerEvent = null;
+            lastDormerTarget = null;
             // No snap SFX here: the free-follow fires off-wall (an invalid red ghost,
             // not a placeable position) AND interleaves with the on-wall slide on the
             // same pointer move (R3F `wall:move` and DOM `grid:move` carry different
@@ -519,11 +577,15 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             // source of the constant click while sliding a window along a wall — the
             // on-wall `applyPreview` already ticks once per along-wall cell.
             hideCursor();
+            useLiveNodeOverrides.getState().clear(movingWindowNode.id);
             useLiveTransforms.getState().clear(movingWindowNode.id);
             const levelId = getLevelId();
             const sillCenterY = getSillCenterY();
             // Keep the R-flip visible while free-following (back = rotated π).
             const yaw = sideOverride === 'back' ? Math.PI : 0;
+            // Scene writes, not overrides: leaving the wall must actually remove the
+            // window from the wall's `children` or the CSG cut trails the ghost
+            // around the old wall (see the wall-branch note in `applyPreview`).
             if (currentHostId !== levelId) {
                 if (currentHostId && currentHostId !== levelId)
                     markHostDirty(currentHostId);
@@ -535,6 +597,8 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                     wallId: undefined,
                     roofSegmentId: undefined,
                     roofFace: undefined,
+                    dormerId: undefined,
+                    dormerFace: undefined,
                     visible: false,
                 });
                 currentHostId = levelId;
@@ -563,7 +627,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
         const onGridMove = (event) => {
             if (committed)
                 return;
-            if (useViewer.getState().cameraDragging)
+            if (isCameraDragging())
                 return;
             // A wall/roof handler owns the pointer right now — the cursor ray is on a
             // wall/roof that snaps, so skip the floor follow (see `wallOwnsPointer`).
@@ -573,6 +637,186 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             lastFloorPoint = [x, z];
             freeFollowAt(x, z);
         };
+        // ── Dormer wall faces ──────────────────────────────────────────
+        const resolveDormerMoveTarget = (event) => resolveDormerWindowTarget({
+            event,
+            width: movingWindowNode.width,
+            height: movingWindowNode.height,
+            ignoreId: movingWindowNode.id,
+            nodes: useScene.getState().nodes,
+            snap: snapToHalf,
+        });
+        const dormerWindowWorldPosition = (event, target) => {
+            const point = new Vector3(...dormerWallFacePointToDormer(event.node, target.face, target.position));
+            event.object.localToWorld(point);
+            return [point.x, point.y, point.z];
+        };
+        const applyDormerPreview = (event, target) => {
+            markWallOwnedPointer();
+            freeFollowing = false;
+            lastTarget = null;
+            lastRoofEvent = null;
+            lastDormerEvent = event;
+            lastDormerTarget = target;
+            dragAnchor = null;
+            grabWallId = null;
+            const side = sideOverride ?? 'front';
+            const rotation = [0, side === 'back' ? Math.PI : 0, 0];
+            if (currentHostId !== target.dormer.id) {
+                markHostDirty(currentHostId);
+                currentHostId = target.dormer.id;
+            }
+            useLiveNodeOverrides.getState().set(movingWindowNode.id, {
+                position: target.position,
+                rotation,
+                side,
+                parentId: target.dormer.id,
+                dormerId: target.dormer.id,
+                dormerFace: target.face,
+                wallId: undefined,
+                roofSegmentId: undefined,
+                roofFace: undefined,
+                visible: false,
+            });
+            const worldPosition = dormerWindowWorldPosition(event, target);
+            publishPlacementSurface(new Vector3(...worldPosition), getDormerWindowWorldNormal(event, target));
+            setGhostPose({
+                position: worldPosition,
+                rotationY: getDormerWindowWorldYaw(event, target),
+                tint: target.valid || altHeld ? 'valid' : 'invalid',
+                floorY: worldPosition[1],
+                side,
+            });
+            useFacingPose.getState().clear();
+            clearOpeningGuides3D();
+        };
+        const commitToDormer = (event, target) => {
+            if (committed)
+                return;
+            committed = true;
+            useLiveNodeOverrides.getState().clear(movingWindowNode.id);
+            const side = sideOverride ?? 'front';
+            const rotation = [0, side === 'back' ? Math.PI : 0, 0];
+            let placedId;
+            if (isNew) {
+                useScene.getState().deleteNode(movingWindowNode.id);
+                const cloned = structuredClone(movingWindowNode);
+                delete cloned.id;
+                cloned.metadata = stripPlacementMetadataFlags(cloned.metadata);
+                const committedNode = WindowNode.parse({
+                    ...cloned,
+                    position: target.position,
+                    rotation,
+                    side,
+                    parentId: target.dormer.id,
+                    dormerId: target.dormer.id,
+                    dormerFace: target.face,
+                    wallId: undefined,
+                    roofSegmentId: undefined,
+                    roofFace: undefined,
+                    visible: true,
+                });
+                history.commitStep(() => {
+                    useScene.getState().createNode(committedNode, target.dormer.id);
+                });
+                placedId = committedNode.id;
+            }
+            else {
+                useScene.getState().updateNode(movingWindowNode.id, {
+                    position: original.position,
+                    rotation: original.rotation,
+                    side: original.side,
+                    parentId: original.parentId,
+                    wallId: original.wallId,
+                    dormerId: original.dormerId,
+                    dormerFace: original.dormerFace,
+                    roofSegmentId: original.roofSegmentId,
+                    roofFace: original.roofFace,
+                    metadata: original.metadata,
+                    visible: original.visible,
+                });
+                history.commitStep(() => {
+                    useScene.getState().updateNode(movingWindowNode.id, {
+                        position: target.position,
+                        rotation,
+                        side,
+                        parentId: target.dormer.id,
+                        dormerId: target.dormer.id,
+                        dormerFace: target.face,
+                        wallId: undefined,
+                        roofSegmentId: undefined,
+                        roofFace: undefined,
+                        metadata: {},
+                        visible: true,
+                    });
+                });
+                if (original.parentId && original.parentId !== target.dormer.id) {
+                    markHostDirty(original.parentId);
+                }
+                placedId = movingWindowNode.id;
+            }
+            markHostDirty(target.dormer.id);
+            useLiveTransforms.getState().clear(movingWindowNode.id);
+            triggerSFX('sfx:structure-build');
+            hideCursor();
+            selectNode(placedId);
+            exitMoveMode();
+            event.stopPropagation();
+        };
+        const onDormerHover = (event) => {
+            if (committed)
+                return;
+            const target = resolveDormerMoveTarget(event);
+            if (!target) {
+                onDormerLeave();
+                return;
+            }
+            applyDormerPreview(event, target);
+            event.stopPropagation();
+        };
+        const onDormerClick = (event) => {
+            if (committed)
+                return;
+            const target = lastDormerTarget && lastDormerEvent?.node.id === event.node.id
+                ? lastDormerTarget
+                : resolveDormerMoveTarget(event);
+            if (!target)
+                return;
+            if (!target.valid && event.nativeEvent?.altKey !== true)
+                return;
+            commitToDormer(event, target);
+        };
+        const onDormerLeave = () => {
+            hideCursor();
+            useLiveNodeOverrides.getState().clear(movingWindowNode.id);
+            useLiveTransforms.getState().clear(movingWindowNode.id);
+            lastDormerEvent = null;
+            lastDormerTarget = null;
+        };
+        const dormerEventFromWindow = (event) => {
+            const dormerId = event.node.dormerId ?? event.node.parentId;
+            const dormer = dormerId ? useScene.getState().nodes[dormerId] : undefined;
+            const object = dormer ? sceneRegistry.nodes.get(dormer.id) : undefined;
+            if (!(dormer?.type === 'dormer' && object))
+                return null;
+            return dormerEventFromHostedWindow(event, dormer, object);
+        };
+        const onDormerWindowHover = (event) => {
+            const dormerEvent = dormerEventFromWindow(event);
+            if (dormerEvent)
+                onDormerHover(dormerEvent);
+        };
+        const onDormerWindowClick = (event) => {
+            const dormerEvent = dormerEventFromWindow(event);
+            if (dormerEvent)
+                onDormerClick(dormerEvent);
+        };
+        const onDormerWindowLeave = (event) => {
+            if (event.node.dormerId ||
+                useScene.getState().nodes[event.node.parentId]?.type === 'dormer') {
+                onDormerLeave();
+            }
+        };
         // ── Roof-segment wall faces ─────────────────────────────────────
         // Mirrors the wall flow for the segments' vertical wall faces (base
         // walls under the roof + coplanar gable ends — a window can sit in
@@ -611,13 +855,16 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             grabWallId = null;
             lastTarget = null;
             lastRoofEvent = event;
+            useLiveNodeOverrides.getState().clear(movingWindowNode.id);
             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, {
+                markHostDirty(currentHostId);
+                currentHostId = target.segment.id;
+                useLiveNodeOverrides.getState().set(movingWindowNode.id, {
                     position: target.position,
                     rotation: [0, 0, 0],
                     side: 'front',
@@ -627,11 +874,9 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                     roofFace: target.face.id,
                     visible: true,
                 });
-                markHostDirty(currentHostId);
-                currentHostId = target.segment.id;
             }
             else {
-                useScene.getState().updateNode(movingWindowNode.id, {
+                useLiveNodeOverrides.getState().set(movingWindowNode.id, {
                     position: target.position,
                     rotation: [0, 0, 0],
                     roofFace: target.face.id,
@@ -653,8 +898,9 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             const segmentId = target.segment.id;
             let placedId;
             if (isNew) {
+                // See commitToWall — delete the draft paused, create as the ONE
+                // tracked write.
                 useScene.getState().deleteNode(movingWindowNode.id);
-                useScene.temporal.getState().resume();
                 const cloned = structuredClone(movingWindowNode);
                 delete cloned.id;
                 cloned.metadata = stripPlacementMetadataFlags(cloned.metadata);
@@ -669,32 +915,39 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                     parentId: segmentId,
                     visible: true,
                 });
-                useScene.getState().createNode(node, segmentId);
+                history.commitStep(() => {
+                    useScene.getState().createNode(node, segmentId);
+                });
                 placedId = node.id;
             }
             else {
+                // See commitToWall — restore the pre-drag baseline paused, drop as
+                // the ONE tracked write.
                 useScene.getState().updateNode(movingWindowNode.id, {
                     position: original.position,
                     rotation: original.rotation,
                     side: original.side,
                     parentId: original.parentId,
                     wallId: original.wallId,
+                    dormerId: original.dormerId,
+                    dormerFace: original.dormerFace,
                     roofSegmentId: original.roofSegmentId,
                     roofFace: original.roofFace,
                     metadata: original.metadata,
                     visible: original.visible,
                 });
-                useScene.temporal.getState().resume();
-                useScene.getState().updateNode(movingWindowNode.id, {
-                    position: target.position,
-                    rotation: [0, 0, 0],
-                    side: 'front',
-                    parentId: segmentId,
-                    wallId: undefined,
-                    roofSegmentId: segmentId,
-                    roofFace: target.face.id,
-                    metadata: {},
-                    visible: true,
+                history.commitStep(() => {
+                    useScene.getState().updateNode(movingWindowNode.id, {
+                        position: target.position,
+                        rotation: [0, 0, 0],
+                        side: 'front',
+                        parentId: segmentId,
+                        wallId: undefined,
+                        roofSegmentId: segmentId,
+                        roofFace: target.face.id,
+                        metadata: {},
+                        visible: true,
+                    });
                 });
                 if (original.parentId && original.parentId !== segmentId) {
                     markHostDirty(original.parentId);
@@ -703,10 +956,9 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             }
             markHostDirty(segmentId);
             useLiveTransforms.getState().clear(movingWindowNode.id);
-            useScene.temporal.getState().pause();
             triggerSFX('sfx:structure-build');
             hideCursor();
-            useViewer.getState().setSelection({ selectedIds: [placedId] });
+            selectNode(placedId);
             exitMoveMode();
             event.stopPropagation();
         };
@@ -714,12 +966,14 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             // Mirror onWallLeave: don't revert to origin here — onGridMove takes
             // over on the same pointermove (snap to a nearby wall or free-follow).
             hideCursor();
+            useLiveNodeOverrides.getState().clear(movingWindowNode.id);
             useLiveTransforms.getState().clear(movingWindowNode.id);
             dragAnchor = null;
             lastTarget = null;
             lastRoofEvent = null;
         };
         const onCancel = () => {
+            useLiveNodeOverrides.getState().clear(movingWindowNode.id);
             useLiveTransforms.getState().clear(movingWindowNode.id);
             if (isNew) {
                 useScene.getState().deleteNode(movingWindowNode.id);
@@ -733,6 +987,8 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                     side: original.side,
                     parentId: original.parentId,
                     wallId: original.wallId,
+                    dormerId: original.dormerId,
+                    dormerFace: original.dormerFace,
                     roofSegmentId: original.roofSegmentId,
                     roofFace: original.roofFace,
                     metadata: original.metadata,
@@ -741,7 +997,10 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                 if (original.parentId)
                     markHostDirty(original.parentId);
             }
-            useScene.temporal.getState().resume();
+            // The revert writes above ran under the gesture's history pause (never
+            // tracked); ending the session here keeps a cancelled move out of undo
+            // entirely. `end` is idempotent — the effect cleanup's end() is a no-op.
+            history.end();
             hideCursor();
             exitMoveMode();
         };
@@ -758,6 +1017,8 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             }
             if (lastRoofEvent)
                 onRoofClick(lastRoofEvent);
+            if (lastDormerEvent && lastDormerTarget)
+                commitToDormer(lastDormerEvent, lastDormerTarget);
         };
         // R flips the window's facing side mid-placement (front ↔ back), like the
         // committed-selected R flip — usable before commit, whether snapped to a
@@ -788,6 +1049,11 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                     applyPreview(next);
                 }
             }
+            else if (lastDormerEvent) {
+                const next = resolveDormerMoveTarget(lastDormerEvent);
+                if (next)
+                    applyDormerPreview(lastDormerEvent, next);
+            }
             else if (lastFloorPoint) {
                 // Free-following: re-run at the same spot so the floating ghost rebuilds
                 // with the flipped side.
@@ -822,6 +1088,14 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
         emitter.on('roof:move', onRoofHover);
         emitter.on('roof:click', onRoofClick);
         emitter.on('roof:leave', onRoofLeave);
+        emitter.on('dormer:enter', onDormerHover);
+        emitter.on('dormer:move', onDormerHover);
+        emitter.on('dormer:click', onDormerClick);
+        emitter.on('dormer:leave', onDormerLeave);
+        emitter.on('window:enter', onDormerWindowHover);
+        emitter.on('window:move', onDormerWindowHover);
+        emitter.on('window:click', onDormerWindowClick);
+        emitter.on('window:leave', onDormerWindowLeave);
         emitter.on('grid:move', onGridMove);
         emitter.on('tool:cancel', onCancel);
         window.addEventListener('pointerup', onPlacementDragPointerUp);
@@ -865,6 +1139,8 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                         side: original.side,
                         parentId: original.parentId,
                         wallId: original.wallId,
+                        dormerId: original.dormerId,
+                        dormerFace: original.dormerFace,
                         roofSegmentId: original.roofSegmentId,
                         roofFace: original.roofFace,
                         metadata: original.metadata,
@@ -880,12 +1156,14 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                 // becomes an invisible orphan (place-preset deletes a true cancel).
                 useScene.getState().updateNode(movingWindowNode.id, { visible: true });
             }
+            useLiveNodeOverrides.getState().clear(movingWindowNode.id);
             useLiveTransforms.getState().clear(movingWindowNode.id);
             useAlignmentGuides.getState().clear();
             clearOpeningGuides3D();
             useFacingPose.getState().clear();
             clearPlacementSurface();
-            useScene.temporal.getState().resume();
+            releaseHiddenWallHold();
+            history.end();
             emitter.off('wall:enter', onWallEnter);
             emitter.off('wall:move', onWallMove);
             emitter.off('wall:click', onWallClick);
@@ -894,6 +1172,14 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             emitter.off('roof:move', onRoofHover);
             emitter.off('roof:click', onRoofClick);
             emitter.off('roof:leave', onRoofLeave);
+            emitter.off('dormer:enter', onDormerHover);
+            emitter.off('dormer:move', onDormerHover);
+            emitter.off('dormer:click', onDormerClick);
+            emitter.off('dormer:leave', onDormerLeave);
+            emitter.off('window:enter', onDormerWindowHover);
+            emitter.off('window:move', onDormerWindowHover);
+            emitter.off('window:click', onDormerWindowClick);
+            emitter.off('window:leave', onDormerWindowLeave);
             emitter.off('grid:move', onGridMove);
             emitter.off('tool:cancel', onCancel);
             window.removeEventListener('pointerup', onPlacementDragPointerUp);
@@ -901,7 +1187,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             window.removeEventListener('keydown', onAltToggle);
             window.removeEventListener('keyup', onAltToggle);
         };
-    }, [movingWindowNode, exitMoveMode]);
+    }, [activeLevelId, exitMoveMode, isCameraDragging, movingWindowNode, selectNode]);
     const edgesGeo = useMemo(() => {
         const boxGeo = new BoxGeometry(movingWindowNode.width, movingWindowNode.height, movingWindowNode.frameDepth ?? 0.07);
         const geo = new EdgesGeometry(boxGeo);