@pascal-app/nodes 1.0.0-beta.5 → 1.0.0

package/dist/lean-to-extension/tool.d.ts

@@ -0,0 +1,3 @@
+declare const LeanToExtensionTool: () => import("react").JSX.Element | null;
+export default LeanToExtensionTool;
+//# sourceMappingURL=tool.d.ts.map

package/dist/lean-to-extension/tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/lean-to-extension/tool.tsx"],"names":[],"mappings":"AAmEA,QAAA,MAAM,mBAAmB,0CAqnBxB,CAAA;AAED,eAAe,mBAAmB,CAAA"}

package/dist/lean-to-extension/tool.js

@@ -0,0 +1,580 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { emitter, getLevelElevations, getWallBaseElevationForNodes, sceneRegistry, } from '@pascal-app/core';
+import { CursorSphere, EDITOR_LAYER, isGridSnapActive, isMagneticSnapActive, markToolCancelConsumed, triggerSFX, useEditor, useInteractionScope, useRegistryToolContext, } from '@pascal-app/editor';
+import { useEffect, useState } from 'react';
+import { Euler, Quaternion, Vector3 } from 'three';
+import { stopPlacementCommitPropagation } from '../shared/floor-placement';
+import { createLeanToAssembly } from './assembly';
+import { isConicalLeanToHostOccupied, resolveConicalLeanToSurfaceHit } from './conical-host';
+import { leanToExtensionGeometryKey } from './geometry';
+import { leanToWallLocalPose, resolveLeanToWallSurfaceHit } from './layout';
+import { findLeanToSlabEdgePlacement, LEAN_TO_RUN_CONNECT_SNAP_RADIUS, LEAN_TO_RUN_MAGNETIC_SNAP_RADIUS, nextLeanToCanopyForm, nextLeanToPlacementRotation, resolveLeanToCommitTarget, resolveLeanToFreestandingRunEndpointSnap, resolveLeanToFreestandingRunTarget, resolveLeanToPlanPlacement, resolveLeanToWallPlanTarget, } from './placement';
+import { isLeanToHostOnLevel } from './placement-scope';
+import LeanToExtensionPreview from './preview';
+import { resolveLeanToHostRoof } from './roof-attachment';
+import { resolveLeanToDoorWallTarget } from './wall-target';
+const LeanToExtensionTool = () => {
+    const { activeLevelId, sceneApi, selectNode } = useRegistryToolContext();
+    const viewMode = useEditor((state) => state.viewMode);
+    const [preview, setPreview] = useState(null);
+    const [chainCursor, setChainCursor] = useState(null);
+    const [runSnap, setRunSnap] = useState(null);
+    useEffect(() => {
+        if (!(activeLevelId && viewMode === '3d'))
+            return;
+        useInteractionScope.getState().begin({ kind: 'drafting', tool: 'lean-to-extension' });
+        let lastMeshEventTime = -1;
+        let freestandingRotationY = 0;
+        let freestandingCanopyForm = 'mono';
+        let lastFreestandingEvent = null;
+        let lastPreviewTarget = null;
+        let chainStart = null;
+        let chainEnd = null;
+        let chainEndSnapped = false;
+        let chainFlipProjection = false;
+        let lastRunSnapKey = null;
+        let commitQueued = false;
+        const isContinuous = () => useEditor.getState().getContinuation('canopy') === 'continuous';
+        const snapPoint = (point, altKey) => {
+            const step = !altKey && isGridSnapActive() ? useEditor.getState().gridSnapStep : 0;
+            const snap = (value) => (step > 0 ? Math.round(value / step) * step : value);
+            return [snap(point[0]), snap(point[1])];
+        };
+        const setChainCursorPreview = (point) => {
+            if (!point) {
+                setChainCursor(null);
+                return;
+            }
+            const position = new Vector3(point[0], 0, point[1]);
+            sceneRegistry.nodes.get(activeLevelId)?.localToWorld(position);
+            setChainCursor([position.x, position.y, position.z]);
+        };
+        const setRunSnapPreview = (snap) => {
+            const key = snap ? `${snap.nodeId}:${snap.side}` : null;
+            if (key && key !== lastRunSnapKey)
+                triggerSFX('sfx:grid-snap');
+            lastRunSnapKey = key;
+            if (!snap) {
+                setRunSnap(null);
+                return;
+            }
+            const position = new Vector3(snap.point[0], 0.06, snap.point[1]);
+            sceneRegistry.nodes.get(activeLevelId)?.localToWorld(position);
+            setRunSnap([position.x, position.y, position.z]);
+        };
+        const resolveBaseY = (wall) => {
+            const nodes = sceneApi.nodes();
+            const levelY = wall.parentId ? (getLevelElevations(nodes).get(wall.parentId)?.baseY ?? 0) : 0;
+            return levelY + getWallBaseElevationForNodes(wall, nodes);
+        };
+        const commitNode = (node, parentId) => {
+            if (!sceneApi.createMany || commitQueued)
+                return;
+            commitQueued = true;
+            queueMicrotask(() => {
+                commitQueued = false;
+            });
+            const nodes = sceneApi.nodes();
+            const assembly = createLeanToAssembly(node, resolveLeanToHostRoof(node, nodes), nodes);
+            sceneApi.createMany([
+                { node: assembly.extension, parentId },
+                ...assembly.children.map((child) => ({
+                    node: child,
+                    parentId: child.parentId ?? undefined,
+                })),
+            ]);
+            lastPreviewTarget = null;
+            setPreview(null);
+            selectNode(assembly.extension.id);
+            triggerSFX('sfx:structure-build');
+            if (!isContinuous()) {
+                useEditor.getState().setTool(null);
+                useEditor.getState().setMode('select');
+            }
+        };
+        const worldPreviewPose = (event, node, localPosition, extraRotationY = 0, valid = true) => {
+            const position = event.object.localToWorld(new Vector3(...localPosition));
+            const rotationY = new Euler().setFromQuaternion(event.object.getWorldQuaternion(new Quaternion()), 'YXZ').y +
+                extraRotationY;
+            return {
+                node,
+                position: [position.x, position.y, position.z],
+                rotationY,
+                valid,
+            };
+        };
+        const levelPreviewPose = (node) => {
+            const levelObject = sceneRegistry.nodes.get(activeLevelId);
+            if (!levelObject) {
+                return {
+                    node,
+                    position: node.position,
+                    rotationY: node.rotation[1],
+                    valid: true,
+                };
+            }
+            const position = levelObject.localToWorld(new Vector3(...node.position));
+            const rotationY = new Euler().setFromQuaternion(levelObject.getWorldQuaternion(new Quaternion()), 'YXZ').y +
+                node.rotation[1];
+            return {
+                node,
+                position: [position.x, position.y, position.z],
+                rotationY,
+                valid: true,
+            };
+        };
+        const updateContinuousTarget = (point, altKey = false) => {
+            if (!chainStart)
+                return null;
+            const nodes = sceneApi.nodes();
+            const snap = altKey
+                ? null
+                : resolveLeanToFreestandingRunEndpointSnap({
+                    activeLevelId,
+                    canopyForm: freestandingCanopyForm,
+                    flipProjection: chainFlipProjection,
+                    maxDistance: isMagneticSnapActive()
+                        ? LEAN_TO_RUN_MAGNETIC_SNAP_RADIUS
+                        : LEAN_TO_RUN_CONNECT_SNAP_RADIUS,
+                    nodes,
+                    proposedEnd: point,
+                    start: chainStart,
+                });
+            const end = snap?.point ?? point;
+            setChainCursorPreview(end);
+            const target = resolveLeanToFreestandingRunTarget({
+                activeLevelId,
+                canopyForm: freestandingCanopyForm,
+                start: chainStart,
+                end,
+                flipProjection: chainFlipProjection,
+                nodes,
+            });
+            chainEnd = end;
+            chainEndSnapped = Boolean(snap);
+            setRunSnapPreview(snap);
+            lastPreviewTarget = target?.node.parentId
+                ? { node: target.node, parentId: target.node.parentId, valid: target.valid }
+                : null;
+            setPreview(target ? levelPreviewPose(target.node) : null);
+            return target;
+        };
+        const pointFromObjectEvent = (event) => {
+            const position = event.object.localToWorld(new Vector3(...event.localPosition));
+            sceneRegistry.nodes.get(activeLevelId)?.worldToLocal(position);
+            return snapPoint([position.x, position.z], event.nativeEvent.altKey);
+        };
+        const updateContinuousObjectTarget = (event) => updateContinuousTarget(pointFromObjectEvent(event), event.nativeEvent.altKey);
+        const finishRun = () => {
+            chainStart = null;
+            chainEnd = null;
+            chainEndSnapped = false;
+            chainFlipProjection = false;
+            lastPreviewTarget = null;
+            setChainCursorPreview(null);
+            setRunSnapPreview(null);
+            setPreview(null);
+        };
+        const advanceRun = () => {
+            if (!chainEnd)
+                return;
+            if (chainEndSnapped) {
+                finishRun();
+                return;
+            }
+            chainStart = chainEnd;
+            chainEnd = null;
+            chainEndSnapped = false;
+            setRunSnapPreview(null);
+            setChainCursorPreview(chainStart);
+        };
+        const updateFreeTarget = (event) => {
+            const point = snapPoint([event.localPosition[0], event.localPosition[2]], event.nativeEvent.altKey);
+            if (chainStart && isContinuous()) {
+                lastFreestandingEvent = event;
+                return updateContinuousTarget(point, event.nativeEvent.altKey);
+            }
+            if (chainStart)
+                finishRun();
+            const nodes = sceneApi.nodes();
+            const target = resolveLeanToPlanPlacement({
+                activeLevelId,
+                freestandingPoint: point,
+                freestandingRotationY,
+                freestandingCanopyForm,
+                nodes,
+                point: [event.localPosition[0], event.localPosition[2]],
+            });
+            lastPreviewTarget = target.node.parentId
+                ? {
+                    node: target.node,
+                    parentId: target.node.parentId,
+                    valid: target.valid,
+                }
+                : null;
+            lastFreestandingEvent = target.node.hostKind === 'freestanding' ? event : null;
+            if (target.wall) {
+                const pose = leanToWallLocalPose(target.wall, target.node, resolveBaseY(target.wall));
+                setPreview((current) => ({
+                    node: current &&
+                        leanToExtensionGeometryKey(current.node) === leanToExtensionGeometryKey(target.node)
+                        ? current.node
+                        : target.node,
+                    ...pose,
+                    valid: target.valid,
+                }));
+            }
+            else {
+                setPreview({ ...levelPreviewPose(target.node), valid: target.valid });
+            }
+            return target;
+        };
+        const updateSlabTarget = (event) => {
+            if (chainStart && isContinuous()) {
+                return updateContinuousObjectTarget(event);
+            }
+            const nodes = sceneApi.nodes();
+            const node = findLeanToSlabEdgePlacement([event.localPosition[0], event.localPosition[2]], nodes, activeLevelId);
+            if (!node || node.hostSlabId !== event.node.id)
+                return updateFreeTarget(event);
+            lastFreestandingEvent = null;
+            lastPreviewTarget = node.parentId
+                ? { node, parentId: node.parentId, valid: true }
+                : null;
+            setPreview(levelPreviewPose(node));
+            return { node, valid: true };
+        };
+        const updateConicalSegmentTarget = (event) => {
+            if (chainStart && isContinuous())
+                return updateContinuousObjectTarget(event);
+            lastFreestandingEvent = null;
+            const nodes = sceneApi.nodes();
+            if (!isLeanToHostOnLevel(event.node, nodes, activeLevelId)) {
+                lastPreviewTarget = null;
+                setPreview(null);
+                return null;
+            }
+            const node = resolveConicalLeanToSurfaceHit(event.node, event.localPosition, event.normal);
+            if (!node) {
+                lastPreviewTarget = null;
+                setPreview(null);
+                return null;
+            }
+            const valid = !isConicalLeanToHostOccupied(event.node.id, nodes);
+            lastPreviewTarget = { node, parentId: event.node.id, valid };
+            setPreview(worldPreviewPose(event, node, node.position, 0, valid));
+            return valid ? node : null;
+        };
+        const updateConicalRoofTarget = (event) => {
+            if (chainStart && isContinuous())
+                return updateContinuousObjectTarget(event);
+            lastFreestandingEvent = null;
+            const nodes = sceneApi.nodes();
+            if (!isLeanToHostOnLevel(event.node, nodes, activeLevelId) ||
+                event.object.name !== 'merged-roof') {
+                lastPreviewTarget = null;
+                setPreview(null);
+                return null;
+            }
+            for (const childId of event.node.children) {
+                const segment = nodes[childId];
+                if (segment?.type !== 'roof-segment' || segment.roofType !== 'conical')
+                    continue;
+                const cos = Math.cos(segment.rotation);
+                const sin = Math.sin(segment.rotation);
+                const dx = event.localPosition[0] - segment.position[0];
+                const dy = event.localPosition[1] - segment.position[1];
+                const dz = event.localPosition[2] - segment.position[2];
+                const localPosition = [
+                    dx * cos - dz * sin,
+                    dy,
+                    dx * sin + dz * cos,
+                ];
+                const normal = event.normal
+                    ? [
+                        event.normal[0] * cos - event.normal[2] * sin,
+                        event.normal[1],
+                        event.normal[0] * sin + event.normal[2] * cos,
+                    ]
+                    : undefined;
+                const node = resolveConicalLeanToSurfaceHit(segment, localPosition, normal);
+                if (!node)
+                    continue;
+                const valid = !isConicalLeanToHostOccupied(segment.id, nodes);
+                lastPreviewTarget = { node, parentId: segment.id, valid };
+                const crownX = segment.position[0] + node.position[0] * cos + node.position[2] * sin;
+                const crownZ = segment.position[2] - node.position[0] * sin + node.position[2] * cos;
+                setPreview(worldPreviewPose(event, node, [crownX, segment.position[1] + node.position[1], crownZ], segment.rotation, valid));
+                return valid ? node : null;
+            }
+            lastPreviewTarget = null;
+            setPreview(null);
+            return null;
+        };
+        const updateTarget = (event) => {
+            if (chainStart && isContinuous())
+                return updateContinuousObjectTarget(event);
+            lastFreestandingEvent = null;
+            const nodes = sceneApi.nodes();
+            if (!isLeanToHostOnLevel(event.node, nodes, activeLevelId)) {
+                lastPreviewTarget = null;
+                setPreview(null);
+                return null;
+            }
+            const hit = resolveLeanToWallSurfaceHit(event.node, event.localPosition, event.normal);
+            if (!hit) {
+                lastPreviewTarget = null;
+                setPreview(null);
+                return null;
+            }
+            const target = resolveLeanToWallPlanTarget(event.node, hit.localX, hit.side, nodes);
+            if (!target) {
+                lastPreviewTarget = null;
+                setPreview(null);
+                return null;
+            }
+            const pose = leanToWallLocalPose(event.node, target.node, resolveBaseY(event.node));
+            lastPreviewTarget = {
+                node: target.node,
+                parentId: event.node.id,
+                valid: target.valid,
+            };
+            setPreview((current) => ({
+                node: current &&
+                    leanToExtensionGeometryKey(current.node) === leanToExtensionGeometryKey(target.node)
+                    ? current.node
+                    : target.node,
+                ...pose,
+                valid: target.valid,
+            }));
+            return target.valid ? target.node : null;
+        };
+        const onWallMove = (event) => {
+            lastMeshEventTime = event.nativeEvent.timeStamp;
+            updateTarget(event);
+        };
+        const onWallLeave = () => {
+            lastFreestandingEvent = null;
+            lastPreviewTarget = null;
+            setPreview(null);
+        };
+        const onWallClick = (event) => {
+            lastMeshEventTime = event.nativeEvent.timeStamp;
+            const visibleTarget = lastPreviewTarget;
+            updateTarget(event);
+            const target = resolveLeanToCommitTarget(visibleTarget, lastPreviewTarget);
+            if (!target?.valid)
+                return;
+            stopPlacementCommitPropagation(event);
+            commitNode(target.node, target.parentId);
+            if (chainStart)
+                advanceRun();
+        };
+        const onDoorMove = (event) => {
+            lastMeshEventTime = event.nativeEvent.timeStamp;
+            if (chainStart && isContinuous()) {
+                updateContinuousObjectTarget(event);
+                return;
+            }
+            const wallId = event.node.wallId ?? event.node.parentId;
+            const wall = wallId ? sceneApi.get(wallId) : undefined;
+            const wallObject = wall ? sceneRegistry.nodes.get(wall.id) : undefined;
+            if (!(wall?.type === 'wall' && wallObject)) {
+                lastPreviewTarget = null;
+                setPreview(null);
+                return;
+            }
+            updateTarget(resolveLeanToDoorWallTarget(event, wall, wallObject));
+        };
+        const onDoorClick = (event) => {
+            lastMeshEventTime = event.nativeEvent.timeStamp;
+            const visibleTarget = lastPreviewTarget;
+            const wallId = event.node.wallId ?? event.node.parentId;
+            const wall = wallId ? sceneApi.get(wallId) : undefined;
+            const wallObject = wall ? sceneRegistry.nodes.get(wall.id) : undefined;
+            if (!(wall?.type === 'wall' && wallObject))
+                return;
+            const target = resolveLeanToDoorWallTarget(event, wall, wallObject);
+            updateTarget(target);
+            const commitTarget = resolveLeanToCommitTarget(visibleTarget, lastPreviewTarget);
+            if (!commitTarget?.valid)
+                return;
+            stopPlacementCommitPropagation(event);
+            commitNode(commitTarget.node, commitTarget.parentId);
+            if (chainStart)
+                advanceRun();
+        };
+        const onDoorLeave = () => {
+            lastPreviewTarget = null;
+            setPreview(null);
+        };
+        const onRoofSegmentMove = (event) => {
+            lastMeshEventTime = event.nativeEvent.timeStamp;
+            updateConicalSegmentTarget(event);
+        };
+        const onRoofSegmentClick = (event) => {
+            lastMeshEventTime = event.nativeEvent.timeStamp;
+            const visibleTarget = lastPreviewTarget;
+            updateConicalSegmentTarget(event);
+            const target = resolveLeanToCommitTarget(visibleTarget, lastPreviewTarget);
+            if (!target?.valid)
+                return;
+            stopPlacementCommitPropagation(event);
+            commitNode(target.node, target.parentId);
+            if (chainStart)
+                advanceRun();
+        };
+        const onRoofMove = (event) => {
+            lastMeshEventTime = event.nativeEvent.timeStamp;
+            updateConicalRoofTarget(event);
+        };
+        const onRoofClick = (event) => {
+            lastMeshEventTime = event.nativeEvent.timeStamp;
+            const visibleTarget = lastPreviewTarget;
+            updateConicalRoofTarget(event);
+            const target = resolveLeanToCommitTarget(visibleTarget, lastPreviewTarget);
+            if (!target?.valid)
+                return;
+            stopPlacementCommitPropagation(event);
+            commitNode(target.node, target.parentId);
+            if (chainStart)
+                advanceRun();
+        };
+        const onSlabMove = (event) => {
+            lastMeshEventTime = event.nativeEvent.timeStamp;
+            updateSlabTarget(event);
+        };
+        const onSlabClick = (event) => {
+            lastMeshEventTime = event.nativeEvent.timeStamp;
+            const visibleTarget = lastPreviewTarget;
+            updateSlabTarget(event);
+            const target = resolveLeanToCommitTarget(visibleTarget, lastPreviewTarget);
+            stopPlacementCommitPropagation(event);
+            if (!target?.valid)
+                return;
+            commitNode(target.node, target.parentId);
+            if (chainStart)
+                advanceRun();
+        };
+        const onGridMove = (event) => {
+            if (event.nativeEvent.timeStamp === lastMeshEventTime)
+                return;
+            updateFreeTarget(event);
+        };
+        const onGridClick = (event) => {
+            if (event.nativeEvent.timeStamp === lastMeshEventTime)
+                return;
+            if (isContinuous() && !chainStart) {
+                chainStart = snapPoint([event.localPosition[0], event.localPosition[2]], event.nativeEvent.altKey);
+                lastFreestandingEvent = event;
+                lastPreviewTarget = null;
+                setChainCursorPreview(chainStart);
+                setPreview(null);
+                triggerSFX('sfx:structure-build-start');
+                return;
+            }
+            const visibleTarget = lastPreviewTarget;
+            updateFreeTarget(event);
+            const target = resolveLeanToCommitTarget(visibleTarget, lastPreviewTarget);
+            if (!target?.valid)
+                return;
+            commitNode(target.node, target.parentId);
+            if (chainStart)
+                advanceRun();
+        };
+        const onKeyDown = (event) => {
+            if (event.target instanceof HTMLInputElement ||
+                event.target instanceof HTMLTextAreaElement ||
+                (event.target instanceof HTMLElement && event.target.isContentEditable)) {
+                return;
+            }
+            if (event.key === 'Escape' && chainStart) {
+                event.preventDefault();
+                event.stopImmediatePropagation();
+                markToolCancelConsumed();
+                finishRun();
+                return;
+            }
+            if (chainStart &&
+                (event.key === 'r' || event.key === 'R' || event.key === 't' || event.key === 'T')) {
+                event.preventDefault();
+                chainFlipProjection = !chainFlipProjection;
+                triggerSFX('sfx:item-rotate');
+                if (chainEnd)
+                    updateContinuousTarget(chainEnd);
+                return;
+            }
+            const nextRotation = nextLeanToPlacementRotation(freestandingRotationY, event.key, event.metaKey || event.ctrlKey);
+            const nextForm = nextLeanToCanopyForm(freestandingCanopyForm, event.key);
+            if (nextRotation === freestandingRotationY && nextForm === freestandingCanopyForm)
+                return;
+            event.preventDefault();
+            freestandingRotationY = nextRotation;
+            freestandingCanopyForm = nextForm;
+            triggerSFX('sfx:item-rotate');
+            if (chainStart && chainEnd)
+                updateContinuousTarget(chainEnd);
+            else if (lastFreestandingEvent)
+                updateFreeTarget(lastFreestandingEvent);
+        };
+        emitter.on('wall:move', onWallMove);
+        emitter.on('wall:enter', onWallMove);
+        emitter.on('wall:leave', onWallLeave);
+        emitter.on('wall:click', onWallClick);
+        emitter.on('door:move', onDoorMove);
+        emitter.on('door:enter', onDoorMove);
+        emitter.on('door:leave', onDoorLeave);
+        emitter.on('door:click', onDoorClick);
+        emitter.on('roof-segment:move', onRoofSegmentMove);
+        emitter.on('roof-segment:enter', onRoofSegmentMove);
+        emitter.on('roof-segment:leave', onWallLeave);
+        emitter.on('roof-segment:click', onRoofSegmentClick);
+        emitter.on('roof:move', onRoofMove);
+        emitter.on('roof:enter', onRoofMove);
+        emitter.on('roof:leave', onWallLeave);
+        emitter.on('roof:click', onRoofClick);
+        emitter.on('slab:move', onSlabMove);
+        emitter.on('slab:enter', onSlabMove);
+        emitter.on('slab:leave', onWallLeave);
+        emitter.on('slab:click', onSlabClick);
+        emitter.on('grid:move', onGridMove);
+        emitter.on('grid:click', onGridClick);
+        window.addEventListener('keydown', onKeyDown, true);
+        return () => {
+            emitter.off('wall:move', onWallMove);
+            emitter.off('wall:enter', onWallMove);
+            emitter.off('wall:leave', onWallLeave);
+            emitter.off('wall:click', onWallClick);
+            emitter.off('door:move', onDoorMove);
+            emitter.off('door:enter', onDoorMove);
+            emitter.off('door:leave', onDoorLeave);
+            emitter.off('door:click', onDoorClick);
+            emitter.off('roof-segment:move', onRoofSegmentMove);
+            emitter.off('roof-segment:enter', onRoofSegmentMove);
+            emitter.off('roof-segment:leave', onWallLeave);
+            emitter.off('roof-segment:click', onRoofSegmentClick);
+            emitter.off('roof:move', onRoofMove);
+            emitter.off('roof:enter', onRoofMove);
+            emitter.off('roof:leave', onWallLeave);
+            emitter.off('roof:click', onRoofClick);
+            emitter.off('slab:move', onSlabMove);
+            emitter.off('slab:enter', onSlabMove);
+            emitter.off('slab:leave', onWallLeave);
+            emitter.off('slab:click', onSlabClick);
+            emitter.off('grid:move', onGridMove);
+            emitter.off('grid:click', onGridClick);
+            window.removeEventListener('keydown', onKeyDown, true);
+            setPreview(null);
+            setChainCursor(null);
+            setRunSnap(null);
+            useInteractionScope
+                .getState()
+                .endIf((scope) => scope.kind === 'drafting' && scope.tool === 'lean-to-extension');
+        };
+    }, [activeLevelId, sceneApi, selectNode, viewMode]);
+    if (viewMode !== '3d')
+        return null;
+    return (_jsxs(_Fragment, { children: [chainCursor ? (_jsx(CursorSphere, { color: "#0ea5e9", height: preview?.node.highEdgeHeight ?? 2.8, position: chainCursor, showTooltip: false })) : null, runSnap ? (_jsxs("mesh", { layers: EDITOR_LAYER, position: runSnap, renderOrder: 1001, rotation: [-Math.PI / 2, 0, 0], children: [_jsx("ringGeometry", { args: [0.13, 0.2, 24] }), _jsx("meshBasicMaterial", { color: "#22c55e", depthTest: false, side: 2 })] })) : null, preview ? (_jsx("group", { position: preview.position, rotation: [0, preview.rotationY, 0], children: _jsx(LeanToExtensionPreview, { invalid: !preview.valid, node: preview.node }) })) : null] }));
+};
+export default LeanToExtensionTool;

package/dist/lean-to-extension/wall-target.d.ts

@@ -0,0 +1,10 @@
+import type { DoorEvent, WallEvent, WallNode } from '@pascal-app/core';
+import type { Object3D } from 'three';
+/**
+ * Re-attributes a hosted door hit to its wall while preserving the hit in
+ * world space. Door face normals are local to the intersected door object;
+ * converting through that object keeps rotated doors and hosted cutout meshes
+ * aligned with the wall's local placement frame.
+ */
+export declare function resolveLeanToDoorWallTarget(event: DoorEvent, wall: WallNode, wallObject: Object3D): WallEvent;
+//# sourceMappingURL=wall-target.d.ts.map

package/dist/lean-to-extension/wall-target.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-target.d.ts","sourceRoot":"","sources":["../../src/lean-to-extension/wall-target.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AACtE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;AAGrC;;;;;GAKG;AACH,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,SAAS,EAChB,IAAI,EAAE,QAAQ,EACd,UAAU,EAAE,QAAQ,GACnB,SAAS,CAuBX"}

package/dist/lean-to-extension/wall-target.js

@@ -0,0 +1,29 @@
+import { Vector3 } from 'three';
+/**
+ * Re-attributes a hosted door hit to its wall while preserving the hit in
+ * world space. Door face normals are local to the intersected door object;
+ * converting through that object keeps rotated doors and hosted cutout meshes
+ * aligned with the wall's local placement frame.
+ */
+export function resolveLeanToDoorWallTarget(event, wall, wallObject) {
+    wallObject.updateWorldMatrix(true, false);
+    event.object.updateWorldMatrix(true, false);
+    const worldPoint = new Vector3(...event.position);
+    const localPoint = wallObject.worldToLocal(worldPoint.clone());
+    const normal = event.normal
+        ? (() => {
+            const objectOrigin = event.object.localToWorld(new Vector3());
+            const objectNormalPoint = event.object.localToWorld(new Vector3(...event.normal));
+            const worldNormal = objectNormalPoint.sub(objectOrigin).normalize();
+            const localNormalPoint = wallObject.worldToLocal(worldPoint.clone().add(worldNormal));
+            return localNormalPoint.sub(localPoint).normalize();
+        })()
+        : new Vector3(0, 0, localPoint.z >= 0 ? 1 : -1);
+    return {
+        ...event,
+        node: wall,
+        localPosition: [localPoint.x, localPoint.y, localPoint.z],
+        normal: [normal.x, normal.y, normal.z],
+        object: wallObject,
+    };
+}

package/dist/lineset/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/lineset/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAKtD,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAEtC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB,EAAE,cAAc,CAAC,OAAO,WAAW,CAoHhE,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/lineset/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAKtD,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAEtC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB,EAAE,cAAc,CAAC,OAAO,WAAW,CAqHhE,CAAA"}

package/dist/lineset/definition.js

@@ -20,6 +20,7 @@ export const linesetDefinition = {
     schema: LinesetNode,
     category: 'utility',
     distributionRole: 'run',
+    drafting: { cancelOnHistoryJump: true },
     // Directional run: like a wall, drafting sets a direction, so it takes the
     // structural snapping context (grid / lines / angles / off) with a 45° angle
     // lock available as a cyclable mode.

package/dist/liquid-line/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/liquid-line/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAKtD,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAEzC;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,oBAAoB,EAAE,cAAc,CAAC,OAAO,cAAc,CA2GtE,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/liquid-line/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAKtD,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAEzC;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,oBAAoB,EAAE,cAAc,CAAC,OAAO,cAAc,CA4GtE,CAAA"}

package/dist/liquid-line/definition.js

@@ -21,6 +21,7 @@ export const liquidLineDefinition = {
     schema: LiquidLineNode,
     category: 'utility',
     distributionRole: 'run',
+    drafting: { cancelOnHistoryJump: true },
     // Directional run: like a wall, drafting sets a direction, so it takes the
     // structural snapping context (grid / lines / angles / off) with a 45° angle
     // lock available as a cyclable mode.

package/dist/pipe-fitting/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/pipe-fitting/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAOtD,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE1C;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC,OAAO,eAAe,CA4FxE,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/pipe-fitting/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAStD,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE1C;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC,OAAO,eAAe,CAwGxE,CAAA"}