@pascal-app/nodes 0.1.1

package/dist/window/system.js

@@ -0,0 +1,16 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { WindowAnimationSystem, WindowSystem } from '@pascal-app/viewer';
+/**
+ * Registry-driven window system bundle.
+ *
+ *  - **`WindowSystem`** — rebuilds frame / sash / divider / sill /
+ *    muntin geometry. Cascades dirty to parent wall for the cutout.
+ *  - **`WindowAnimationSystem`** — advances sash/panel open state at
+ *    frame priority 2, then marks the window dirty for the geometry
+ *    rebuild at priority 3.
+ */
+const WindowSystems = () => {
+    return (_jsxs(_Fragment, { children: [_jsx(WindowAnimationSystem, {}), _jsx(WindowSystem, {})] }));
+};
+export default WindowSystems;

package/dist/window/tool.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Window tool — places WindowNodes on walls and on roof-segment wall
+ * faces (the generated base walls under a roof, including coplanar gable
+ * ends — a window can sit in the gable pediment).
+ *
+ * The ghost follows the cursor everywhere (like moving an item): over open
+ * floor it floats as an invalid (unplaceable) ghost; the moment the cursor ray
+ * hovers a wall (or roof-segment face) the real draft snaps onto it. Snapping
+ * engages only on an actual mesh hover — no proximity magnet.
+ */
+declare const WindowTool: React.FC;
+export default WindowTool;
+//# sourceMappingURL=tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/window/tool.tsx"],"names":[],"mappings":"AA6EA;;;;;;;;;GASG;AACH,QAAA,MAAM,UAAU,EAAE,KAAK,CAAC,EAuqBvB,CAAA;AAED,eAAe,UAAU,CAAA"}

package/dist/window/tool.js

@@ -0,0 +1,580 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { emitter, isCurvedWall, sceneRegistry, spatialGridManager, useScene, WindowNode, } from '@pascal-app/core';
+import { calculateCursorRotation, calculateItemRotation, EDITOR_LAYER, getSideFromNormal, isMagneticSnapActive, isValidWallSideFace, snapToHalf, triggerSFX, useAlignmentGuides, useEditor, useFacingPose, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { useEffect, useMemo, useRef, useState } from 'react';
+import { BoxGeometry, EdgesGeometry, Vector3 } from 'three';
+import { LineBasicNodeMaterial } from 'three/webgpu';
+import { clearOpeningGuides3D, publishOpeningGuidesForWallEvent, resolveSillSnap, } from '../shared/opening-guides-runtime';
+import { getRoofWallOpeningCursorPose, resolveRoofWallOpeningTarget, worldToSelectedBuildingLocal, } from '../shared/roof-wall-opening-placement';
+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';
+// Shared edge material — reuse across renders, just toggle color
+const edgeMaterial = new LineBasicNodeMaterial({
+    color: 0xef_44_44, // red-500 default (invalid)
+    linewidth: 3,
+    depthTest: false,
+    depthWrite: false,
+});
+const FALLBACK_WIDTH = 1.5;
+const FALLBACK_HEIGHT = 1.5;
+// Off-wall ghost lift = the default sill, so the floating preview matches the
+// sill the floor-cursor placement commits at.
+const FALLBACK_SILL_LIFT = DEFAULT_WINDOW_SILL_M;
+// Default sill centre for a window snapped from the floor (the floor cursor
+// carries no wall-face height): the default sill + half the default height.
+const DEFAULT_SILL_CENTER_Y = DEFAULT_WINDOW_SILL_M + FALLBACK_HEIGHT / 2;
+const roofFallbackPoint = new Vector3();
+/**
+ * Window tool — places WindowNodes on walls and on roof-segment wall
+ * faces (the generated base walls under a roof, including coplanar gable
+ * ends — a window can sit in the gable pediment).
+ *
+ * The ghost follows the cursor everywhere (like moving an item): over open
+ * floor it floats as an invalid (unplaceable) ghost; the moment the cursor ray
+ * hovers a wall (or roof-segment face) the real draft snaps onto it. Snapping
+ * engages only on an actual mesh hover — no proximity magnet.
+ */
+const WindowTool = () => {
+    const draftRef = useRef(null);
+    const cursorGroupRef = useRef(null);
+    const edgesRef = useRef(null);
+    // Off-host floating ghost: the real window geometry follows the cursor
+    // over the grid (tinted invalid). Mutually exclusive with the on-host draft.
+    // `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 ghostStub = useMemo(() => WindowNode.parse({
+        position: [0, 0, 0],
+        rotation: [0, 0, 0],
+        side: fallbackPose?.side ?? 'front',
+    }), [fallbackPose?.side]);
+    // 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();
+        let hostKind = null;
+        // timeStamp of the most recent wall/roof mesh event. A wall/roof hover and
+        // the grid raycast from the SAME pointermove share the source DOM event's
+        // timeStamp, so the grid handler can detect "a mesh handler already owns
+        // this frame" without depending on event order or on a leave firing (node
+        // events are suppressed during a camera drag, so a sticky boolean would
+        // strand the draft after an orbit; a per-frame timestamp self-heals).
+        let lastMeshEventTime = -1;
+        // R flips the window's facing side mid-placement (front ↔ back); re-applied
+        // to the last wall hover so the flip shows live before commit.
+        let sideFlip = false;
+        let lastWallEvent = 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.
+        let lastFloorPoint = null;
+        const getLevelId = () => useViewer.getState().selection.levelId;
+        const getLevelYOffset = () => {
+            const id = getLevelId();
+            return id ? (sceneRegistry.nodes.get(id)?.position.y ?? 0) : 0;
+        };
+        const getSlabElevationForWall = (wall) => spatialGridManager.getSlabElevationForWall(wall.parentId ?? '', wall.start, wall.end);
+        const markHostDirty = (hostId) => {
+            useScene.getState().dirtyNodes.add(hostId);
+        };
+        const destroyDraft = () => {
+            if (!draftRef.current)
+                return;
+            const wallId = draftRef.current.parentId;
+            useScene.getState().deleteNode(draftRef.current.id);
+            draftRef.current = null;
+            // Rebuild wall so it removes the cutout from the deleted draft
+            if (wallId)
+                markHostDirty(wallId);
+        };
+        const hideCursor = () => {
+            if (cursorGroupRef.current)
+                cursorGroupRef.current.visible = false;
+            useAlignmentGuides.getState().clear();
+            clearOpeningGuides3D();
+            setFallbackPose(null);
+            useFacingPose.getState().clear();
+        };
+        // Alignment candidates — anchors of every alignable object; refreshed
+        // after each placement. A window aligns by the plan position of its centre
+        // (along-wall only; the floor-plane guides don't cover sill height).
+        let alignmentCandidates = collectWallOpeningAlignmentCandidates(useScene.getState().nodes, '');
+        // On-host cursor: the green/red wireframe outline tracks a live draft.
+        // Showing it always clears the off-host floating ghost (they never
+        // coexist — a draft means the cursor is on a valid host).
+        const updateCursor = (worldPosition, cursorRotationY, valid, indicatorYOffset) => {
+            setFallbackPose(null);
+            const group = cursorGroupRef.current;
+            if (!group)
+                return;
+            group.visible = true;
+            group.position.set(...worldPosition);
+            group.rotation.y = cursorRotationY;
+            edgeMaterial.color.setHex(valid ? 0x22_c5_5e : 0xef_44_44);
+            // Forward-facing triangle (editor-side overlay). The cursor group is
+            // already yawed so +Z faces out of the wall, so the window's front is +Z.
+            // The indicator rides at the sill (`indicatorYOffset`).
+            useFacingPose.getState().set({
+                position: [worldPosition[0], worldPosition[1] + indicatorYOffset, worldPosition[2]],
+                rotationY: cursorRotationY,
+                depth: frameDepthRef.current,
+            });
+        };
+        // Off-host fallback: hide the wireframe outline and float the real window
+        // geometry (tinted invalid) at the cursor so the armed tool is visible.
+        const showGhostAt = (position, floorY) => {
+            if (cursorGroupRef.current)
+                cursorGroupRef.current.visible = false;
+            lastFloorPoint = { pos: position, floorY };
+            // `sideFlip` (R) flips the facing — back is a π yaw on the floating ghost.
+            setFallbackPose({
+                position,
+                rotationY: sideFlip ? Math.PI : 0,
+                floorY,
+                side: sideFlip ? 'back' : 'front',
+            });
+            useAlignmentGuides.getState().clear();
+            clearOpeningGuides3D();
+            // Off-host (invalid) floating ghost — no direction triangle.
+            useFacingPose.getState().clear();
+        };
+        const showRoofFallbackCursor = (event) => {
+            const [x, , z] = worldToSelectedBuildingLocal(roofFallbackPoint.set(...event.position));
+            showGhostAt([x, getLevelYOffset() + FALLBACK_HEIGHT / 2 + FALLBACK_SILL_LIFT, z], getLevelYOffset());
+        };
+        const showWallFallbackCursor = (event) => {
+            const [x, , z] = worldToSelectedBuildingLocal(roofFallbackPoint.set(...event.position));
+            showGhostAt([x, getLevelYOffset() + FALLBACK_HEIGHT / 2 + FALLBACK_SILL_LIFT, z], getLevelYOffset());
+        };
+        // Sill alignment (snap + guide): a sibling sill/centre/top wins over the
+        // grid when within threshold — it's the magnetic ("lines") component for the
+        // vertical axis, so it runs only when magnetic snap is on; otherwise the
+        // grid `snapToHalf` (itself mode-aware) decides Y. `movingId` is the draft's
+        // id once it exists (so it's excluded from the sibling scan), or '' before
+        // the draft is created (nothing to exclude yet).
+        const resolvePlacementY = (args) => {
+            const sillY = isMagneticSnapActive()
+                ? resolveSillSnap({
+                    wall: args.wall,
+                    movingId: args.movingId,
+                    localX: args.localX,
+                    localY: args.rawLocalY,
+                    width: args.width,
+                    height: args.height,
+                    nodes: useScene.getState().nodes,
+                })
+                : null;
+            return sillY ?? snapToHalf(args.rawLocalY);
+        };
+        // Settle a wall target: alignment snap → sill clamp → overlap check.
+        const resolveWallPlacement = (wall, rawLocalX, rawLocalY, width, height, applySnap, 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).
+            const localX = resolveWallSlideAlignment({
+                wallNode: wall,
+                rawLocalX,
+                width,
+                candidates: alignmentCandidates,
+                applySnap,
+            });
+            const localY = resolvePlacementY({
+                wall,
+                movingId: ignoreId ?? '',
+                localX,
+                rawLocalY,
+                width,
+                height,
+            });
+            const { clampedX, clampedY } = clampToWall(wall, localX, localY, width, height);
+            const valid = !hasWallChildOverlap(wall.id, clampedX, clampedY, width, height, ignoreId);
+            return { clampedX, clampedY, valid };
+        };
+        // 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 width = draftRef.current?.width ?? 1.5;
+            const height = draftRef.current?.height ?? 1.5;
+            if (!draftRef.current) {
+                const node = WindowNode.parse({
+                    position: [0, DEFAULT_SILL_CENTER_Y, 0],
+                    rotation: [0, itemRotation, 0],
+                    side,
+                    wallId: wall.id,
+                    parentId: wall.id,
+                    metadata: { isTransient: true },
+                });
+                useScene.getState().createNode(node, wall.id);
+                draftRef.current = node;
+            }
+            const { clampedX, clampedY, valid } = resolveWallPlacement(wall, rawLocalX, rawLocalY, width, height, applySnap, draftRef.current.id);
+            if (wall.id === draftRef.current.parentId) {
+                useScene.getState().updateNode(draftRef.current.id, {
+                    position: [clampedX, clampedY, 0],
+                    rotation: [0, itemRotation, 0],
+                    side,
+                });
+                markHostDirty(wall.id);
+            }
+            else {
+                useScene.getState().updateNode(draftRef.current.id, {
+                    position: [clampedX, clampedY, 0],
+                    rotation: [0, itemRotation, 0],
+                    side,
+                    parentId: wall.id,
+                    wallId: wall.id,
+                    // The draft may arrive from a roof-segment face hover.
+                    roofSegmentId: undefined,
+                    roofFace: undefined,
+                });
+            }
+            updateCursor(wallLocalToWorld(wall, clampedX, clampedY, getLevelYOffset(), getSlabElevationForWall(wall)), cursorRotationY, valid, -clampedY);
+            if (draftRef.current) {
+                publishOpeningGuidesForWallEvent({
+                    wall,
+                    movingId: draftRef.current.id,
+                    centerS: clampedX,
+                    centerY: clampedY,
+                    width,
+                    height,
+                    includeVertical: true,
+                    levelYOffset: getLevelYOffset(),
+                    slabElevation: getSlabElevationForWall(wall),
+                });
+            }
+            return { clampedX, clampedY, valid };
+        };
+        // 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 draft = draftRef.current;
+            if (!draft)
+                return;
+            draftRef.current = null;
+            hostKind = null;
+            useScene.getState().deleteNode(draft.id);
+            useScene.temporal.getState().resume();
+            const levelId = getLevelId();
+            const state = useScene.getState();
+            const windowCount = Object.values(state.nodes).filter((n) => {
+                if (n.type !== 'window')
+                    return false;
+                const w = n.parentId ? state.nodes[n.parentId] : undefined;
+                return w?.parentId === levelId;
+            }).length;
+            const node = WindowNode.parse({
+                name: `Window ${windowCount + 1}`,
+                position: [clampedX, clampedY, 0],
+                rotation: [0, itemRotation, 0],
+                side,
+                wallId: wall.id,
+                parentId: wall.id,
+                width: draft.width,
+                height: draft.height,
+                windowType: draft.windowType,
+                operationState: draft.operationState,
+                awningDirection: draft.awningDirection,
+                casementStyle: draft.casementStyle,
+                hingesSide: draft.hingesSide,
+                frameThickness: draft.frameThickness,
+                frameDepth: draft.frameDepth,
+                columnRatios: draft.columnRatios,
+                rowRatios: draft.rowRatios,
+                columnDividerThickness: draft.columnDividerThickness,
+                rowDividerThickness: draft.rowDividerThickness,
+                sill: draft.sill,
+                sillDepth: draft.sillDepth,
+                sillThickness: draft.sillThickness,
+            });
+            useScene.getState().createNode(node, wall.id);
+            useViewer.getState().setSelection({ selectedIds: [node.id] });
+            triggerSFX('sfx:structure-build');
+            useAlignmentGuides.getState().clear();
+            clearOpeningGuides3D();
+            if (useEditor.getState().getContinuation('point') === 'repeat') {
+                useScene.temporal.getState().pause();
+                alignmentCandidates = collectWallOpeningAlignmentCandidates(useScene.getState().nodes, '');
+            }
+            else {
+                hideCursor();
+                useEditor.getState().setTool(null);
+            }
+        };
+        // ── Direct wall-mesh hover ──────────────────────────────────────
+        const onWallHover = (event) => {
+            hostKind = 'wall';
+            lastMeshEventTime = event.nativeEvent?.timeStamp ?? -1;
+            if (!isValidWallSideFace(event.normal) ||
+                isCurvedWall(event.node) ||
+                event.node.parentId !== getLevelId()) {
+                destroyDraft();
+                showWallFallbackCursor(event);
+                return;
+            }
+            lastWallEvent = event;
+            const faceSide = getSideFromNormal(event.normal);
+            const side = sideFlip ? (faceSide === 'front' ? 'back' : 'front') : faceSide;
+            const flipOffset = sideFlip ? Math.PI : 0;
+            const itemRotation = calculateItemRotation(event.normal) + flipOffset;
+            const cursorRotation = calculateCursorRotation(event.normal, event.node.start, event.node.end) + flipOffset;
+            applyWallTarget({
+                wall: event.node,
+                rawLocalX: event.localPosition[0],
+                rawLocalY: event.localPosition[1],
+                side,
+                itemRotation,
+                cursorRotationY: cursorRotation,
+                applySnap: isMagneticSnapActive(),
+            });
+            event.stopPropagation();
+        };
+        const onWallClick = (event) => {
+            if (!draftRef.current)
+                return;
+            if (!isValidWallSideFace(event.normal) ||
+                isCurvedWall(event.node) ||
+                event.node.parentId !== getLevelId()) {
+                return;
+            }
+            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);
+            // 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);
+            event.stopPropagation();
+        };
+        const onWallLeave = () => {
+            if (hostKind !== 'wall')
+                return;
+            lastWallEvent = null;
+            destroyDraft();
+            hideCursor();
+            hostKind = null;
+        };
+        // ── Floor free-follow ───────────────────────────────────────────
+        // Over open floor the ghost follows the cursor like a moving item. It does
+        // NOT snap from proximity — snapping engages only when the cursor ray
+        // actually hovers a wall (onWallHover) or roof face (onRoofHover).
+        const onGridFreeFollow = (event) => {
+            if (useViewer.getState().cameraDragging)
+                return;
+            // A wall/roof mesh handler processed this pointermove (shared DOM
+            // timeStamp) — it owns the frame and has snapped the draft, so skip the
+            // floor follow this tick.
+            const ts = event.nativeEvent?.timeStamp ?? -1;
+            if (ts === lastMeshEventTime)
+                return;
+            // Fresh floor-only frame: the cursor is off any wall/roof. Drop any draft
+            // and free-follow the cursor with the invalid (unplaceable) ghost.
+            hostKind = null;
+            lastWallEvent = null;
+            const [x, y, z] = event.localPosition;
+            destroyDraft();
+            showGhostAt([x, y + FALLBACK_HEIGHT / 2 + FALLBACK_SILL_LIFT, z], y);
+        };
+        // ── Roof-segment wall faces ─────────────────────────────────────
+        // The merged roof mesh emits `roof:*`; hits are resolved against the
+        // segments' vertical wall faces (base walls + coplanar gable ends),
+        // so a window can sit anywhere inside the face profile — including
+        // the gable pediment triangle.
+        const resolveRoofTarget = (event) => resolveRoofWallOpeningTarget({
+            event,
+            width: draftRef.current?.width ?? 1.5,
+            height: draftRef.current?.height ?? 1.5,
+            ignoreId: draftRef.current?.id,
+            vertical: {
+                kind: 'free',
+                // `snapToHalf` is mode-aware (raw cursor when grid snap is off).
+                snap: snapToHalf,
+            },
+        });
+        const updateRoofCursor = (target, roof) => {
+            const pose = getRoofWallOpeningCursorPose(target, roof);
+            if (pose)
+                updateCursor(pose.position, pose.rotationY, target.valid, -target.position[1]);
+        };
+        const onRoofHover = (event) => {
+            hostKind = 'roof';
+            lastMeshEventTime = event.nativeEvent?.timeStamp ?? -1;
+            const target = resolveRoofTarget(event);
+            if (!target) {
+                // On the roof but not over a placeable wall face (slope, soffit,
+                // or a face the window cannot fit on).
+                destroyDraft();
+                showRoofFallbackCursor(event);
+                return;
+            }
+            const { segment, face, position } = target;
+            if (draftRef.current && draftRef.current.parentId !== segment.id)
+                destroyDraft();
+            if (draftRef.current) {
+                useScene.getState().updateNode(draftRef.current.id, {
+                    position,
+                    rotation: [0, 0, 0],
+                    roofFace: face.id,
+                });
+            }
+            else {
+                const node = WindowNode.parse({
+                    position,
+                    rotation: [0, 0, 0],
+                    side: 'front',
+                    roofSegmentId: segment.id,
+                    roofFace: face.id,
+                    parentId: segment.id,
+                    metadata: { isTransient: true },
+                });
+                useScene.getState().createNode(node, segment.id);
+                draftRef.current = node;
+            }
+            // Opening guides are wall-specific; clear them while over a roof face.
+            clearOpeningGuides3D();
+            updateRoofCursor(target, event.node);
+            event.stopPropagation();
+        };
+        const onRoofClick = (event) => {
+            if (!draftRef.current?.roofSegmentId)
+                return;
+            const target = resolveRoofTarget(event);
+            // Alt force-places over a colliding roof-face target (see onWallClick).
+            if (!target)
+                return;
+            if (!target.valid && event.nativeEvent?.altKey !== true)
+                return;
+            const { segment, face, position } = target;
+            const draft = draftRef.current;
+            draftRef.current = null;
+            hostKind = null;
+            useScene.getState().deleteNode(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;
+            const node = WindowNode.parse({
+                name: `Window ${windowCount + 1}`,
+                position,
+                rotation: [0, 0, 0],
+                side: 'front',
+                roofSegmentId: segment.id,
+                roofFace: face.id,
+                parentId: segment.id,
+                width: draft.width,
+                height: draft.height,
+                windowType: draft.windowType,
+                operationState: draft.operationState,
+                awningDirection: draft.awningDirection,
+                casementStyle: draft.casementStyle,
+                hingesSide: draft.hingesSide,
+                frameThickness: draft.frameThickness,
+                frameDepth: draft.frameDepth,
+                columnRatios: draft.columnRatios,
+                rowRatios: draft.rowRatios,
+                columnDividerThickness: draft.columnDividerThickness,
+                rowDividerThickness: draft.rowDividerThickness,
+                sill: draft.sill,
+                sillDepth: draft.sillDepth,
+                sillThickness: draft.sillThickness,
+            });
+            useScene.getState().createNode(node, segment.id);
+            // Rebuild the segment (and the merged roof) so the wall brush
+            // picks up the new opening cut.
+            useScene.getState().dirtyNodes.add(segment.id);
+            useViewer.getState().setSelection({ selectedIds: [node.id] });
+            triggerSFX('sfx:structure-build');
+            if (useEditor.getState().getContinuation('point') === 'repeat') {
+                useScene.temporal.getState().pause();
+            }
+            else {
+                hideCursor();
+                useEditor.getState().setTool(null);
+            }
+            event.stopPropagation();
+        };
+        const onRoofLeave = () => {
+            if (hostKind !== 'roof')
+                return;
+            destroyDraft();
+            hideCursor();
+            hostKind = null;
+        };
+        const onCancel = () => {
+            destroyDraft();
+            hideCursor();
+            hostKind = null;
+        };
+        // R flips the window's facing side mid-placement (front ↔ back). ALWAYS
+        // toggles the persistent flip intent — never a no-op (the old `!lastWallEvent`
+        // 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')
+                return;
+            if (e.repeat)
+                return;
+            const t = e.target;
+            if (t && (t.tagName === 'INPUT' || t.tagName === 'TEXTAREA' || t.isContentEditable))
+                return;
+            e.preventDefault();
+            sideFlip = !sideFlip;
+            triggerSFX('sfx:item-rotate');
+            if (lastWallEvent) {
+                onWallHover(lastWallEvent);
+            }
+            else if (lastFloorPoint) {
+                showGhostAt(lastFloorPoint.pos, lastFloorPoint.floorY);
+            }
+            // else: no preview yet — `sideFlip` is set, so the first hover/follow uses it.
+        };
+        emitter.on('wall:enter', onWallHover);
+        emitter.on('wall:move', onWallHover);
+        emitter.on('wall:click', onWallClick);
+        emitter.on('wall:leave', onWallLeave);
+        emitter.on('roof:enter', onRoofHover);
+        emitter.on('roof:move', onRoofHover);
+        emitter.on('roof:click', onRoofClick);
+        emitter.on('roof:leave', onRoofLeave);
+        emitter.on('grid:move', onGridFreeFollow);
+        emitter.on('tool:cancel', onCancel);
+        window.addEventListener('keydown', onKeyDown);
+        return () => {
+            destroyDraft();
+            hideCursor();
+            useAlignmentGuides.getState().clear();
+            clearOpeningGuides3D();
+            useScene.temporal.getState().resume();
+            emitter.off('wall:enter', onWallHover);
+            emitter.off('wall:move', onWallHover);
+            emitter.off('wall:click', onWallClick);
+            emitter.off('wall:leave', onWallLeave);
+            emitter.off('roof:enter', onRoofHover);
+            emitter.off('roof:move', onRoofHover);
+            emitter.off('roof:click', onRoofClick);
+            emitter.off('roof:leave', onRoofLeave);
+            emitter.off('grid:move', onGridFreeFollow);
+            emitter.off('tool:cancel', onCancel);
+            window.removeEventListener('keydown', onKeyDown);
+        };
+    }, []);
+    // Cursor geometry: window outline rectangle. Static dims, so build it once and
+    // dispose on unmount rather than reallocating (and orphaning) an EdgesGeometry
+    // on every re-render during placement.
+    const edgesGeo = useMemo(() => {
+        const boxGeo = new BoxGeometry(FALLBACK_WIDTH, FALLBACK_HEIGHT, 0.07);
+        const geo = new EdgesGeometry(boxGeo);
+        boxGeo.dispose();
+        return geo;
+    }, []);
+    useEffect(() => () => edgesGeo.dispose(), [edgesGeo]);
+    return (_jsxs(_Fragment, { children: [_jsx("group", { ref: cursorGroupRef, visible: false, children: _jsx("lineSegments", { geometry: edgesGeo, layers: EDITOR_LAYER, material: edgeMaterial, ref: edgesRef }) }), fallbackPose && (_jsx("group", { position: fallbackPose.position, "rotation-y": fallbackPose.rotationY, children: _jsx(WindowPreview, { invalid: true, node: ghostStub }) })), fallbackPose && (_jsx(WindowFloorProjection, { centerX: fallbackPose.position[0], centerY: fallbackPose.position[1], centerZ: fallbackPose.position[2], floorY: fallbackPose.floorY, rotationY: fallbackPose.rotationY, width: FALLBACK_WIDTH }))] }));
+};
+export default WindowTool;

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

@@ -0,0 +1,31 @@
+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
+ * floor-cursor placement use it so a new window floats slightly above the
+ * ground rather than sitting on it. The committed Y is the window's CENTRE, so
+ * callers add `height / 2`. An existing window keeps its own sill.
+ */
+export declare const DEFAULT_WINDOW_SILL_M = 0.5;
+/**
+ * Converts wall-local (X along wall, Y = height above wall base) 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.
+ */
+export declare function clampToWall(wallNode: WallNode, localX: number, localY: number, width: number, height: number): {
+    clampedX: number;
+    clampedY: number;
+};
+/**
+ * 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';
+//# sourceMappingURL=window-math.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"window-math.d.ts","sourceRoot":"","sources":["../../src/window/window-math.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAEhD;;;;;;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,CAU1B;AAED;;GAEG;AACH,wBAAgB,WAAW,CACzB,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CASxC;AAED;;;;GAIG;AACH,OAAO,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAA"}