@pascal-app/nodes 0.1.1

package/dist/shared/move-roof-tool.js

@@ -0,0 +1,420 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { collectAlignmentAnchors, emitter, movingAlignmentAnchors, nodeRegistry, resolveAlignment, sceneRegistry, useLiveNodeOverrides, useLiveTransforms, useScene, } from '@pascal-app/core';
+import { CursorSphere, commitFreshPlacementSubtree, consumePlacementDragRelease, DragBoundingBox, getFloorStackPreviewPosition, isMagneticSnapActive, resolvePlanarCursorPosition, snapFenceDraftPoint, stripPlacementMetadataFlags, triggerSFX, useAlignmentGuides, useEditor, useFreshPlacementVisibility, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { useCallback, useEffect, useRef, useState } from 'react';
+import * as THREE from 'three';
+/** Figma-style alignment-snap threshold (meters), matching the other tools. */
+const ALIGNMENT_THRESHOLD_M = 0.08;
+function disableRaycastDuringDrag(root) {
+    if (!root)
+        return () => { };
+    const originals = [];
+    root.traverse((child) => {
+        originals.push([child, child.raycast]);
+        child.raycast = () => { };
+    });
+    return () => {
+        for (const [child, raycast] of originals) {
+            child.raycast = raycast;
+        }
+    };
+}
+function resolvePreviewRotationY(node, localRotation) {
+    if ((node.type === 'roof-segment' || node.type === 'stair-segment') && node.parentId) {
+        const parentNode = useScene.getState().nodes[node.parentId];
+        const parentRotation = parentNode && 'rotation' in parentNode && typeof parentNode.rotation === 'number'
+            ? parentNode.rotation
+            : 0;
+        return parentRotation + localRotation;
+    }
+    return localRotation;
+}
+export const MoveRoofTool = ({ node: movingNode }) => {
+    const { isFreshPlacement, previewVisible: cursorVisible, revealFreshPlacement, useAbsoluteCursorPlacement, } = useFreshPlacementVisibility({
+        node: movingNode,
+        enabled: movingNode.type === 'roof' || movingNode.type === 'stair',
+    });
+    const exitMoveMode = useCallback(() => {
+        useEditor.getState().setMovingNode(null);
+    }, []);
+    const previousGridPosRef = useRef(null);
+    const dragAnchorRef = useRef(null);
+    const [previewRotation, setPreviewRotation] = useState(() => resolvePreviewRotationY(movingNode, movingNode.rotation));
+    const [cursorWorldPos, setCursorWorldPos] = useState(() => {
+        const obj = sceneRegistry.nodes.get(movingNode.id);
+        if (obj) {
+            const worldPos = obj.getWorldPosition(new THREE.Vector3());
+            // Cursor renders inside the building-local ToolManager group, so convert
+            // world → building-local to honor any building rotation.
+            const buildingId = useViewer.getState().selection.buildingId;
+            const buildingObj = buildingId ? sceneRegistry.nodes.get(buildingId) : null;
+            if (buildingObj)
+                buildingObj.worldToLocal(worldPos);
+            return [worldPos.x, worldPos.y, worldPos.z];
+        }
+        // Fallback if not registered (e.g. newly created duplicate without mesh yet)
+        if ((movingNode.type === 'roof-segment' || movingNode.type === 'stair-segment') &&
+            movingNode.parentId) {
+            const parentNode = useScene.getState().nodes[movingNode.parentId];
+            if (parentNode && 'position' in parentNode && 'rotation' in parentNode) {
+                const parentAngle = parentNode.rotation;
+                const px = parentNode.position[0];
+                const py = parentNode.position[1];
+                const pz = parentNode.position[2];
+                const lx = movingNode.position[0];
+                const ly = movingNode.position[1];
+                const lz = movingNode.position[2];
+                const wx = lx * Math.cos(parentAngle) - lz * Math.sin(parentAngle) + px;
+                const wz = lx * Math.sin(parentAngle) + lz * Math.cos(parentAngle) + pz;
+                return [wx, py + ly, wz];
+            }
+        }
+        return [movingNode.position[0], movingNode.position[1], movingNode.position[2]];
+    });
+    useEffect(() => {
+        useScene.temporal.getState().pause();
+        dragAnchorRef.current = null;
+        previousGridPosRef.current = null;
+        const isNew = isFreshPlacement;
+        const committedMeta = stripPlacementMetadataFlags(movingNode.metadata);
+        const original = {
+            position: [...movingNode.position],
+            rotation: movingNode.rotation,
+            parentId: movingNode.parentId,
+            metadata: movingNode.metadata,
+        };
+        // Track whether the move was committed so cleanup knows whether to revert.
+        // We avoid setting isTransient on the store to prevent RoofSystem from
+        // resetting the mesh position (it resets on dirty) and from triggering
+        // expensive merged-mesh CSG rebuilds on every frame.
+        let wasCommitted = false;
+        let wasCancelled = false;
+        let hasMoved = false;
+        // Track pending rotation — no store updates during drag
+        let pendingRotation = movingNode.rotation;
+        let lastLocalPosition = [
+            movingNode.position[0],
+            movingNode.position[1],
+            movingNode.position[2],
+        ];
+        const movingObject = sceneRegistry.nodes.get(movingNode.id);
+        const restoreRaycasts = disableRaycastDuringDrag(movingObject);
+        const syncHostedPreview = (patch) => {
+            if (movingNode.type !== 'roof-segment' && movingNode.type !== 'stair-segment')
+                return;
+            useLiveNodeOverrides.getState().set(movingNode.id, patch);
+        };
+        const clearHostedPreview = () => {
+            if (movingNode.type !== 'roof-segment' && movingNode.type !== 'stair-segment')
+                return;
+            useLiveNodeOverrides.getState().clear(movingNode.id);
+        };
+        const resolveLevelId = () => {
+            if (movingNode.type === 'roof' || movingNode.type === 'stair') {
+                return movingNode.parentId ?? null;
+            }
+            if ((movingNode.type === 'roof-segment' || movingNode.type === 'stair-segment') &&
+                movingNode.parentId) {
+                const parentNode = useScene.getState().nodes[movingNode.parentId];
+                return parentNode && 'parentId' in parentNode ? (parentNode.parentId ?? null) : null;
+            }
+            return null;
+        };
+        const levelId = resolveLevelId();
+        const isFloorPlaced = nodeRegistry.get(movingNode.type)?.capabilities?.floorPlaced !== undefined;
+        const getPreviewPosition = (position, rotation = pendingRotation) => {
+            if (!isFloorPlaced)
+                return position;
+            return getFloorStackPreviewPosition({
+                node: movingNode,
+                position,
+                rotation,
+                levelId,
+                nodes: useScene.getState().nodes,
+            });
+        };
+        const levelNode = levelId && useScene.getState().nodes[levelId]?.type === 'level'
+            ? useScene.getState().nodes[levelId]
+            : null;
+        const levelChildren = levelNode?.children ?? [];
+        const levelWalls = levelChildren
+            .map((childId) => useScene.getState().nodes[childId])
+            .filter((node) => node?.type === 'wall');
+        const levelFences = levelChildren
+            .map((childId) => useScene.getState().nodes[childId])
+            .filter((node) => node?.type === 'fence');
+        const buildingId = useViewer.getState().selection.buildingId;
+        const buildingObj = buildingId ? sceneRegistry.nodes.get(buildingId) : null;
+        // Alignment for top-level stair / roof only. Segments live in parent-local
+        // space (a different frame from the building-local candidate pool / guide
+        // layer), so we leave them on the plain grid+corner snap. Both stair and
+        // roof align by their footprint bounding-box corners.
+        const alignTopLevel = movingNode.type === 'stair' || movingNode.type === 'roof';
+        const alignmentCandidates = alignTopLevel
+            ? collectAlignmentAnchors(useScene.getState().nodes, movingNode.id, movingNode.type === 'stair' ? levelId : undefined)
+            : [];
+        const alignLocalPoint = (lx, lz, bypass) => {
+            if (!alignTopLevel || bypass || alignmentCandidates.length === 0) {
+                useAlignmentGuides.getState().clear();
+                return [lx, lz];
+            }
+            const moving = movingNode.type === 'stair' || movingNode.type === 'roof'
+                ? movingAlignmentAnchors(movingNode, useScene.getState().nodes, lx, lz, pendingRotation)
+                : [];
+            const ar = resolveAlignment({
+                moving: moving.length > 0 ? moving : [{ nodeId: movingNode.id, kind: 'corner', x: lx, z: lz }],
+                candidates: alignmentCandidates,
+                threshold: ALIGNMENT_THRESHOLD_M,
+            });
+            useAlignmentGuides.getState().set(ar.guides);
+            return ar.snap && isMagneticSnapActive() ? [lx + ar.snap.dx, lz + ar.snap.dz] : [lx, lz];
+        };
+        const localToWorldPoint = (localPoint, y) => {
+            if (buildingObj) {
+                const worldPoint = buildingObj.localToWorld(new THREE.Vector3(localPoint[0], y, localPoint[1]));
+                return [worldPoint.x, worldPoint.y, worldPoint.z];
+            }
+            return [localPoint[0], y, localPoint[1]];
+        };
+        const computeLocal = (gridX, gridZ, y, buildingLocalX, buildingLocalZ) => {
+            // Segments have a transformed parent (stair/roof). Convert world → parent-local
+            // via Three.js hierarchy so the segment's stored position stays parent-relative.
+            if ((movingNode.type === 'roof-segment' || movingNode.type === 'stair-segment') &&
+                movingNode.parentId) {
+                const parentNode = useScene.getState().nodes[movingNode.parentId];
+                if (parentNode && 'position' in parentNode && 'rotation' in parentNode) {
+                    const parentObj = sceneRegistry.nodes.get(movingNode.parentId);
+                    if (parentObj) {
+                        const worldVec = new THREE.Vector3(gridX, y, gridZ);
+                        parentObj.worldToLocal(worldVec);
+                        return [worldVec.x, worldVec.z];
+                    }
+                    const dx = gridX - parentNode.position[0];
+                    const dz = gridZ - parentNode.position[2];
+                    const angle = -parentNode.rotation;
+                    return [
+                        dx * Math.cos(angle) - dz * Math.sin(angle),
+                        dx * Math.sin(angle) + dz * Math.cos(angle),
+                    ];
+                }
+            }
+            // Stair/roof live directly in the level — their stored position is building-local.
+            // event.localPosition is already building-local, so using it handles building rotation.
+            return [buildingLocalX, buildingLocalZ];
+        };
+        const localPositionToToolLocal = (position) => {
+            if ((movingNode.type === 'roof-segment' || movingNode.type === 'stair-segment') &&
+                movingNode.parentId) {
+                const parentObj = sceneRegistry.nodes.get(movingNode.parentId);
+                if (parentObj) {
+                    const point = parentObj.localToWorld(new THREE.Vector3(...position));
+                    if (buildingObj)
+                        buildingObj.worldToLocal(point);
+                    return [point.x, point.y, point.z];
+                }
+            }
+            return position;
+        };
+        const onGridMove = (event) => {
+            hasMoved = true;
+            revealFreshPlacement();
+            const y = event.position[1];
+            const roofBypassSnap = event.nativeEvent?.shiftKey === true;
+            const snappedLocal = snapFenceDraftPoint({
+                point: [event.localPosition[0], event.localPosition[2]],
+                walls: levelWalls,
+                fences: levelFences,
+                bypassSnap: roofBypassSnap,
+                magnetic: !roofBypassSnap && isMagneticSnapActive(),
+            });
+            const [rawGridX, , rawGridZ] = localToWorldPoint(snappedLocal, y);
+            const [rawLocalX, rawLocalZ] = computeLocal(rawGridX, rawGridZ, y, snappedLocal[0], snappedLocal[1]);
+            const resolved = resolvePlanarCursorPosition({
+                cursor: [rawLocalX, rawLocalZ],
+                original: [movingNode.position[0], movingNode.position[2]],
+                anchor: dragAnchorRef.current,
+                mode: useAbsoluteCursorPlacement ? 'absolute' : 'relative',
+            });
+            dragAnchorRef.current = resolved.anchor;
+            let [localX, localZ] = resolved.point;
+            if (alignTopLevel) {
+                const aligned = alignLocalPoint(localX, localZ, event.nativeEvent?.altKey === true || event.nativeEvent?.shiftKey === true);
+                localX = aligned[0];
+                localZ = aligned[1];
+            }
+            if (event.nativeEvent?.shiftKey !== true &&
+                previousGridPosRef.current &&
+                (localX !== previousGridPosRef.current[0] || localZ !== previousGridPosRef.current[1])) {
+                triggerSFX('sfx:grid-snap');
+            }
+            previousGridPosRef.current = [localX, localZ];
+            lastLocalPosition = [localX, movingNode.position[1], localZ];
+            const previewPosition = getPreviewPosition(lastLocalPosition);
+            setCursorWorldPos(isFloorPlaced ? previewPosition : localPositionToToolLocal(lastLocalPosition));
+            // Directly update the Three.js mesh — no store update during drag
+            const mesh = sceneRegistry.nodes.get(movingNode.id);
+            if (mesh) {
+                if (isFloorPlaced) {
+                    mesh.position.set(...previewPosition);
+                }
+                else {
+                    mesh.position.x = localX;
+                    mesh.position.z = localZ;
+                }
+            }
+            // Publish canonical position so the 2D floorplan can track the drag.
+            // Floor-placed parents (stairs) stay in their committed local frame;
+            // the lifted Y remains presentation-only in the 3D view.
+            useLiveTransforms.getState().set(movingNode.id, {
+                position: lastLocalPosition,
+                rotation: pendingRotation,
+            });
+            syncHostedPreview({
+                position: lastLocalPosition,
+                rotation: pendingRotation,
+            });
+        };
+        const onGridClick = (event) => {
+            if (wasCommitted)
+                return;
+            if (!hasMoved)
+                return;
+            const [localX, , localZ] = lastLocalPosition;
+            useAlignmentGuides.getState().clear();
+            wasCommitted = true;
+            let committedId = movingNode.id;
+            if (isNew) {
+                committedId =
+                    commitFreshPlacementSubtree(movingNode.id, {
+                        position: [localX, movingNode.position[1], localZ],
+                        rotation: pendingRotation,
+                        metadata: committedMeta,
+                        visible: true,
+                    }) ?? committedId;
+            }
+            else {
+                // The store still holds the original values (we didn't update during drag).
+                // Resume temporal and apply the final state as a single undoable step.
+                useScene.temporal.getState().resume();
+                useScene.getState().updateNode(movingNode.id, {
+                    position: [localX, movingNode.position[1], localZ],
+                    rotation: pendingRotation,
+                    metadata: committedMeta,
+                });
+                useScene.temporal.getState().pause();
+            }
+            triggerSFX('sfx:item-place');
+            useViewer.getState().setSelection({ selectedIds: [committedId] });
+            clearHostedPreview();
+            useLiveTransforms.getState().clear(movingNode.id);
+            useEditor.getState().setMovingNodeOrigin('3d');
+            exitMoveMode();
+            event.nativeEvent?.stopPropagation?.();
+        };
+        const onPlacementDragPointerUp = (event) => {
+            if (!consumePlacementDragRelease(event))
+                return;
+            onGridClick({ nativeEvent: event });
+        };
+        const onCancel = () => {
+            wasCancelled = true;
+            clearHostedPreview();
+            useLiveTransforms.getState().clear(movingNode.id);
+            useAlignmentGuides.getState().clear();
+            if (isNew) {
+                useScene.getState().deleteNode(movingNode.id);
+            }
+            else {
+                useScene.getState().updateNode(movingNode.id, {
+                    position: original.position,
+                    rotation: original.rotation,
+                    metadata: original.metadata,
+                });
+            }
+            useScene.temporal.getState().resume();
+            exitMoveMode();
+        };
+        const onKeyDown = (event) => {
+            if (event.target instanceof HTMLInputElement || event.target instanceof HTMLTextAreaElement) {
+                return;
+            }
+            const ROTATION_STEP = Math.PI / 4;
+            let rotationDelta = 0;
+            if (event.key === 'r' || event.key === 'R')
+                rotationDelta = ROTATION_STEP;
+            else if (event.key === 't' || event.key === 'T')
+                rotationDelta = -ROTATION_STEP;
+            if (rotationDelta !== 0) {
+                event.preventDefault();
+                triggerSFX('sfx:item-rotate');
+                pendingRotation += rotationDelta;
+                setPreviewRotation(resolvePreviewRotationY(movingNode, pendingRotation));
+                // Directly update the Three.js mesh — no store update during drag
+                const mesh = sceneRegistry.nodes.get(movingNode.id);
+                if (mesh) {
+                    mesh.rotation.y = pendingRotation;
+                    if (isFloorPlaced) {
+                        const previewPosition = getPreviewPosition(lastLocalPosition, pendingRotation);
+                        mesh.position.set(...previewPosition);
+                        setCursorWorldPos(previewPosition);
+                    }
+                }
+                // Update live transform rotation for 2D floorplan
+                const currentLive = useLiveTransforms.getState().get(movingNode.id);
+                if (currentLive) {
+                    useLiveTransforms.getState().set(movingNode.id, {
+                        ...currentLive,
+                        rotation: pendingRotation,
+                    });
+                }
+                syncHostedPreview({
+                    position: lastLocalPosition,
+                    rotation: pendingRotation,
+                });
+            }
+        };
+        emitter.on('grid:move', onGridMove);
+        emitter.on('grid:click', onGridClick);
+        emitter.on('tool:cancel', onCancel);
+        window.addEventListener('keydown', onKeyDown);
+        window.addEventListener('pointerup', onPlacementDragPointerUp);
+        return () => {
+            restoreRaycasts();
+            // Clear ephemeral live transform + any alignment guides
+            clearHostedPreview();
+            useLiveTransforms.getState().clear(movingNode.id);
+            useAlignmentGuides.getState().clear();
+            // Skip restore when the 2D floor-plan overlay claimed teardown
+            // ownership — same contract `FloorplanRegistryMoveOverlay` uses to
+            // decide whether to revert its own apply() writes. Without this,
+            // a stair / roof move committed in the floor plan unmounts this
+            // tool with `wasCommitted === false` (this tool's own grid-click
+            // never fired), and the restore below stomps the just-committed
+            // position back to the snapshot.
+            const finalisedBy2D = useEditor.getState().movingNodeOrigin === '2d';
+            if (!(wasCommitted || wasCancelled || isNew || finalisedBy2D)) {
+                useScene.getState().updateNode(movingNode.id, {
+                    position: original.position,
+                    rotation: original.rotation,
+                    metadata: original.metadata,
+                });
+            }
+            useScene.temporal.getState().resume();
+            emitter.off('grid:move', onGridMove);
+            emitter.off('grid:click', onGridClick);
+            emitter.off('tool:cancel', onCancel);
+            window.removeEventListener('keydown', onKeyDown);
+            window.removeEventListener('pointerup', onPlacementDragPointerUp);
+        };
+    }, [movingNode, exitMoveMode, isFreshPlacement, revealFreshPlacement, useAbsoluteCursorPlacement]);
+    // Show the same green drag box for both top-level roofs/stairs and their
+    // segments. Segment cursor positions are converted into the tool's
+    // building-local frame above, so the box can now ride the cursor correctly.
+    const showBoundingBox = movingNode.type === 'stair' ||
+        movingNode.type === 'roof' ||
+        movingNode.type === 'roof-segment' ||
+        movingNode.type === 'stair-segment';
+    return (_jsxs("group", { visible: cursorVisible, children: [_jsx(CursorSphere, { position: cursorWorldPos, showTooltip: false }), showBoundingBox && (_jsx(DragBoundingBox, { nodeId: movingNode.id, position: cursorWorldPos, rotationY: previewRotation }))] }));
+};
+export default MoveRoofTool;

package/dist/shared/opening-guides-runtime.d.ts

@@ -0,0 +1,70 @@
+import { type AnyNode, type OpeningSpan, type WallNode } from '@pascal-app/core';
+/** Maps a wall-local point (s along the wall, y above the wall base) to the move
+ *  tool's render frame — the caller passes its own `wallLocalToWorld` closure so
+ *  the guides land in exactly the same (building-local) frame as the drag cursor. */
+type ToWorld = (s: number, y: number) => [number, number, number];
+/** The moving opening's same-wall neighbours, as wall-local spans. */
+export declare function collectOpeningSiblings(wall: WallNode, movingId: string, nodes: Record<string, AnyNode>): OpeningSpan[];
+/**
+ * Vertical sill/centre/top snap for a window — the chosen "snap + guide"
+ * behaviour. Returns the snapped wall-local Y when a sibling sill/centre/top is
+ * within threshold, else null so the caller falls back to the grid. Mirrors
+ * `snapLocalXToNeighbors` on the vertical axis.
+ */
+export declare function resolveSillSnap(args: {
+    wall: WallNode;
+    movingId: string;
+    localX: number;
+    localY: number;
+    width: number;
+    height: number;
+    nodes: Record<string, AnyNode>;
+}): number | null;
+/** Compute and publish the 3D opening guides for the current drag tick. */
+export declare function publishOpeningGuides3D(args: {
+    wall: WallNode;
+    movingId: string;
+    centerS: number;
+    centerY: number;
+    width: number;
+    height: number;
+    includeVertical: boolean;
+    toWorld: ToWorld;
+    nodes: Record<string, AnyNode>;
+}): void;
+export declare function clearOpeningGuides3D(): void;
+/** Like {@link makeWallToWorld} but derives the level Y + slab elevation from the
+ *  scene, for callers without a wall event — i.e. the resize handles. */
+export declare function wallToWorld(wall: WallNode): ToWorld;
+/**
+ * Publish 3D opening guides for an opening being placed or moved on a wall via a
+ * wall event. The caller passes the level Y + slab elevation it already computed
+ * for the drag cursor, so the guides share the cursor's frame exactly — the one
+ * place the door/window move + placement tools publish from.
+ */
+export declare function publishOpeningGuidesForWallEvent(args: {
+    wall: WallNode;
+    movingId: string;
+    centerS: number;
+    centerY: number;
+    width: number;
+    height: number;
+    includeVertical: boolean;
+    levelYOffset: number;
+    slabElevation: number;
+}): void;
+/**
+ * Publish 3D opening guides for an opening being RESIZED via a handle arrow.
+ * Resolves the host wall + transform from the scene (no wall event), then reuses
+ * the shared publish. Doors pass `includeVertical: false` (they sit on the
+ * floor); windows pass `true` so a height drag also shows the live sill/head.
+ */
+export declare function publishOpeningResizeGuides(node: {
+    id: string;
+    parentId?: string | null;
+    position: readonly [number, number, number];
+    width: number;
+    height: number;
+}, includeVertical: boolean): void;
+export {};
+//# sourceMappingURL=opening-guides-runtime.d.ts.map

package/dist/shared/opening-guides-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opening-guides-runtime.d.ts","sourceRoot":"","sources":["../../src/shared/opening-guides-runtime.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,KAAK,OAAO,EAIZ,KAAK,WAAW,EAIhB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AASzB;;qFAEqF;AACrF,KAAK,OAAO,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAEjE,sEAAsE;AACtE,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,WAAW,EAAE,CAgBf;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE;IACpC,IAAI,EAAE,QAAQ,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC/B,GAAG,MAAM,GAAG,IAAI,CAchB;AAED,2EAA2E;AAC3E,wBAAgB,sBAAsB,CAAC,IAAI,EAAE;IAC3C,IAAI,EAAE,QAAQ,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,eAAe,EAAE,OAAO,CAAA;IACxB,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC/B,GAAG,IAAI,CA2EP;AAED,wBAAgB,oBAAoB,IAAI,IAAI,CAE3C;AAiBD;yEACyE;AACzE,wBAAgB,WAAW,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CASnD;AAED;;;;;GAKG;AACH,wBAAgB,gCAAgC,CAAC,IAAI,EAAE;IACrD,IAAI,EAAE,QAAQ,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,eAAe,EAAE,OAAO,CAAA;IACxB,YAAY,EAAE,MAAM,CAAA;IACpB,aAAa,EAAE,MAAM,CAAA;CACtB,GAAG,IAAI,CAQP;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE;IACJ,EAAE,EAAE,MAAM,CAAA;IACV,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,QAAQ,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAC3C,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;CACf,EACD,eAAe,EAAE,OAAO,GACvB,IAAI,CAeN"}

package/dist/shared/opening-guides-runtime.js

@@ -0,0 +1,182 @@
+// Runtime glue between the pure `computeOpeningGuides` geometry (core) and the
+// editor's 3D guide store, used by the door/window move + placement tools. Lives
+// in `nodes` (not core) because it talks to the editor store; kept thin so each
+// tool's per-tick hook is a single call.
+import { computeOpeningGuides, detectVerticalAlignment, sceneRegistry, spatialGridManager, useScene, } from '@pascal-app/core';
+import { useOpeningGuides } from '@pascal-app/editor';
+// Parity with `snapLocalXToNeighbors`' along-wall threshold.
+const SILL_SNAP_THRESHOLD_M = 0.08;
+// Hide a dimension that has collapsed to nothing (sill flush to the floor, or
+// head flush to the wall top) so it doesn't render a zero-length "0m" pill.
+const MIN_DIMENSION_M = 0.02;
+/** The moving opening's same-wall neighbours, as wall-local spans. */
+export function collectOpeningSiblings(wall, movingId, nodes) {
+    const out = [];
+    const childIds = Array.isArray(wall.children) ? wall.children : [];
+    for (const childId of childIds) {
+        if (childId === movingId)
+            continue;
+        const node = nodes[childId];
+        if (!node || (node.type !== 'door' && node.type !== 'window'))
+            continue;
+        out.push({
+            id: node.id,
+            centerS: node.position[0],
+            width: node.width,
+            centerY: node.position[1],
+            height: node.height,
+        });
+    }
+    return out;
+}
+/**
+ * Vertical sill/centre/top snap for a window — the chosen "snap + guide"
+ * behaviour. Returns the snapped wall-local Y when a sibling sill/centre/top is
+ * within threshold, else null so the caller falls back to the grid. Mirrors
+ * `snapLocalXToNeighbors` on the vertical axis.
+ */
+export function resolveSillSnap(args) {
+    const siblings = collectOpeningSiblings(args.wall, args.movingId, args.nodes);
+    const match = detectVerticalAlignment({
+        id: args.movingId,
+        centerS: args.localX,
+        width: args.width,
+        centerY: args.localY,
+        height: args.height,
+    }, siblings, SILL_SNAP_THRESHOLD_M);
+    return match ? args.localY + match.snap : null;
+}
+/** Compute and publish the 3D opening guides for the current drag tick. */
+export function publishOpeningGuides3D(args) {
+    const { wall, centerS, centerY, width, toWorld } = args;
+    const wallLength = Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]);
+    const wallHeight = wall.height ?? 2.5;
+    const siblings = collectOpeningSiblings(wall, args.movingId, args.nodes);
+    const guides = computeOpeningGuides({
+        moving: { id: args.movingId, centerS, width, centerY, height: args.height },
+        siblings,
+        wall: { length: wallLength, height: wallHeight },
+        includeVertical: args.includeVertical,
+    });
+    const out = [];
+    // Stable `id`s keyed on the guide's semantic role (not list position) so the
+    // 3D layer can keep a persisting slot's element + `<Html>` pill mounted as the
+    // set churns each tick — see `OpeningGuide3D`.
+    if (guides.sillHead) {
+        if (guides.sillHead.sill > MIN_DIMENSION_M) {
+            out.push({
+                kind: 'dimension',
+                id: 'sill',
+                from: toWorld(centerS, 0),
+                to: toWorld(centerS, guides.sillHead.bottomY),
+                value: guides.sillHead.sill,
+            });
+        }
+        if (guides.sillHead.head > MIN_DIMENSION_M) {
+            out.push({
+                kind: 'dimension',
+                id: 'head',
+                from: toWorld(centerS, guides.sillHead.topY),
+                to: toWorld(centerS, wallHeight),
+                value: guides.sillHead.head,
+            });
+        }
+    }
+    for (const gap of guides.gaps) {
+        out.push({
+            kind: 'dimension',
+            id: `gap:${gap.side}`,
+            from: toWorld(gap.fromS, centerY),
+            to: toWorld(gap.toS, centerY),
+            value: gap.distance,
+        });
+    }
+    if (guides.vertical) {
+        const target = siblings.find((s) => s.id === guides.vertical?.targetId);
+        if (target) {
+            const lo = Math.min(centerS - width / 2, target.centerS - target.width / 2);
+            const hi = Math.max(centerS + width / 2, target.centerS + target.width / 2);
+            out.push({
+                kind: 'align-line',
+                id: 'vertical',
+                from: toWorld(lo, guides.vertical.y),
+                to: toWorld(hi, guides.vertical.y),
+            });
+        }
+    }
+    if (guides.equalSpacing) {
+        const { gap, segments } = guides.equalSpacing;
+        segments.forEach((seg, i) => {
+            out.push({
+                kind: 'badge',
+                id: `spacing:${i}`,
+                at: toWorld((seg.fromS + seg.toS) / 2, centerY),
+                value: gap,
+            });
+        });
+    }
+    useOpeningGuides.getState().set(out);
+}
+export function clearOpeningGuides3D() {
+    useOpeningGuides.getState().clear();
+}
+/** Wall-local (s along the wall, y above the wall base) → the move tool's render
+ *  frame, given the level Y offset + slab elevation. Shared by the wall-event
+ *  publisher (which already has them) and the resize publisher (which derives
+ *  them from the scene). Same frame as `wallLocalToWorld`. */
+function makeWallToWorld(wall, levelYOffset, slabElevation) {
+    const angle = Math.atan2(wall.end[1] - wall.start[1], wall.end[0] - wall.start[0]);
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    return (s, y) => [
+        wall.start[0] + s * cos,
+        slabElevation + y + levelYOffset,
+        wall.start[1] + s * sin,
+    ];
+}
+/** Like {@link makeWallToWorld} but derives the level Y + slab elevation from the
+ *  scene, for callers without a wall event — i.e. the resize handles. */
+export function wallToWorld(wall) {
+    const levelId = wall.parentId;
+    const levelYOffset = levelId ? (sceneRegistry.nodes.get(levelId)?.position.y ?? 0) : 0;
+    const slabElevation = spatialGridManager.getSlabElevationForWall(wall.parentId ?? '', wall.start, wall.end);
+    return makeWallToWorld(wall, levelYOffset, slabElevation);
+}
+/**
+ * Publish 3D opening guides for an opening being placed or moved on a wall via a
+ * wall event. The caller passes the level Y + slab elevation it already computed
+ * for the drag cursor, so the guides share the cursor's frame exactly — the one
+ * place the door/window move + placement tools publish from.
+ */
+export function publishOpeningGuidesForWallEvent(args) {
+    const { wall, levelYOffset, slabElevation, ...rest } = args;
+    publishOpeningGuides3D({
+        ...rest,
+        wall,
+        nodes: useScene.getState().nodes,
+        toWorld: makeWallToWorld(wall, levelYOffset, slabElevation),
+    });
+}
+/**
+ * Publish 3D opening guides for an opening being RESIZED via a handle arrow.
+ * Resolves the host wall + transform from the scene (no wall event), then reuses
+ * the shared publish. Doors pass `includeVertical: false` (they sit on the
+ * floor); windows pass `true` so a height drag also shows the live sill/head.
+ */
+export function publishOpeningResizeGuides(node, includeVertical) {
+    const nodes = useScene.getState().nodes;
+    const wall = node.parentId ? nodes[node.parentId] : undefined;
+    if (wall?.type !== 'wall')
+        return;
+    publishOpeningGuides3D({
+        wall,
+        movingId: node.id,
+        centerS: node.position[0],
+        centerY: node.position[1],
+        width: node.width,
+        height: node.height,
+        includeVertical,
+        nodes,
+        toWorld: wallToWorld(wall),
+    });
+}