@pascal-app/nodes 1.0.3 → 1.0.4

package/dist/window/floorplan.js

@@ -1,6 +1,8 @@
+import { getWallBodyCenterOffset } from '@pascal-app/core';
 import { floorplanGeometryMetadata, readFloorplanContext } from '@pascal-app/editor';
 import { buildOpeningMarkAnnotation, } from '../shared/opening-documentation';
 import { buildOpeningPlacementDimensions } from '../shared/opening-placement-dimensions';
+import { resolveOpeningPlanPlane } from '../shared/opening-plane-offset';
 /**
  * Stage C floor-plan builder for window. Mirrors the legacy
  * floorplan-panel window rendering:
@@ -31,11 +33,42 @@ export function buildWindowFloorplan(node, ctx) {
     const perpZ = dirX;
     const distance = node.position[0];
     const width = node.width;
-    const depth = wall.thickness ?? 0.1;
-    const cx = x1 + dirX * distance;
-    const cz = z1 + dirZ * distance;
+    const wallDepth = wall.thickness ?? 0.1;
+    const plane = resolveOpeningPlanPlane(node, wallDepth);
+    const depth = plane.depth;
+    // The plane offset is measured from the body centre, which a justified wall
+    // sets off its reference line.
+    const bodyOffset = getWallBodyCenterOffset(wall);
+    const across = bodyOffset + plane.offset;
+    const cx = x1 + dirX * distance + perpX * across;
+    const cz = z1 + dirZ * distance + perpZ * across;
     const halfWidth = width / 2;
     const halfDepth = depth / 2;
+    // An offset frame stands clear of the wall centre, but the wall is still
+    // cut through its whole thickness: that hole is drawn too.
+    const wallX = x1 + dirX * distance + perpX * bodyOffset;
+    const wallZ = z1 + dirZ * distance + perpZ * bodyOffset;
+    const halfWallDepth = wallDepth / 2;
+    const cutoutPoints = plane.offset === 0
+        ? null
+        : [
+            [
+                wallX - dirX * halfWidth + perpX * halfWallDepth,
+                wallZ - dirZ * halfWidth + perpZ * halfWallDepth,
+            ],
+            [
+                wallX + dirX * halfWidth + perpX * halfWallDepth,
+                wallZ + dirZ * halfWidth + perpZ * halfWallDepth,
+            ],
+            [
+                wallX + dirX * halfWidth - perpX * halfWallDepth,
+                wallZ + dirZ * halfWidth - perpZ * halfWallDepth,
+            ],
+            [
+                wallX - dirX * halfWidth - perpX * halfWallDepth,
+                wallZ - dirZ * halfWidth - perpZ * halfWallDepth,
+            ],
+        ];
     const points = [
         [cx - dirX * halfWidth + perpX * halfDepth, cz - dirZ * halfWidth + perpZ * halfDepth],
         [cx + dirX * halfWidth + perpX * halfDepth, cz + dirZ * halfWidth + perpZ * halfDepth],
@@ -75,44 +108,93 @@ export function buildWindowFloorplan(node, ctx) {
     // midpoint of the right edge of the cutout.
     const mullionStart = [cx - dirX * halfWidth, cz - dirZ * halfWidth];
     const mullionEnd = [cx + dirX * halfWidth, cz + dirZ * halfWidth];
-    const children = [
-        // Outer footprint — white fill so the wall hatch underneath
-        // doesn't bleed through.
-        {
-            kind: 'polygon',
-            points,
-            fill: fillColor,
-            stroke: accentColor,
-            strokeWidth: showSelectedChrome ? 1.9 : 1.25,
-            vectorEffect: 'non-scaling-stroke',
-            strokeLinejoin: 'round',
-            metadata: floorplanGeometryMetadata({ annotationObstacle: 'bounds' }),
-        },
-        // Inset glass-pane outline.
-        {
-            kind: 'polygon',
-            points: [innerStartA, innerEndA, innerEndB, innerStartB],
-            fill: 'none',
-            stroke: accentColor,
-            strokeOpacity: 0.6,
-            strokeWidth: showSelectedChrome ? 1.3 : 0.9,
-            vectorEffect: 'non-scaling-stroke',
-            strokeLinejoin: 'round',
-        },
-        // Center mullion.
-        {
-            kind: 'line',
-            x1: mullionStart[0],
-            y1: mullionStart[1],
-            x2: mullionEnd[0],
-            y2: mullionEnd[1],
-            stroke: accentColor,
-            strokeWidth: showSelectedChrome ? 1.6 : 1.1,
-            strokeOpacity: 0.85,
-            strokeLinecap: 'round',
-            vectorEffect: 'non-scaling-stroke',
-        },
-    ];
+    // A sheet draws the standard window symbol in plan-metre ink, so it prints
+    // the same in every back end: the two wall faces carried across the opening
+    // (the outline, which closes on the jambs) and the glass line between them.
+    const drafting = readFloorplanContext(ctx).drafting;
+    const cutout = cutoutPoints
+        ? [
+            drafting
+                ? {
+                    kind: 'polygon',
+                    points: cutoutPoints,
+                    fill: '#ffffff',
+                    stroke: '#1f2937',
+                    strokeWidth: 0.01,
+                    strokeLinejoin: 'miter',
+                }
+                : {
+                    kind: 'polygon',
+                    points: cutoutPoints,
+                    fill: fillColor,
+                    stroke: accentColor,
+                    strokeWidth: showSelectedChrome ? 1.9 : 1.25,
+                    vectorEffect: 'non-scaling-stroke',
+                    strokeLinejoin: 'round',
+                    metadata: floorplanGeometryMetadata({ annotationObstacle: 'bounds' }),
+                },
+        ]
+        : [];
+    const children = drafting
+        ? [
+            ...cutout,
+            {
+                kind: 'polygon',
+                points,
+                fill: '#ffffff',
+                stroke: '#1f2937',
+                strokeWidth: 0.01,
+                strokeLinejoin: 'miter',
+            },
+            {
+                kind: 'line',
+                x1: mullionStart[0],
+                y1: mullionStart[1],
+                x2: mullionEnd[0],
+                y2: mullionEnd[1],
+                stroke: '#1f2937',
+                strokeWidth: 0.008,
+            },
+        ]
+        : [
+            ...cutout,
+            // Outer footprint — white fill so the wall hatch underneath
+            // doesn't bleed through.
+            {
+                kind: 'polygon',
+                points,
+                fill: fillColor,
+                stroke: accentColor,
+                strokeWidth: showSelectedChrome ? 1.9 : 1.25,
+                vectorEffect: 'non-scaling-stroke',
+                strokeLinejoin: 'round',
+                metadata: floorplanGeometryMetadata({ annotationObstacle: 'bounds' }),
+            },
+            // Inset glass-pane outline.
+            {
+                kind: 'polygon',
+                points: [innerStartA, innerEndA, innerEndB, innerStartB],
+                fill: 'none',
+                stroke: accentColor,
+                strokeOpacity: 0.6,
+                strokeWidth: showSelectedChrome ? 1.3 : 0.9,
+                vectorEffect: 'non-scaling-stroke',
+                strokeLinejoin: 'round',
+            },
+            // Center mullion.
+            {
+                kind: 'line',
+                x1: mullionStart[0],
+                y1: mullionStart[1],
+                x2: mullionEnd[0],
+                y2: mullionEnd[1],
+                stroke: accentColor,
+                strokeWidth: showSelectedChrome ? 1.6 : 1.1,
+                strokeOpacity: 0.85,
+                strokeLinecap: 'round',
+                vectorEffect: 'non-scaling-stroke',
+            },
+        ];
     // Move handle — orange dot at the window center. Only when selected.
     if (isSelected) {
         children.push({
@@ -124,24 +206,27 @@ export function buildWindowFloorplan(node, ctx) {
         // `resize-width` affordance — anchored at the opposite edge, clamped
         // to wall bounds. Mirrors the 3D `WindowSideArrow` width drag and the
         // door's 2D pattern.
-        const startEdgeX = cx - dirX * halfWidth;
-        const startEdgeZ = cz - dirZ * halfWidth;
-        const endEdgeX = cx + dirX * halfWidth;
-        const endEdgeZ = cz + dirZ * halfWidth;
-        children.push({
-            kind: 'move-arrow',
-            point: [startEdgeX, startEdgeZ],
-            angle: Math.atan2(-dirZ, -dirX),
-            affordance: 'resize-width',
-            payload: { side: 'start' },
-        });
-        children.push({
-            kind: 'move-arrow',
-            point: [endEdgeX, endEdgeZ],
-            angle: Math.atan2(dirZ, dirX),
-            affordance: 'resize-width',
-            payload: { side: 'end' },
-        });
+        // A scripted opening's width is its script's: its size arrows live in 3D, on its params.
+        if (!node.source) {
+            const startEdgeX = cx - dirX * halfWidth;
+            const startEdgeZ = cz - dirZ * halfWidth;
+            const endEdgeX = cx + dirX * halfWidth;
+            const endEdgeZ = cz + dirZ * halfWidth;
+            children.push({
+                kind: 'move-arrow',
+                point: [startEdgeX, startEdgeZ],
+                angle: Math.atan2(-dirZ, -dirX),
+                affordance: 'resize-width',
+                payload: { side: 'start' },
+            });
+            children.push({
+                kind: 'move-arrow',
+                point: [endEdgeX, endEdgeZ],
+                angle: Math.atan2(dirZ, dirX),
+                affordance: 'resize-width',
+                payload: { side: 'end' },
+            });
+        }
     }
     // Placement-measurement dimensions when actively moving — same
     // contract as door (see `nodes/src/door/floorplan.ts`).
@@ -150,7 +235,7 @@ export function buildWindowFloorplan(node, ctx) {
             children.push(dim);
         }
     }
-    const markAnnotation = buildOpeningMarkAnnotation(node, wall, ctx.levelData, { stroke: showSelectedChrome ? '#f97316' : '#334155' });
+    const markAnnotation = buildOpeningMarkAnnotation(node, wall, ctx.levelData, { stroke: showSelectedChrome ? '#f97316' : '#334155', drafting });
     if (markAnnotation)
         children.push(markAnnotation);
     return { kind: 'group', children };

package/dist/window/mechanism.d.ts

@@ -0,0 +1,4 @@
+import type { MechanismCapability } from '@pascal-app/core';
+/** A window's sash: Open and Close preview it without touching the saved open state. */
+export declare const windowMechanism: MechanismCapability;
+//# sourceMappingURL=mechanism.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mechanism.d.ts","sourceRoot":"","sources":["../../src/window/mechanism.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAA;AAS3D,wFAAwF;AACxF,eAAO,MAAM,eAAe,EAAE,mBAiB7B,CAAA"}

package/dist/window/mechanism.js

@@ -0,0 +1,20 @@
+import { closeWindowOpenState, getDisplayedWindowValue, isOperableWindowType, openWindowOpenState, } from '@pascal-app/editor';
+import { scriptedOpening } from '../shared/scripted-opening';
+/** 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,EAqBL,UAAU,EACX,MAAM,kBAAkB,CAAA;AAmEzB;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,CAy0ClD,CAAA;AAED,eAAe,cAAc,CAAA"}

package/dist/window/move-tool.js

@@ -1,5 +1,5 @@
 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 { beginSceneHistoryDraft, collectionIdsOf, dormerWallFacePointToDormer, emitter, getOpeningWallPlacement, holdHiddenWallPointerEvents, isCurvedWall, runSceneHistoryDraftWrite, 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';
@@ -9,6 +9,7 @@ import { dormerEventFromHostedWindow, getDormerWindowWorldNormal, getDormerWindo
 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 { openingPlaneOffsetOnWall } from '../shared/opening-plane-offset';
 import { getRoofWallOpeningCursorPose, resolveRoofWallOpeningTarget, } from '../shared/roof-wall-opening-placement';
 import { resolveOpeningPlacement } from '../shared/wall-attach-target';
 import { collectWallOpeningAlignmentCandidates, resolveWallSlideAlignment, } from '../shared/wall-opening-alignment';
@@ -77,6 +78,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 +105,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
@@ -196,7 +201,7 @@ 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 = () => {
             if (cursorGroupRef.current)
                 cursorGroupRef.current.visible = false;
@@ -245,7 +250,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];
@@ -321,9 +326,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: [target.clampedX, 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: [target.clampedX, target.clampedY, planeOffsetOn(target.wallId)],
                     rotation: [0, target.itemRotation, 0],
                     side: target.side,
                     parentId: target.wallId,
@@ -337,16 +357,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: [target.clampedX, target.clampedY, planeOffsetOn(target.wallId)],
                 rotation: target.itemRotation,
             });
             markHostDirtyThrottled(target.wallId);
@@ -357,7 +369,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, target.clampedX, target.clampedY, getLevelYOffset(), getSlabElevation(target.event), planeOffsetOn(target.wallId));
             const ghostYaw = target.itemRotation - wallAngle;
             setGhostPose({
                 position: ghostWorldPos,
@@ -455,13 +467,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 +486,9 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                     visible: true,
                 });
                 history.commitStep(() => {
-                    useScene.getState().createNode(node, target.wallId);
+                    useScene
+                        .getState()
+                        .createNodes([{ node, parentId: target.wallId, collectionIds }]);
                 });
                 placedId = node.id;
             }
@@ -480,7 +496,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 +511,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,
@@ -514,6 +530,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             triggerSFX('sfx:structure-build');
             hideCursor();
             selectNode(placedId);
+            endDraft?.();
             exitMoveMode();
         };
         const onWallClick = (event) => {
@@ -586,10 +603,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 +628,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 +716,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 +736,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,
@@ -759,6 +782,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             triggerSFX('sfx:structure-build');
             hideCursor();
             selectNode(placedId);
+            endDraft?.();
             exitMoveMode();
             event.stopPropagation();
         };
@@ -860,25 +884,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 +923,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 +941,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,
@@ -957,6 +985,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             triggerSFX('sfx:structure-build');
             hideCursor();
             selectNode(placedId);
+            endDraft?.();
             exitMoveMode();
             event.stopPropagation();
         };
@@ -979,7 +1008,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 +1029,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) => {
@@ -1060,7 +1090,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],
                 });
@@ -1110,7 +1140,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
@@ -1131,7 +1161,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 +1182,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 +1192,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

@@ -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,
 });