@pascal-app/nodes 1.0.3 → 1.0.5

package/dist/window/tool.js

@@ -1,18 +1,22 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import { dormerWallFacePointToDormer, emitter, getEffectiveNode, holdHiddenWallPointerEvents, isCurvedWall, sceneRegistry, spatialGridManager, useLiveNodeOverrides, useScene, WallNode as WallNodeSchema, WindowNode, } from '@pascal-app/core';
-import { calculateItemRotation, clearPlacementSurface, EDITOR_LAYER, getSideFromNormal, isMagneticSnapActive, isValidWallSideFace, publishPlacementSurface, snapToHalf, triggerSFX, useAlignmentGuides, useEditor, useFacingPose, usePlacementPreview, useRegistryToolContext, } from '@pascal-app/editor';
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { beginSceneHistoryDraft, createSnapEaser, dormerWallFacePointToDormer, emitter, evaluateCorner, getEffectiveNode, holdHiddenWallPointerEvents, isCurvedWall, prefersReducedMotion, runAsSingleSceneHistoryStep, sceneRegistry, spatialGridManager, useLiveNodeOverrides, useScene, WallNode as WallNodeSchema, WindowNode, } from '@pascal-app/core';
+import { windowTakesStyle } from '@pascal-app/core/building';
+import { calculateItemRotation, clearPlacementSurface, EDITOR_LAYER, getSideFromNormal, isMagneticSnapActive, isTypingTarget, isValidWallSideFace, publishPlacementSurface, snapToHalf, triggerSFX, useAlignmentGuides, useEditor, useFacingPose, usePlacementPreview, useRegistryToolContext, } from '@pascal-app/editor';
 import { 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 { shouldFollowOpeningGrid, shouldHandleOpeningHostLeave, } from '../shared/opening-grid-follow';
-import { clearOpeningGuides3D, publishOpeningGuidesForWallEvent, resolveSillSnap, } from '../shared/opening-guides-runtime';
-import { getRoofWallOpeningCursorPose, resolveRoofWallOpeningTarget, worldToSelectedBuildingLocal, } from '../shared/roof-wall-opening-placement';
-import { wallEventFromGrid } from '../shared/wall-event-from-grid';
-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 { dormerEventFromHostedWindow, getDormerWindowWorldNormal, getDormerWindowWorldYaw, resolveDormerWindowTarget, } from '../shared/dormer-wall-opening-placement.js';
+import { shouldFollowOpeningGrid, shouldHandleOpeningHostLeave, } from '../shared/opening-grid-follow.js';
+import { clearOpeningGuides3D, publishOpeningGuidesForWallEvent, resolveSillSnap, } from '../shared/opening-guides-runtime.js';
+import { getRoofWallOpeningCursorPose, resolveRoofWallOpeningTarget, worldToSelectedBuildingLocal, } from '../shared/roof-wall-opening-placement.js';
+import { wallEventFromGrid } from '../shared/wall-event-from-grid.js';
+import { collectWallOpeningAlignmentCandidates, resolveWallSlideAlignment, } from '../shared/wall-opening-alignment.js';
+import { showCornerCue, snappingTurnedOff } from './corner-cue.js';
+import { fuseAtCorner } from './corner-fuse.js';
+import { WindowFloorProjection } from './floor-projection.js';
+import { placedWindowFields, useWindowPlacement } from './placement.js';
+import WindowPreview from './preview.js';
+import { clampToWall, DEFAULT_WINDOW_SILL_M, hasWallChildOverlap, wallLocalToWorld, } from './window-math.js';
 // Shared edge material — reuse across renders, just toggle color
 const edgeMaterial = new LineBasicNodeMaterial({
     color: 0xef_44_44, // red-500 default (invalid)
@@ -49,20 +53,50 @@ const WindowTool = () => {
     // `floorY` feeds the floor "shadow" projection; `side` carries the R-flip so
     // the floating ghost faces the side that will be committed.
     const [fallbackPose, setFallbackPose] = useState(null);
-    // Ghost preview node — zeroed transform + the live facing side (rebuilds on R).
+    const placedType = useWindowPlacement((state) => state.type);
+    const placedStyle = useWindowPlacement((state) => state.style);
+    // Ghost preview node — zeroed transform + the live facing side (rebuilds on R) and the
+    // chips' type and style (rebuilds on O / L).
+    // biome-ignore lint/correctness/useExhaustiveDependencies: placedWindowFields reads the chips' store
     const ghostStub = useMemo(() => WindowNode.parse({
+        ...placedWindowFields(),
         position: [0, 0, 0],
         rotation: [0, 0, 0],
         side: fallbackPose?.side ?? 'front',
-    }), [fallbackPose?.side]);
+    }), [fallbackPose?.side, placedType, placedStyle]);
     // The frame depth is a fixed parse default (the `side` flip doesn't change
     // it); a ref lets the facing-pose publish inside the setup effect read it
     // without re-subscribing every event listener.
     const frameDepthRef = useRef(ghostStub.frameDepth);
     useEffect(() => {
         useScene.temporal.getState().pause();
+        // The draft is a created carry draft: undo history and every save leave it out
+        // (core `getSceneDocument`), so a reload mid-placement never finds it in the scene.
+        const draftHistoryEnds = new Map();
+        const createDraft = (node, parentId) => {
+            const end = beginSceneHistoryDraft(node.id, null);
+            draftHistoryEnds.set(node.id, end);
+            try {
+                useScene.getState().createNode(node, parentId);
+            }
+            catch (error) {
+                end();
+                draftHistoryEnds.delete(node.id);
+                throw error;
+            }
+        };
+        const deleteDraft = (id) => {
+            try {
+                useScene.getState().deleteNode(id);
+            }
+            finally {
+                draftHistoryEnds.get(id)?.();
+                draftHistoryEnds.delete(id);
+            }
+        };
         const ownedPreviewIds = new Set();
-        const fallbackPreview = WindowNode.parse({
+        const fallbackPreview = () => WindowNode.parse({
+            ...placedWindowFields(),
             position: [0, 0, 0],
             rotation: [0, 0, 0],
             side: 'front',
@@ -103,6 +137,25 @@ const WindowTool = () => {
         // to the last wall hover so the flip shows live before commit.
         let sideFlip = false;
         let lastWallEvent = null;
+        // Placing near a corner: inside the corner zone the ghost snaps its edge to the corner, the
+        // window waiting on the other wall is outlined, and the HUD says what a click does. Alt places
+        // the window plain.
+        let cornerHeld = null;
+        // Whether Alt is held: from the keys, and from each new pointer event, which also catches a
+        // press made while the canvas did not have focus.
+        let altDown = false;
+        // Alt, or snapping off, places the window where it is clicked.
+        const cornerSnapOn = () => !altDown && !snappingTurnedOff();
+        const cornerEaser = createSnapEaser();
+        let cornerEaseFrame = 0;
+        const resetCorner = () => {
+            cornerHeld = null;
+            cornerEaser.reset();
+            if (cornerEaseFrame)
+                cancelAnimationFrame(cornerEaseFrame);
+            cornerEaseFrame = 0;
+            showCornerCue(null);
+        };
         let lastDormerEvent = null;
         // Last open-floor cursor point (level-local X/Z) + floor Y, so an R-flip
         // while free-following can re-render the floating ghost with the new facing.
@@ -112,11 +165,12 @@ const WindowTool = () => {
             const id = getLevelId();
             return id ? (sceneRegistry.nodes.get(id)?.position.y ?? 0) : 0;
         };
-        const getSlabElevationForWall = (wall) => spatialGridManager.getSlabElevationForWall(wall.parentId ?? '', wall.start, wall.end, wall.curveOffset ?? 0, wall.thickness, wall.supportSlabId);
+        const getSlabElevationForWall = (wall) => spatialGridManager.getSlabElevationForWall(wall.parentId ?? '', wall.start, wall.end, wall.curveOffset ?? 0, wall.thickness, wall.supportSlabId, wall.justification);
         const markHostDirty = (hostId) => {
             useScene.getState().dirtyNodes.add(hostId);
         };
         const destroyDraft = () => {
+            resetCorner();
             const draft = draftRef.current;
             if (!draft) {
                 clearPlacementPreview();
@@ -124,7 +178,7 @@ const WindowTool = () => {
             }
             const wallId = draft.parentId;
             useLiveNodeOverrides.getState().clear(draft.id);
-            useScene.getState().deleteNode(draft.id);
+            deleteDraft(draft.id);
             draftRef.current = null;
             clearPlacementPreview();
             // Rebuild wall so it removes the cutout from the deleted draft
@@ -179,7 +233,8 @@ const WindowTool = () => {
                 floorY,
                 side: sideFlip ? 'back' : 'front',
             });
-            const halfWidth = fallbackPreview.width / 2 + 0.5;
+            const preview = fallbackPreview();
+            const halfWidth = preview.width / 2 + 0.5;
             const wall = WallNodeSchema.parse({
                 end: [position[0] + halfWidth, position[2]],
                 id: fallbackWallId,
@@ -187,10 +242,10 @@ const WindowTool = () => {
                 thickness: 0.1,
             });
             const ghost = WindowNode.parse({
-                ...fallbackPreview,
+                ...preview,
                 metadata: { isTransient: true },
                 parentId: wall.id,
-                position: [halfWidth, FALLBACK_SILL_LIFT + fallbackPreview.height / 2, 0],
+                position: [halfWidth, FALLBACK_SILL_LIFT + preview.height / 2, 0],
                 rotation: [0, sideFlip ? Math.PI : 0, 0],
                 side: sideFlip ? 'back' : 'front',
                 wallId: wall.id,
@@ -219,31 +274,32 @@ const WindowTool = () => {
             const itemRotation = sideFlip ? Math.PI : 0;
             if (draftRef.current && draftRef.current.parentId !== event.node.id)
                 destroyDraft();
-            if (!draftRef.current) {
-                const node = WindowNode.parse({
+            if (draftRef.current) {
+                useLiveNodeOverrides.getState().set(draftRef.current.id, {
                     position: target.position,
                     rotation: [0, itemRotation, 0],
                     side,
                     parentId: event.node.id,
                     dormerId: event.node.id,
                     dormerFace: target.face,
-                    metadata: { isTransient: true },
+                    wallId: undefined,
+                    roofSegmentId: undefined,
+                    roofFace: undefined,
                 });
-                useScene.getState().createNode(node, event.node.id);
-                draftRef.current = node;
             }
             else {
-                useLiveNodeOverrides.getState().set(draftRef.current.id, {
+                const node = WindowNode.parse({
+                    ...placedWindowFields(),
                     position: target.position,
                     rotation: [0, itemRotation, 0],
                     side,
                     parentId: event.node.id,
                     dormerId: event.node.id,
                     dormerFace: target.face,
-                    wallId: undefined,
-                    roofSegmentId: undefined,
-                    roofFace: undefined,
+                    metadata: { isTransient: true },
                 });
+                createDraft(node, event.node.id);
+                draftRef.current = node;
             }
             publishDraftPreview(event.node);
             clearOpeningGuides3D();
@@ -272,7 +328,7 @@ const WindowTool = () => {
             return sillY ?? snapToHalf(args.rawLocalY);
         };
         // Settle a wall target: alignment snap → sill clamp → overlap check.
-        const resolveWallPlacement = (wall, rawLocalX, rawLocalY, width, height, applySnap, ignoreId) => {
+        const resolveWallPlacement = (wall, rawLocalX, rawLocalY, width, height, applySnap, cornerSnapOn, ignoreId) => {
             // Along-wall alignment guides are DISPLAYED in every snapping mode; the
             // magnetic pull onto them is applied only when `applySnap` (magnetic
             // "lines" mode). The grid component lives in `snapToHalf` (mode-aware).
@@ -291,20 +347,46 @@ const WindowTool = () => {
                 width,
                 height,
             });
-            const { clampedX, clampedY } = clampToWall(wall, localX, localY, width, height, useScene.getState().nodes);
-            const valid = !hasWallChildOverlap(wall.id, useScene.getState().nodes, clampedX, clampedY, width, height, ignoreId);
-            return { clampedX, clampedY, valid };
+            const nodes = useScene.getState().nodes;
+            const slid = clampToWall(wall, localX, localY, width, 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.
+            const found = cornerSnapOn
+                ? evaluateCorner(nodes, {
+                    wallId: wall.id,
+                    centreX: clampedX,
+                    width,
+                    height,
+                    sillHeight: clampedY - height / 2,
+                    ignoreId,
+                    held: cornerHeld,
+                })
+                : { snap: null, block: null };
+            let { snap, block } = found;
+            if (snap) {
+                const settled = clampToWall(wall, snap.centreX, clampedY, width, 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(wall.id, nodes, clampedX, clampedY, width, height, ignoreId);
+            return { clampedX, clampedY, valid, snap, block };
         };
         // Shared create/update path for the wall draft — used by the direct
         // wall-mesh hover and the floor proximity snap. Reuses the existing draft
         // (reparenting only on an actual wall change to avoid churning the host's
         // children array, which flashes 0-vertex wall geometry in WebGPU).
         const applyWallTarget = (args) => {
-            const { wall, rawLocalX, rawLocalY, side, itemRotation, cursorRotationY, applySnap } = args;
+            const { wall, rawLocalX, rawLocalY, side, itemRotation, cursorRotationY, applySnap, cornerSnapOn, } = args;
             const width = draftRef.current?.width ?? 1.5;
             const height = draftRef.current?.height ?? 1.5;
             if (!draftRef.current) {
                 const node = WindowNode.parse({
+                    ...placedWindowFields(),
                     position: [0, DEFAULT_SILL_CENTER_Y, 0],
                     rotation: [0, itemRotation, 0],
                     side,
@@ -312,13 +394,25 @@ const WindowTool = () => {
                     parentId: wall.id,
                     metadata: { isTransient: true },
                 });
-                useScene.getState().createNode(node, wall.id);
+                createDraft(node, wall.id);
                 draftRef.current = node;
             }
-            const { clampedX, clampedY, valid } = resolveWallPlacement(wall, rawLocalX, rawLocalY, width, height, applySnap, draftRef.current.id);
+            const { clampedX, clampedY, valid, snap, block } = resolveWallPlacement(wall, rawLocalX, rawLocalY, width, height, applySnap, cornerSnapOn, draftRef.current.id);
+            cornerHeld = (snap ?? block)?.end ?? null;
+            showCornerCue(snap, block);
+            // The ghost eases into and out of the snap; the click always lands on the snapped place.
+            const now = performance.now();
+            const shownX = cornerEaser.display(clampedX, snap !== null, now, prefersReducedMotion());
+            if (cornerEaser.active(now) && !cornerEaseFrame) {
+                cornerEaseFrame = requestAnimationFrame(() => {
+                    cornerEaseFrame = 0;
+                    if (lastWallEvent)
+                        onWallHover(lastWallEvent);
+                });
+            }
             if (wall.id === draftRef.current.parentId) {
                 useLiveNodeOverrides.getState().set(draftRef.current.id, {
-                    position: [clampedX, clampedY, 0],
+                    position: [shownX, clampedY, 0],
                     rotation: [0, itemRotation, 0],
                     side,
                 });
@@ -327,7 +421,7 @@ const WindowTool = () => {
             else {
                 useLiveNodeOverrides.getState().clear(draftRef.current.id);
                 useScene.getState().updateNode(draftRef.current.id, {
-                    position: [clampedX, clampedY, 0],
+                    position: [shownX, clampedY, 0],
                     rotation: [0, itemRotation, 0],
                     side,
                     parentId: wall.id,
@@ -338,7 +432,7 @@ const WindowTool = () => {
                 });
             }
             publishDraftPreview(wall);
-            updateCursor(wallLocalToWorld(wall, clampedX, clampedY, getLevelYOffset(), getSlabElevationForWall(wall)), cursorRotationY, valid, -clampedY);
+            updateCursor(wallLocalToWorld(wall, shownX, clampedY, getLevelYOffset(), getSlabElevationForWall(wall)), cursorRotationY, valid, -clampedY);
             if (draftRef.current) {
                 publishOpeningGuidesForWallEvent({
                     wall,
@@ -356,15 +450,16 @@ const WindowTool = () => {
         };
         // Promote the draft into a permanent window. Shared by the wall-mesh click
         // and the floor proximity click.
-        const commitWindowAtWall = (wall, clampedX, clampedY, side, itemRotation) => {
+        const commitWindowAtWall = (wall, clampedX, clampedY, side, itemRotation, snap = null) => {
             const draft = draftRef.current;
             if (!draft)
                 return;
             clearPlacementPreview();
+            resetCorner();
             draftRef.current = null;
             hostKind = null;
             useLiveNodeOverrides.getState().clear(draft.id);
-            useScene.getState().deleteNode(draft.id);
+            deleteDraft(draft.id);
             useScene.temporal.getState().resume();
             const levelId = getLevelId();
             const state = useScene.getState();
@@ -398,7 +493,12 @@ const WindowTool = () => {
                 sillDepth: draft.sillDepth,
                 sillThickness: draft.sillThickness,
             });
-            useScene.getState().createNode(node, wall.id);
+            // At a corner the window is placed already joined, as one undo step.
+            runAsSingleSceneHistoryStep(useScene, () => {
+                useScene.getState().createNode(node, wall.id);
+                if (snap)
+                    fuseAtCorner(node.id, snap.waitingId);
+            });
             selectNode(node.id);
             triggerSFX('sfx:structure-build');
             useAlignmentGuides.getState().clear();
@@ -420,7 +520,7 @@ const WindowTool = () => {
             draftRef.current = null;
             hostKind = null;
             useLiveNodeOverrides.getState().clear(draft.id);
-            useScene.getState().deleteNode(draft.id);
+            deleteDraft(draft.id);
             useScene.temporal.getState().resume();
             const state = useScene.getState();
             const windowCount = Object.values(state.nodes).filter((node) => node.type === 'window').length;
@@ -481,6 +581,9 @@ const WindowTool = () => {
                 showWallFallbackCursor(event);
                 return;
             }
+            // The Alt toggle re-runs the last event: only a new one says whether Alt is held.
+            if (event !== lastWallEvent)
+                altDown = event.nativeEvent?.altKey === true;
             lastWallEvent = event;
             const faceSide = getSideFromNormal(event.normal);
             const side = sideFlip ? (faceSide === 'front' ? 'back' : 'front') : faceSide;
@@ -500,6 +603,7 @@ const WindowTool = () => {
                 itemRotation,
                 cursorRotationY: cursorRotation,
                 applySnap: isMagneticSnapActive(),
+                cornerSnapOn: cornerSnapOn(),
             });
             event.stopPropagation();
         };
@@ -514,11 +618,11 @@ const WindowTool = () => {
             const faceSide = getSideFromNormal(event.normal);
             const side = sideFlip ? (faceSide === 'front' ? 'back' : 'front') : faceSide;
             const itemRotation = calculateItemRotation(event.normal) + (sideFlip ? Math.PI : 0);
-            const { clampedX, clampedY, valid } = resolveWallPlacement(event.node, event.localPosition[0], event.localPosition[1], draftRef.current.width, draftRef.current.height, isMagneticSnapActive(), draftRef.current.id);
+            const { clampedX, clampedY, valid, snap } = resolveWallPlacement(event.node, event.localPosition[0], event.localPosition[1], draftRef.current.width, draftRef.current.height, isMagneticSnapActive(), event.nativeEvent?.altKey !== true && cornerSnapOn(), draftRef.current.id);
             // Alt force-places over a collision (the draft stays red as a warning).
             if (!valid && event.nativeEvent?.altKey !== true)
                 return;
-            commitWindowAtWall(event.node, clampedX, clampedY, side, itemRotation);
+            commitWindowAtWall(event.node, clampedX, clampedY, side, itemRotation, snap);
             event.stopPropagation();
         };
         // XR selectend produces a grid click without replaying the wall mesh's
@@ -697,6 +801,7 @@ const WindowTool = () => {
             }
             else {
                 const node = WindowNode.parse({
+                    ...placedWindowFields(),
                     position,
                     rotation: [0, 0, 0],
                     side: 'front',
@@ -705,7 +810,7 @@ const WindowTool = () => {
                     parentId: segment.id,
                     metadata: { isTransient: true },
                 });
-                useScene.getState().createNode(node, segment.id);
+                createDraft(node, segment.id);
                 draftRef.current = node;
             }
             publishDraftPreview(segment);
@@ -729,7 +834,7 @@ const WindowTool = () => {
             draftRef.current = null;
             hostKind = null;
             useLiveNodeOverrides.getState().clear(draft.id);
-            useScene.getState().deleteNode(draft.id);
+            deleteDraft(draft.id);
             useScene.temporal.getState().resume();
             const state = useScene.getState();
             const windowCount = Object.values(state.nodes).filter((n) => n.type === 'window' && n.roofSegmentId !== undefined).length;
@@ -790,14 +895,27 @@ const WindowTool = () => {
         // guard dropped R off-wall / before the first hover). Then re-renders the
         // current preview so the flip shows live and matches commit.
         const onKeyDown = (e) => {
-            if (e.key !== 'r' && e.key !== 'R')
+            const key = e.key.toLowerCase();
+            if (key !== 'r' && key !== 'o' && key !== 'l')
+                return;
+            if (key === 'l' && !windowTakesStyle(useWindowPlacement.getState().type))
                 return;
             if (e.repeat)
                 return;
-            const t = e.target;
-            if (t && (t.tagName === 'INPUT' || t.tagName === 'TEXTAREA' || t.isContentEditable))
+            if (isTypingTarget(e.target))
+                return;
+            if (key !== 'r' && (e.metaKey || e.ctrlKey || e.altKey))
                 return;
             e.preventDefault();
+            if (key !== 'r') {
+                // O / L cycle the chips; the store subscription re-previews.
+                if (key === 'o')
+                    useWindowPlacement.getState().cycleType();
+                else
+                    useWindowPlacement.getState().cycleStyle();
+                triggerSFX('sfx:item-rotate');
+                return;
+            }
             sideFlip = !sideFlip;
             triggerSFX('sfx:item-rotate');
             if (lastWallEvent) {
@@ -831,7 +949,40 @@ const WindowTool = () => {
         emitter.on('grid:move', onGridFreeFollow);
         emitter.on('grid:pointerup', onGridPointerUp);
         emitter.on('tool:cancel', onCancel);
+        // Alt turns the corner snap off, and pressing it while hovering says so at once.
+        const onAltToggle = (e) => {
+            // 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 === altDown)
+                return;
+            altDown = held;
+            if (lastWallEvent)
+                onWallHover(lastWallEvent);
+        };
         window.addEventListener('keydown', onKeyDown);
+        window.addEventListener('keydown', onAltToggle);
+        window.addEventListener('keyup', onAltToggle);
+        // A chip changed (key or click): the draft takes the new type and style, then re-previews.
+        const unsubscribePlacement = useWindowPlacement.subscribe(() => {
+            const draft = draftRef.current;
+            if (draft) {
+                useScene.getState().updateNode(draft.id, placedWindowFields());
+                const live = useScene.getState().nodes[draft.id];
+                if (live?.type === 'window')
+                    draftRef.current = live;
+            }
+            const parent = draft?.parentId ? useScene.getState().nodes[draft.parentId] : null;
+            if (lastWallEvent)
+                onWallHover(lastWallEvent);
+            else if (lastDormerEvent)
+                onDormerHover(lastDormerEvent);
+            else if (parent)
+                publishDraftPreview(parent);
+            else if (lastFloorPoint)
+                showGhostAt(lastFloorPoint.pos, lastFloorPoint.floorY);
+        });
         // Placement tracks the cursor through wall events; keep walls hidden by
         // the wall-mode pass (X-ray 'down' mode) pointer-targetable while the
         // tool is active so a new window still snaps onto them (see the wall
@@ -839,7 +990,10 @@ const WindowTool = () => {
         const releaseHiddenWallHold = holdHiddenWallPointerEvents();
         return () => {
             destroyDraft();
+            for (const end of draftHistoryEnds.values())
+                end();
             hideCursor();
+            resetCorner();
             clearPlacementPreview();
             useAlignmentGuides.getState().clear();
             clearOpeningGuides3D();
@@ -866,6 +1020,9 @@ const WindowTool = () => {
             emitter.off('grid:pointerup', onGridPointerUp);
             emitter.off('tool:cancel', onCancel);
             window.removeEventListener('keydown', onKeyDown);
+            window.removeEventListener('keydown', onAltToggle);
+            window.removeEventListener('keyup', onAltToggle);
+            unsubscribePlacement();
         };
     }, [activeLevelId, isCameraDragging, selectNode]);
     // Cursor geometry: window outline rectangle. Static dims, so build it once and

package/dist/window/window-math.d.ts

@@ -1,4 +1,4 @@
-import { type AnyNode, type AnyNodeId, type WallNode } from '@pascal-app/core';
+import { type WallNode } from '@pascal-app/core';
 /**
  * Default sill height (metres from the floor to the BOTTOM of a window) for a
  * fresh window that has no wall-face height yet — the off-wall ghost and the
@@ -8,28 +8,20 @@ import { type AnyNode, type AnyNodeId, type WallNode } from '@pascal-app/core';
  */
 export declare const DEFAULT_WINDOW_SILL_M = 0.5;
 /**
- * Converts wall-local (X along wall, Y = height above wall base) to world XYZ.
+ * Converts wall-local (X along wall, Y = height above wall base, Z = offset
+ * from the wall centre plane along its normal) to world XYZ.
  * Wall XZ uses level-local coordinates (levels only offset in Y, not XZ).
  * Pass levelYOffset (the level group's current world Y) and slabElevation (the
  * wall mesh's Y within the level group) so the cursor lands at the correct world
  * height — matching how WallSystem positions the wall mesh at slabElevation.
  */
-export declare function wallLocalToWorld(wallNode: WallNode, localX: number, localY: number, levelYOffset?: number, slabElevation?: number): [number, number, number];
-/**
- * Clamps window center position so it stays fully within wall bounds. The Y
- * ceiling is the wall's RESOLVED top (storey plane for plane-bound walls,
- * stored height for explicit ones, minus the elected slab base) — `nodes` is
- * required because a plane-bound wall's top lives on its level, not on the
- * wall record.
- */
-export declare function clampToWall(wallNode: WallNode, localX: number, localY: number, width: number, height: number, nodes: Readonly<Record<AnyNodeId, AnyNode>>): {
-    clampedX: number;
-    clampedY: number;
-};
+export declare function wallLocalToWorld(wallNode: WallNode, localX: number, localY: number, levelYOffset?: number, slabElevation?: number, localZ?: number): [number, number, number];
+/** Window centre on its wall and under its ceiling: the shared rule in core (`clampWindowToWall`). */
+export { clampWindowToWall as clampToWall } from '@pascal-app/core/building';
 /**
  * Wall-child overlap is shared by door + window placement (one source of
  * truth in `shared/wall-attach-target.ts`). Re-exported here so existing
  * `./window-math` importers don't change.
  */
-export { hasWallChildOverlap } from '../shared/wall-attach-target';
+export { hasWallChildOverlap } from '../shared/wall-attach-target.js';
 //# sourceMappingURL=window-math.d.ts.map

package/dist/window/window-math.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"window-math.d.ts","sourceRoot":"","sources":["../../src/window/window-math.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAId,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAGzB;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,MAAM,CAAA;AAExC;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,YAAY,SAAI,EAChB,aAAa,SAAI,GAChB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAI1B;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CACzB,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,GAC1C;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAQxC;AAED;;;;GAIG;AACH,OAAO,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAA"}
+{"version":3,"file":"window-math.d.ts","sourceRoot":"","sources":["../../src/window/window-math.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAEzB;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,MAAM,CAAA;AAExC;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,YAAY,SAAI,EAChB,aAAa,SAAI,EACjB,MAAM,SAAI,GACT,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAW1B;AAED,sGAAsG;AACtG,OAAO,EAAE,iBAAiB,IAAI,WAAW,EAAE,MAAM,2BAA2B,CAAA;AAE5E;;;;GAIG;AACH,OAAO,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAA"}

package/dist/window/window-math.js

@@ -1,5 +1,4 @@
-import { getCurtainWallConfig, getWallCurveFrameAt, getWallCurveLength, } from '@pascal-app/core';
-import { resolveWallOpeningCeiling } from '../shared/wall-opening-ceiling';
+import { getWallBodyCenterOffset, getWallCurveFrameAt, getWallCurveLength, } from '@pascal-app/core';
 /**
  * Default sill height (metres from the floor to the BOTTOM of a window) for a
  * fresh window that has no wall-face height yet — the off-wall ghost and the
@@ -9,35 +8,30 @@ import { resolveWallOpeningCeiling } from '../shared/wall-opening-ceiling';
  */
 export const DEFAULT_WINDOW_SILL_M = 0.5;
 /**
- * Converts wall-local (X along wall, Y = height above wall base) to world XYZ.
+ * Converts wall-local (X along wall, Y = height above wall base, Z = offset
+ * from the wall centre plane along its normal) to world XYZ.
  * Wall XZ uses level-local coordinates (levels only offset in Y, not XZ).
  * Pass levelYOffset (the level group's current world Y) and slabElevation (the
  * wall mesh's Y within the level group) so the cursor lands at the correct world
  * height — matching how WallSystem positions the wall mesh at slabElevation.
  */
-export function wallLocalToWorld(wallNode, localX, localY, levelYOffset = 0, slabElevation = 0) {
+export function wallLocalToWorld(wallNode, localX, localY, levelYOffset = 0, slabElevation = 0, localZ = 0) {
     const wallLength = getWallCurveLength(wallNode);
     const frame = getWallCurveFrameAt(wallNode, wallLength > 1e-6 ? localX / wallLength : 0);
-    return [frame.point.x, slabElevation + localY + levelYOffset, frame.point.y];
-}
-/**
- * Clamps window center position so it stays fully within wall bounds. The Y
- * ceiling is the wall's RESOLVED top (storey plane for plane-bound walls,
- * stored height for explicit ones, minus the elected slab base) — `nodes` is
- * required because a plane-bound wall's top lives on its level, not on the
- * wall record.
- */
-export function clampToWall(wallNode, localX, localY, width, height, nodes) {
-    const wallLength = getWallCurveLength(wallNode);
-    const wallHeight = resolveWallOpeningCeiling(wallNode, nodes);
-    const margin = wallNode.wallType === 'curtain' ? getCurtainWallConfig(wallNode).perimeterWidth : 0;
-    const clampedX = Math.max(margin + width / 2, Math.min(wallLength - margin - width / 2, localX));
-    const clampedY = Math.max(margin + height / 2, Math.min(wallHeight - margin - height / 2, localY));
-    return { clampedX, clampedY };
+    // `localZ` is measured from the body's centre plane, which a justified wall
+    // sets off its reference line.
+    const across = getWallBodyCenterOffset(wallNode) + localZ;
+    return [
+        frame.point.x + frame.normal.x * across,
+        slabElevation + localY + levelYOffset,
+        frame.point.y + frame.normal.y * across,
+    ];
 }
+/** Window centre on its wall and under its ceiling: the shared rule in core (`clampWindowToWall`). */
+export { clampWindowToWall as clampToWall } from '@pascal-app/core/building';
 /**
  * Wall-child overlap is shared by door + window placement (one source of
  * truth in `shared/wall-attach-target.ts`). Re-exported here so existing
  * `./window-math` importers don't change.
  */
-export { hasWallChildOverlap } from '../shared/wall-attach-target';
+export { hasWallChildOverlap } from '../shared/wall-attach-target.js';

package/dist/zone/contextual-dimensions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"contextual-dimensions.d.ts","sourceRoot":"","sources":["../../src/zone/contextual-dimensions.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAEpB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAGzB,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAc1B"}
+{"version":3,"file":"contextual-dimensions.d.ts","sourceRoot":"","sources":["../../src/zone/contextual-dimensions.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAEpB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAGzB,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAgB1B"}

package/dist/zone/contextual-dimensions.js

@@ -1,10 +1,13 @@
-import { resolveAutoZonePolygon, } from '@pascal-app/core';
+import { area as footprintArea, polygonInteriorPoint, } from '@pascal-app/core';
 import { formatAreaLabel } from '@pascal-app/editor';
 export function buildZoneContextualDimensions(node, ctx) {
-    const polygon = resolveAutoZonePolygon(node, ctx.resolve);
+    if (node.autoFromWalls && node.enclosureStatus === 'open')
+        return null;
+    const polygon = node.polygon;
     if (polygon.length < 3)
         return null;
-    const { area, centroid } = polygonAreaAndCentroid(polygon);
+    const area = footprintArea([{ outer: polygon, holes: node.holes ?? [] }]);
+    const centroid = polygonInteriorPoint(node, true);
     if (area <= 1e-6)
         return null;
     return {
@@ -16,28 +19,3 @@ export function buildZoneContextualDimensions(node, ctx) {
         angle: 0,
     };
 }
-function polygonAreaAndCentroid(points) {
-    let twiceSignedArea = 0;
-    let weightedX = 0;
-    let weightedY = 0;
-    for (let index = 0; index < points.length; index += 1) {
-        const current = points[index];
-        const next = points[(index + 1) % points.length];
-        const cross = current[0] * next[1] - next[0] * current[1];
-        twiceSignedArea += cross;
-        weightedX += (current[0] + next[0]) * cross;
-        weightedY += (current[1] + next[1]) * cross;
-    }
-    const area = Math.abs(twiceSignedArea) / 2;
-    if (Math.abs(twiceSignedArea) <= 1e-9) {
-        const sum = points.reduce((acc, point) => [acc[0] + point[0], acc[1] + point[1]], [0, 0]);
-        return {
-            area,
-            centroid: [sum[0] / points.length, sum[1] / points.length],
-        };
-    }
-    return {
-        area,
-        centroid: [weightedX / (3 * twiceSignedArea), weightedY / (3 * twiceSignedArea)],
-    };
-}