@pascal-app/nodes 1.0.3 → 1.0.5

package/dist/window/mechanism.js

@@ -0,0 +1,20 @@
+import { closeWindowOpenState, getDisplayedWindowValue, isOperableWindowType, openWindowOpenState, } from '@pascal-app/editor';
+import { scriptedOpening } from '../shared/scripted-opening.js';
+/** A window's sash: Open and Close preview it without touching the saved open state. */
+export const windowMechanism = {
+    verb: 'open',
+    icon: 'window',
+    has: (node) => node.type === 'window' &&
+        (node.source
+            ? scriptedOpening.has(node)
+            : node.openingKind !== 'opening' && isOperableWindowType(node.windowType)),
+    isOn: (node) => node.type === 'window' &&
+        (node.source
+            ? scriptedOpening.isOn(node)
+            : getDisplayedWindowValue(node.id, node.operationState) > 0),
+    set: (node, on) => {
+        if (node.type === 'window' && node.source)
+            return scriptedOpening.set(node, on);
+        return (on ? openWindowOpenState : closeWindowOpenState)(node.id, { persist: false });
+    },
+};

package/dist/window/move-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/window/move-tool.tsx"],"names":[],"mappings":"AAAA,OAAO,EAiBL,UAAU,EACX,MAAM,kBAAkB,CAAA;AAkEzB;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,CAiyClD,CAAA;AAED,eAAe,cAAc,CAAA"}
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/window/move-tool.tsx"],"names":[],"mappings":"AAAA,OAAO,EA0BL,UAAU,EACX,MAAM,kBAAkB,CAAA;AAsEzB;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,CAi5ClD,CAAA;eAEc,cAAc"}

package/dist/window/move-tool.js

@@ -1,20 +1,23 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-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 { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { beginSceneHistoryDraft, collectionIdsOf, createSnapEaser, dormerWallFacePointToDormer, emitter, evaluateCorner, getOpeningWallPlacement, holdHiddenWallPointerEvents, isCurvedWall, prefersReducedMotion, runSceneHistoryDraftWrite, sceneRegistry, spatialGridManager, useLiveNodeOverrides, useLiveTransforms, useScene, WindowNode, } from '@pascal-app/core';
+import { calculateItemRotation, clearPlacementSurface, consumePlacementDragRelease, EDITOR_LAYER, getSideFromNormal, isGridSnapActive, isMagneticSnapActive, isTypingTarget, 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 { commitOpeningMove } from '../shared/commit-opening-move';
-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';
-import { WindowFloorProjection } from './floor-projection';
-import WindowPreview from './preview';
-import { clampToWall, DEFAULT_WINDOW_SILL_M, hasWallChildOverlap, wallLocalToWorld, } from './window-math';
+import { commitOpeningMove } from '../shared/commit-opening-move.js';
+import { dormerEventFromHostedWindow, getDormerWindowWorldNormal, getDormerWindowWorldYaw, resolveDormerWindowTarget, } from '../shared/dormer-wall-opening-placement.js';
+import { clearOpeningGuides3D, publishOpeningGuidesForWallEvent, resolveSillSnap, } from '../shared/opening-guides-runtime.js';
+import { beginOpeningMoveHistorySession } from '../shared/opening-move-history.js';
+import { isWallMeshHidden, shouldIgnoreWallEventForOpeningMove, } from '../shared/opening-move-wall-gate.js';
+import { openingPlaneOffsetOnWall } from '../shared/opening-plane-offset.js';
+import { getRoofWallOpeningCursorPose, resolveRoofWallOpeningTarget, } from '../shared/roof-wall-opening-placement.js';
+import { resolveOpeningPlacement } from '../shared/wall-attach-target.js';
+import { collectWallOpeningAlignmentCandidates, resolveWallSlideAlignment, } from '../shared/wall-opening-alignment.js';
+import { showCornerCue, snappingTurnedOff } from './corner-cue.js';
+import { fuseAtCorner, settleMovedWindow } from './corner-fuse.js';
+import { WindowFloorProjection } from './floor-projection.js';
+import WindowPreview from './preview.js';
+import { clampToWall, DEFAULT_WINDOW_SILL_M, hasWallChildOverlap, wallLocalToWorld, } from './window-math.js';
 const edgeMaterial = new LineBasicNodeMaterial({
     color: 0xef_44_44,
     linewidth: 3,
@@ -77,6 +80,8 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             ? movingWindowNode.metadata
             : {};
         const isNew = !!meta.isNew;
+        const endDraft = isNew ? null : beginSceneHistoryDraft(movingWindowNode.id, movingWindowNode);
+        const updateDraft = (data) => runSceneHistoryDraftWrite(() => useScene.getState().updateNode(movingWindowNode.id, data));
         // Save original state (only used in move mode)
         const original = {
             position: [...movingWindowNode.position],
@@ -102,10 +107,12 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
         // preview on the wall and can't be placed consecutively without leaving/re-entering. This
         // mirrors MoveDoorTool.
         if (!isNew) {
-            useScene.getState().updateNode(movingWindowNode.id, {
+            updateDraft({
                 metadata: { ...meta, isTransient: true },
             });
         }
+        // Same-wall moves keep the wall-local plane offset; another host resets it.
+        const planeOffsetOn = (wallId) => openingPlaneOffsetOnWall(movingWindowNode, wallId);
         let currentHostId = movingWindowNode.parentId;
         let committed = false;
         // Off-wall free-follow: over empty floor the window is parented to the
@@ -162,6 +169,20 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
         // The wall the window was grabbed from. Nulled the first time the anchor
         // seeds on any other host: the grab offset is then forgotten for good.
         let grabWallId = movingWindowNode.parentId;
+        // Dragging near a corner, the same zone as placing: the window snaps its edge to the corner,
+        // the window waiting on the other wall is outlined, and on release they join. Alt drops it
+        // plain.
+        let cornerHeld = null;
+        const cornerEaser = createSnapEaser();
+        let cornerEaseFrame = 0;
+        const resetCorner = () => {
+            cornerHeld = null;
+            cornerEaser.reset();
+            if (cornerEaseFrame)
+                cancelAnimationFrame(cornerEaseFrame);
+            cornerEaseFrame = 0;
+            showCornerCue(null);
+        };
         let lastTarget = null;
         let lastRoofEvent = null;
         let lastDormerEvent = null;
@@ -196,8 +217,9 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             const y = movingWindowNode.position[1];
             return y > 0.1 ? y : DEFAULT_WINDOW_SILL_M + movingWindowNode.height / 2;
         };
-        const getSlabElevation = (wallEvent) => spatialGridManager.getSlabElevationForWall(wallEvent.node.parentId ?? '', wallEvent.node.start, wallEvent.node.end, wallEvent.node.curveOffset ?? 0, wallEvent.node.thickness, wallEvent.node.supportSlabId);
+        const getSlabElevation = (wallEvent) => spatialGridManager.getSlabElevationForWall(wallEvent.node.parentId ?? '', wallEvent.node.start, wallEvent.node.end, wallEvent.node.curveOffset ?? 0, wallEvent.node.thickness, wallEvent.node.supportSlabId, wallEvent.node.justification);
         const hideCursor = () => {
+            resetCorner();
             if (cursorGroupRef.current)
                 cursorGroupRef.current.visible = false;
             useAlignmentGuides.getState().clear();
@@ -233,7 +255,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                 eventWallHidden: isWallMeshHidden(event.node.id),
                 ownWallIds: [original.wallId, currentHostId],
             });
-        const resolveMoveTarget = (event) => {
+        const resolveMoveTarget = (event, plain = event.nativeEvent?.altKey === true || altHeld) => {
             if (!isValidWallSideFace(event.normal))
                 return;
             if (isCurvedWall(event.node)) {
@@ -245,7 +267,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                 return;
             const faceSide = getSideFromNormal(event.normal);
             const side = sideOverride ?? faceSide;
-            const rotationOffset = side !== faceSide ? Math.PI : 0;
+            const rotationOffset = side === faceSide ? 0 : Math.PI;
             const itemRotation = calculateItemRotation(event.normal) + rotationOffset;
             const rawLocalX = event.localPosition[0];
             const rawLocalY = event.localPosition[1];
@@ -292,8 +314,34 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                 // component lives in `snapToHalf` (itself mode-aware).
                 applySnap: isMagneticSnapActive(),
             });
-            const { clampedX, clampedY } = clampToWall(event.node, localX, targetLocalY, movingWindowNode.width, movingWindowNode.height, useScene.getState().nodes);
-            const valid = !hasWallChildOverlap(event.node.id, useScene.getState().nodes, clampedX, clampedY, movingWindowNode.width, movingWindowNode.height, movingWindowNode.id);
+            const nodes = useScene.getState().nodes;
+            const slid = clampToWall(event.node, localX, targetLocalY, movingWindowNode.width, movingWindowNode.height, nodes);
+            const { clampedY } = slid;
+            let clampedX = slid.clampedX;
+            // The corner zone: the edge snaps to the corner, unless a curtain wall's margin keeps it off.
+            // Alt, or snapping off, places the window where it is dropped.
+            const found = plain || snappingTurnedOff()
+                ? { snap: null, block: null }
+                : evaluateCorner(nodes, {
+                    wallId: event.node.id,
+                    centreX: clampedX,
+                    width: movingWindowNode.width,
+                    height: movingWindowNode.height,
+                    sillHeight: clampedY - movingWindowNode.height / 2,
+                    ignoreId: movingWindowNode.id,
+                    held: cornerHeld,
+                });
+            let { snap, block } = found;
+            if (snap) {
+                const settled = clampToWall(event.node, snap.centreX, clampedY, movingWindowNode.width, movingWindowNode.height, nodes);
+                if (Math.abs(settled.clampedX - snap.centreX) > 1e-6) {
+                    block = { reason: 'curtain', end: snap.end };
+                    snap = null;
+                }
+                else
+                    clampedX = snap.centreX;
+            }
+            const valid = !hasWallChildOverlap(event.node.id, nodes, clampedX, clampedY, movingWindowNode.width, movingWindowNode.height, movingWindowNode.id);
             return {
                 wallNode: event.node,
                 wallId: event.node.id,
@@ -302,6 +350,8 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                 clampedX,
                 clampedY,
                 valid,
+                snap,
+                block,
                 event,
             };
         };
@@ -312,6 +362,18 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             // mouse-move even when the window stays in the same along-wall cell.
             // Per-frame guard collapses duplicate wall events on the same pointermove.
             tickGridStep(target.event.nativeEvent?.timeStamp ?? -1, target.clampedX);
+            cornerHeld = (target.snap ?? target.block)?.end ?? null;
+            showCornerCue(target.snap, target.block);
+            // The ghost eases into and out of the snap; the drop always lands on the snapped place.
+            const now = performance.now();
+            const shownX = cornerEaser.display(target.clampedX, target.snap !== null, now, prefersReducedMotion());
+            if (cornerEaser.active(now) && !cornerEaseFrame) {
+                cornerEaseFrame = requestAnimationFrame(() => {
+                    cornerEaseFrame = 0;
+                    if (!committed && lastTarget)
+                        applyPreview(lastTarget);
+                });
+            }
             // 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). Reparenting
@@ -321,9 +383,24 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             // 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],
+            if (currentHostId === target.wallId) {
+                const windowMesh = sceneRegistry.nodes.get(movingWindowNode.id);
+                if (windowMesh) {
+                    // Where the opening system will put it: the body centre plane of a
+                    // justified wall plus the opening's own plane offset, on the arc.
+                    const placement = getOpeningWallPlacement(target.wallNode, {
+                        ...movingWindowNode,
+                        position: [shownX, target.clampedY, planeOffsetOn(target.wallId)],
+                        rotation: [0, target.itemRotation, 0],
+                    }, useScene.getState().nodes);
+                    windowMesh.position.set(...placement.position);
+                    windowMesh.rotation.set(...placement.rotation);
+                    windowMesh.updateMatrixWorld(true);
+                }
+            }
+            else {
+                updateDraft({
+                    position: [shownX, target.clampedY, planeOffsetOn(target.wallId)],
                     rotation: [0, target.itemRotation, 0],
                     side: target.side,
                     parentId: target.wallId,
@@ -337,16 +414,8 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                 markHostDirty(currentHostId);
                 currentHostId = target.wallId;
             }
-            else {
-                const windowMesh = sceneRegistry.nodes.get(movingWindowNode.id);
-                if (windowMesh) {
-                    windowMesh.position.set(target.clampedX, target.clampedY, 0);
-                    windowMesh.rotation.set(0, target.itemRotation, 0);
-                    windowMesh.updateMatrixWorld(true);
-                }
-            }
             useLiveTransforms.getState().set(movingWindowNode.id, {
-                position: [target.clampedX, target.clampedY, 0],
+                position: [shownX, target.clampedY, planeOffsetOn(target.wallId)],
                 rotation: target.itemRotation,
             });
             markHostDirtyThrottled(target.wallId);
@@ -357,7 +426,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             // (-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]);
-            const ghostWorldPos = wallLocalToWorld(target.wallNode, target.clampedX, target.clampedY, getLevelYOffset(), getSlabElevation(target.event));
+            const ghostWorldPos = wallLocalToWorld(target.wallNode, shownX, target.clampedY, getLevelYOffset(), getSlabElevation(target.event), planeOffsetOn(target.wallId));
             const ghostYaw = target.itemRotation - wallAngle;
             setGhostPose({
                 position: ghostWorldPos,
@@ -455,13 +524,15 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                 // 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.
+                // Read before the delete: the copy joins the collections its draft is in.
+                const collectionIds = collectionIdsOf(useScene.getState().collections, movingWindowNode.id);
                 useScene.getState().deleteNode(movingWindowNode.id);
                 const cloned = structuredClone(movingWindowNode);
                 delete cloned.id;
                 cloned.metadata = stripPlacementMetadataFlags(cloned.metadata);
                 const node = WindowNode.parse({
                     ...cloned,
-                    position: [target.clampedX, target.clampedY, 0],
+                    position: [target.clampedX, target.clampedY, planeOffsetOn(target.wallId)],
                     rotation: [0, target.itemRotation, 0],
                     side: target.side,
                     wallId: target.wallId,
@@ -472,7 +543,11 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                     visible: true,
                 });
                 history.commitStep(() => {
-                    useScene.getState().createNode(node, target.wallId);
+                    useScene
+                        .getState()
+                        .createNodes([{ node, parentId: target.wallId, collectionIds }]);
+                    if (target.snap)
+                        fuseAtCorner(node.id, target.snap.waitingId);
                 });
                 placedId = node.id;
             }
@@ -480,7 +555,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                 // 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, {
+                updateDraft({
                     position: original.position,
                     rotation: original.rotation,
                     side: original.side,
@@ -495,7 +570,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                 });
                 history.commitStep(() => {
                     commitOpeningMove(movingWindowNode.id, {
-                        position: [target.clampedX, target.clampedY, 0],
+                        position: [target.clampedX, target.clampedY, planeOffsetOn(target.wallId)],
                         rotation: [0, target.itemRotation, 0],
                         side: target.side,
                         parentId: target.wallId,
@@ -503,6 +578,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                         roofSegmentId: undefined,
                         visible: true,
                     });
+                    settleMovedWindow(movingWindowNode.id, target.snap);
                 });
                 if (original.parentId && original.parentId !== target.wallId) {
                     markHostDirty(original.parentId);
@@ -514,6 +590,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             triggerSFX('sfx:structure-build');
             hideCursor();
             selectNode(placedId);
+            endDraft?.();
             exitMoveMode();
         };
         const onWallClick = (event) => {
@@ -586,10 +663,18 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             // 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 === levelId) {
+                updateDraft({
+                    position: [localX, sillCenterY, localZ],
+                    rotation: [0, yaw, 0],
+                    side: sideOverride,
+                    visible: false,
+                });
+            }
+            else {
                 if (currentHostId && currentHostId !== levelId)
                     markHostDirty(currentHostId);
-                useScene.getState().updateNode(movingWindowNode.id, {
+                updateDraft({
                     position: [localX, sillCenterY, localZ],
                     rotation: [0, yaw, 0],
                     side: sideOverride,
@@ -603,14 +688,6 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                 });
                 currentHostId = levelId;
             }
-            else {
-                useScene.getState().updateNode(movingWindowNode.id, {
-                    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({
@@ -699,6 +776,8 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             const rotation = [0, side === 'back' ? Math.PI : 0, 0];
             let placedId;
             if (isNew) {
+                // Read before the delete: the copy joins the collections its draft is in.
+                const collectionIds = collectionIdsOf(useScene.getState().collections, movingWindowNode.id);
                 useScene.getState().deleteNode(movingWindowNode.id);
                 const cloned = structuredClone(movingWindowNode);
                 delete cloned.id;
@@ -717,12 +796,16 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                     visible: true,
                 });
                 history.commitStep(() => {
-                    useScene.getState().createNode(committedNode, target.dormer.id);
+                    useScene
+                        .getState()
+                        .createNodes([
+                        { node: committedNode, parentId: target.dormer.id, collectionIds },
+                    ]);
                 });
                 placedId = committedNode.id;
             }
             else {
-                useScene.getState().updateNode(movingWindowNode.id, {
+                updateDraft({
                     position: original.position,
                     rotation: original.rotation,
                     side: original.side,
@@ -748,6 +831,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                         roofFace: undefined,
                         visible: true,
                     });
+                    settleMovedWindow(movingWindowNode.id, null);
                 });
                 if (original.parentId && original.parentId !== target.dormer.id) {
                     markHostDirty(original.parentId);
@@ -759,6 +843,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             triggerSFX('sfx:structure-build');
             hideCursor();
             selectNode(placedId);
+            endDraft?.();
             exitMoveMode();
             event.stopPropagation();
         };
@@ -860,25 +945,25 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             clearOpeningGuides3D();
             // On a roof face the real mesh is the preview — drop the ghost + reveal.
             revealRealNode();
-            if (currentHostId !== target.segment.id) {
-                markHostDirty(currentHostId);
-                currentHostId = target.segment.id;
+            if (currentHostId === target.segment.id) {
                 useLiveNodeOverrides.getState().set(movingWindowNode.id, {
                     position: target.position,
                     rotation: [0, 0, 0],
-                    side: 'front',
-                    parentId: target.segment.id,
-                    wallId: undefined,
-                    roofSegmentId: target.segment.id,
                     roofFace: target.face.id,
-                    visible: true,
                 });
             }
             else {
+                markHostDirty(currentHostId);
+                currentHostId = target.segment.id;
                 useLiveNodeOverrides.getState().set(movingWindowNode.id, {
                     position: target.position,
                     rotation: [0, 0, 0],
+                    side: 'front',
+                    parentId: target.segment.id,
+                    wallId: undefined,
+                    roofSegmentId: target.segment.id,
                     roofFace: target.face.id,
+                    visible: true,
                 });
             }
             updateRoofCursor(target, event.node);
@@ -899,6 +984,8 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             if (isNew) {
                 // See commitToWall — delete the draft paused, create as the ONE
                 // tracked write.
+                // Read before the delete: the copy joins the collections its draft is in.
+                const collectionIds = collectionIdsOf(useScene.getState().collections, movingWindowNode.id);
                 useScene.getState().deleteNode(movingWindowNode.id);
                 const cloned = structuredClone(movingWindowNode);
                 delete cloned.id;
@@ -915,14 +1002,16 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                     visible: true,
                 });
                 history.commitStep(() => {
-                    useScene.getState().createNode(node, segmentId);
+                    useScene
+                        .getState()
+                        .createNodes([{ node, parentId: segmentId, collectionIds }]);
                 });
                 placedId = node.id;
             }
             else {
                 // See commitToWall — restore the pre-drag baseline paused, drop as
                 // the ONE tracked write.
-                useScene.getState().updateNode(movingWindowNode.id, {
+                updateDraft({
                     position: original.position,
                     rotation: original.rotation,
                     side: original.side,
@@ -946,6 +1035,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                         roofFace: target.face.id,
                         visible: true,
                     });
+                    settleMovedWindow(movingWindowNode.id, null);
                 });
                 if (original.parentId && original.parentId !== segmentId) {
                     markHostDirty(original.parentId);
@@ -957,6 +1047,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             triggerSFX('sfx:structure-build');
             hideCursor();
             selectNode(placedId);
+            endDraft?.();
             exitMoveMode();
             event.stopPropagation();
         };
@@ -979,7 +1070,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                     markHostDirty(currentHostId);
             }
             else {
-                useScene.getState().updateNode(movingWindowNode.id, {
+                updateDraft({
                     position: original.position,
                     rotation: original.rotation,
                     side: original.side,
@@ -1000,6 +1091,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             // entirely. `end` is idempotent — the effect cleanup's end() is a no-op.
             history.end();
             hideCursor();
+            endDraft?.();
             exitMoveMode();
         };
         const onPlacementDragPointerUp = (event) => {
@@ -1026,11 +1118,8 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                 return;
             if (e.key !== 'r' && e.key !== 'R')
                 return;
-            const target = e.target;
-            if (target &&
-                (target.tagName === 'INPUT' || target.tagName === 'TEXTAREA' || target.isContentEditable)) {
+            if (isTypingTarget(e.target))
                 return;
-            }
             // Ignore OS key-repeat so a held R doesn't flip many times per press.
             if (e.repeat)
                 return;
@@ -1060,7 +1149,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             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, {
+                updateDraft({
                     side: sideOverride,
                     rotation: [0, sideOverride === 'back' ? Math.PI : 0, 0],
                 });
@@ -1069,12 +1158,17 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
         // Alt toggles force-place — re-run the on-wall preview so the tint flips
         // green↔red live (pointer stationary). Commit gates still read alt fresh.
         const onAltToggle = (e) => {
-            if (e.key !== 'Alt')
+            // A field's own Alt (a typed character) is not the placement's.
+            if (e.key !== 'Alt' || isTypingTarget(e.target))
                 return;
             const held = e.type === 'keydown';
             if (held === altHeld)
                 return;
             altHeld = held;
+            // Alt takes the corner join off the target at once and gives it back on release: the hint
+            // and the drop follow without the pointer moving.
+            if (lastTarget)
+                lastTarget = resolveMoveTarget(lastTarget.event, held) ?? lastTarget;
             if (!committed && lastTarget)
                 applyPreview(lastTarget);
         };
@@ -1110,7 +1204,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             if (hostWall?.type === 'wall') {
                 const wallAngle = Math.atan2(hostWall.end[1] - hostWall.start[1], hostWall.end[0] - hostWall.start[0]);
                 const ghostYaw = movingWindowNode.rotation[1] - wallAngle;
-                const seedPos = wallLocalToWorld(hostWall, movingWindowNode.position[0], movingWindowNode.position[1], getLevelYOffset(), spatialGridManager.getSlabElevationForWall(hostWall.parentId ?? '', hostWall.start, hostWall.end, hostWall.curveOffset ?? 0, hostWall.thickness, hostWall.supportSlabId));
+                const seedPos = wallLocalToWorld(hostWall, movingWindowNode.position[0], movingWindowNode.position[1], getLevelYOffset(), spatialGridManager.getSlabElevationForWall(hostWall.parentId ?? '', hostWall.start, hostWall.end, hostWall.curveOffset ?? 0, hostWall.thickness, hostWall.supportSlabId, hostWall.justification), planeOffsetOn(hostWall.id));
                 publishPlacementSurface(new Vector3(...seedPos), new Vector3(Math.sin(ghostYaw), 0, Math.cos(ghostYaw)));
                 // Claim the pointer for the wall so the floor free-follow stands down for
                 // the first frames after grab. Otherwise the first `grid:move` (the window
@@ -1121,6 +1215,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             }
         }
         return () => {
+            resetCorner();
             // Safety cleanup: if still transient on unmount (e.g. phase switch mid-move)
             const current = useScene.getState().nodes[movingWindowNode.id];
             const currentMeta = current?.metadata;
@@ -1131,7 +1226,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                         markHostDirty(currentHostId);
                 }
                 else {
-                    useScene.getState().updateNode(movingWindowNode.id, {
+                    updateDraft({
                         position: original.position,
                         rotation: original.rotation,
                         side: original.side,
@@ -1152,7 +1247,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                 // 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 });
+                updateDraft({ visible: true });
             }
             useLiveNodeOverrides.getState().clear(movingWindowNode.id);
             useLiveTransforms.getState().clear(movingWindowNode.id);
@@ -1162,6 +1257,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             clearPlacementSurface();
             releaseHiddenWallHold();
             history.end();
+            endDraft?.();
             emitter.off('wall:enter', onWallEnter);
             emitter.off('wall:move', onWallMove);
             emitter.off('wall:click', onWallClick);

package/dist/window/paint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/window/paint.ts"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH,eAAO,MAAM,WAAW,4CAGtB,CAAA"}
+{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/window/paint.ts"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH,eAAO,MAAM,WAAW,4CAOtB,CAAA"}

package/dist/window/paint.js

@@ -1,4 +1,4 @@
-import { createSlotPaintCapability, previewSlotByUserData, resolveSlotByReRaycast, } from '../shared/slot-paint';
+import { createSlotPaintCapability, previewSlotByUserData, resolveSlotByReRaycast, } from '../shared/slot-paint.js';
 /**
  * Window paint on the unified slot model. The window's opening proxy (a proud,
  * invisible cutout) wins the shared scene raycast over the wall in front of the
@@ -8,4 +8,7 @@ import { createSlotPaintCapability, previewSlotByUserData, resolveSlotByReRaycas
 export const windowPaint = createSlotPaintCapability({
     resolveRole: resolveSlotByReRaycast,
     applyPreview: previewSlotByUserData,
+    legacyEffective: (node, role) => node.type === 'window' && !node.source && node.material && role === 'frame'
+        ? { material: node.material, materialPreset: undefined }
+        : null,
 });

package/dist/window/panel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/window/panel.tsx"],"names":[],"mappings":"AAwFA,MAAM,CAAC,OAAO,UAAU,WAAW,uCA20BlC"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/window/panel.tsx"],"names":[],"mappings":"AA0GA,MAAM,CAAC,OAAO,UAAU,WAAW,uCA68BlC"}