@pascal-app/nodes 0.1.1

package/dist/measurement/selection.js

@@ -0,0 +1,259 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { collectAlignmentAnchors, emitter, MeasurementNode, resolveLevelId, sceneRegistry, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { boundaryReshapeScope, EDITOR_LAYER, isAlignmentGuideActive, MEASUREMENT_ACTIVE_COLOR, swallowNextClick, useInteractionScope, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { Html } from '@react-three/drei';
+import { createPortal, useFrame, useThree } from '@react-three/fiber';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { BufferGeometry, Float32BufferAttribute, MathUtils, Vector3, } from 'three';
+import { MeshBasicNodeMaterial } from 'three/webgpu';
+import { useShallow } from 'zustand/react/shallow';
+import { measurementEditAnchor, measurementResolvedEditPoints, refreshMeasurementAnchorFallbacks, replaceMeasurementAnchor, } from './edit';
+import { measurementDependencyIds, resolveMeasurementNode } from './resolve';
+import { associateSurfaceHit, createMeasurementSurfaceQuerySession, measurementVertexSnapAnchors, } from './surface-query';
+const HANDLE_RADIUS_PX = 7;
+const GUIDE_COLORS = {
+    x: '#ef4444',
+    y: '#22c55e',
+    z: '#3b82f6',
+};
+const NO_RAYCAST = () => { };
+function MeasurementEditHandle({ active, onPointerDown, position, }) {
+    const ref = useRef(null);
+    const worldPosition = useMemo(() => new Vector3(), []);
+    const cameraPosition = useMemo(() => new Vector3(), []);
+    const materials = useMemo(() => ({
+        halo: new MeshBasicNodeMaterial({
+            color: '#f8fafc',
+            depthTest: false,
+            depthWrite: false,
+        }),
+        point: new MeshBasicNodeMaterial({
+            color: MEASUREMENT_ACTIVE_COLOR,
+            depthTest: false,
+            depthWrite: false,
+        }),
+        hit: new MeshBasicNodeMaterial({
+            visible: false,
+        }),
+    }), []);
+    useEffect(() => () => {
+        materials.halo.dispose();
+        materials.point.dispose();
+        materials.hit.dispose();
+    }, [materials]);
+    useFrame(({ camera, size }) => {
+        const group = ref.current;
+        if (!group)
+            return;
+        group.getWorldPosition(worldPosition);
+        let worldUnitsPerPixel = 0.01;
+        if (camera.isPerspectiveCamera) {
+            const perspective = camera;
+            const depth = Math.abs(cameraPosition.copy(worldPosition).applyMatrix4(perspective.matrixWorldInverse).z);
+            worldUnitsPerPixel =
+                (2 * depth * Math.tan(MathUtils.degToRad(perspective.getEffectiveFOV() * 0.5))) /
+                    Math.max(size.height, 1);
+        }
+        else if (camera.isOrthographicCamera) {
+            const orthographic = camera;
+            worldUnitsPerPixel =
+                (orthographic.top - orthographic.bottom) / Math.max(orthographic.zoom * size.height, 1);
+        }
+        const scale = worldUnitsPerPixel * HANDLE_RADIUS_PX * (active ? 1.2 : 1);
+        if (Number.isFinite(scale))
+            group.scale.setScalar(MathUtils.clamp(scale, 0.004, 0.3));
+    });
+    return (_jsxs("group", { position: position, ref: ref, userData: { measurementSurface: false }, children: [_jsx("mesh", { layers: EDITOR_LAYER, material: materials.halo, raycast: NO_RAYCAST, renderOrder: 1010, children: _jsx("sphereGeometry", { args: [1, 16, 12] }) }), _jsx("mesh", { layers: EDITOR_LAYER, material: materials.point, raycast: NO_RAYCAST, renderOrder: 1011, scale: 0.62, children: _jsx("sphereGeometry", { args: [1, 16, 12] }) }), _jsx("mesh", { layers: EDITOR_LAYER, material: materials.hit, onPointerDown: onPointerDown, onPointerEnter: () => {
+                    document.body.style.cursor = 'grab';
+                }, onPointerLeave: () => {
+                    if (!active)
+                        document.body.style.cursor = '';
+                }, renderOrder: 1012, scale: 1.8, children: _jsx("sphereGeometry", { args: [1, 12, 8] }) })] }));
+}
+function MeasurementEditGuide({ guide }) {
+    const geometry = useMemo(() => {
+        const next = new BufferGeometry();
+        next.setAttribute('position', new Float32BufferAttribute([...guide.from, ...guide.to], 3));
+        return next;
+    }, [guide]);
+    useEffect(() => () => geometry.dispose(), [geometry]);
+    return (_jsxs(_Fragment, { children: [_jsx("lineSegments", { frustumCulled: false, geometry: geometry, layers: EDITOR_LAYER, raycast: NO_RAYCAST, renderOrder: 1009, userData: { measurementSurface: false }, children: _jsx("lineBasicNodeMaterial", { color: GUIDE_COLORS[guide.axis], depthTest: false, depthWrite: false, linewidth: guide.snapped ? 3 : 2, opacity: guide.snapped ? 1 : 0.72, transparent: true }) }), _jsx(Html, { center: true, position: guide.to, style: { pointerEvents: 'none' }, zIndexRange: [80, 0], children: _jsxs("div", { className: "-translate-y-4 whitespace-nowrap rounded-full border border-indigo-400/70 bg-background/95 px-2.5 py-1 font-mono font-semibold text-[11px] text-foreground shadow-sm backdrop-blur", children: [guide.proximity ? 'Align ' : '', guide.axis.toUpperCase()] }) })] }));
+}
+function MeasurementEditHandles({ levelId, levelObject, node, }) {
+    const { camera, gl, scene } = useThree();
+    const ownOverride = useLiveNodeOverrides((state) => state.overrides.get(node.id));
+    const effectiveNode = useMemo(() => (ownOverride ? { ...node, ...ownOverride } : node), [node, ownOverride]);
+    const dependencyIds = measurementDependencyIds(effectiveNode.measurement, (id) => useScene.getState().nodes[id]);
+    useScene(useShallow((state) => dependencyIds.map((id) => state.nodes[id])));
+    useLiveNodeOverrides(useShallow((state) => dependencyIds.map((id) => state.overrides.get(id))));
+    const resolved = resolveMeasurementNode(effectiveNode, (id) => {
+        const dependency = useScene.getState().nodes[id];
+        if (!dependency)
+            return undefined;
+        const override = useLiveNodeOverrides.getState().overrides.get(id);
+        return override ? { ...dependency, ...override } : dependency;
+    });
+    const points = measurementResolvedEditPoints(resolved.payload);
+    const polygon = resolved.payload.kind === 'area' ||
+        resolved.payload.kind === 'perimeter' ||
+        resolved.payload.kind === 'volume';
+    const surfaceQuery = useMemo(() => createMeasurementSurfaceQuerySession(scene), [scene]);
+    const proximityCache = useRef({
+        anchors: [],
+        timestamp: Number.NEGATIVE_INFINITY,
+    });
+    const [activeIndex, setActiveIndex] = useState(null);
+    const [axisGuide, setAxisGuide] = useState(null);
+    const endDragRef = useRef(() => { });
+    useEffect(() => () => {
+        endDragRef.current(false);
+        surfaceQuery.dispose();
+        useLiveNodeOverrides.getState().clear(node.id);
+        document.body.style.cursor = '';
+    }, [node.id, surfaceQuery]);
+    const startDrag = useCallback((index, event) => {
+        if (event.button !== 0 || useViewer.getState().cameraDragging)
+            return;
+        event.stopPropagation();
+        event.nativeEvent.preventDefault();
+        event.nativeEvent.stopImmediatePropagation();
+        const baseResolved = resolveMeasurementNode(node, (id) => {
+            const dependency = useScene.getState().nodes[id];
+            if (!dependency)
+                return undefined;
+            const override = useLiveNodeOverrides.getState().overrides.get(id);
+            return override ? { ...dependency, ...override } : dependency;
+        });
+        const basePayload = refreshMeasurementAnchorFallbacks(node.measurement, baseResolved.payload);
+        const basePoints = measurementResolvedEditPoints(baseResolved.payload);
+        if (!basePoints[index])
+            return;
+        const previousInputDragging = useViewer.getState().inputDragging;
+        const previousCursor = document.body.style.cursor;
+        let latestPayload = null;
+        let latestGuide = null;
+        const pointerId = event.pointerId;
+        setActiveIndex(index);
+        useViewer.getState().setInputDragging(true);
+        useInteractionScope.getState().begin(boundaryReshapeScope(node.id));
+        document.body.style.cursor = 'grabbing';
+        const getProximityAnchors = () => {
+            const now = performance.now();
+            if (now - proximityCache.current.timestamp > 120) {
+                proximityCache.current = {
+                    anchors: collectAlignmentAnchors(useScene.getState().nodes, node.id, levelId),
+                    timestamp: now,
+                };
+            }
+            return proximityCache.current.anchors;
+        };
+        const onMove = (pointerEvent) => {
+            if (pointerEvent.pointerId !== pointerId)
+                return;
+            pointerEvent.preventDefault();
+            pointerEvent.stopPropagation();
+            const anchors = measurementVertexSnapAnchors(basePoints, index, polygon);
+            // Measurement anchors always bind to real geometry — the construction
+            // snapping-mode chip doesn't govern this analysis tool. Alt bypasses.
+            const applyMagneticSnap = !pointerEvent.altKey;
+            const surface = surfaceQuery.resolvePointer({
+                event: pointerEvent,
+                camera,
+                canvas: gl.domElement,
+                levelObject,
+                anchorOrAnchors: anchors,
+                lockedGuide: applyMagneticSnap && latestGuide?.snapped === true ? latestGuide : null,
+                planarProximityAnchors: getProximityAnchors(),
+                applyMagneticSnap,
+                showAlignmentGuides: isAlignmentGuideActive(),
+            });
+            if (!surface)
+                return;
+            const associated = associateSurfaceHit(surface.hit, applyMagneticSnap ? 0.2 : 0.012);
+            const anchor = measurementEditAnchor(baseResolved.payload, associated.point, associated.anchor);
+            const next = replaceMeasurementAnchor(basePayload, index, anchor);
+            if (!next || !MeasurementNode.safeParse({ ...node, measurement: next }).success)
+                return;
+            latestPayload = next;
+            latestGuide = surface.guide;
+            useLiveNodeOverrides.getState().set(node.id, { measurement: next });
+            setAxisGuide(surface.guide);
+        };
+        const cleanup = (commit) => {
+            window.removeEventListener('pointermove', onMove);
+            window.removeEventListener('pointerup', onUp);
+            window.removeEventListener('pointercancel', onCancel);
+            window.removeEventListener('blur', onBlur);
+            emitter.off('tool:cancel', onToolCancel);
+            useLiveNodeOverrides.getState().clear(node.id);
+            useViewer.getState().setInputDragging(previousInputDragging);
+            useInteractionScope
+                .getState()
+                .endIf((scope) => scope.kind === 'reshaping' &&
+                scope.reshape === 'boundary' &&
+                scope.nodeId === node.id);
+            document.body.style.cursor = previousCursor;
+            setActiveIndex(null);
+            setAxisGuide(null);
+            const payload = latestPayload;
+            latestPayload = null;
+            latestGuide = null;
+            endDragRef.current = () => { };
+            if (commit && payload)
+                useScene.getState().updateNode(node.id, { measurement: payload });
+        };
+        const onUp = (pointerEvent) => {
+            if (pointerEvent.pointerId !== pointerId)
+                return;
+            pointerEvent.preventDefault();
+            swallowNextClick();
+            cleanup(true);
+        };
+        const onCancel = (pointerEvent) => {
+            if (pointerEvent.pointerId === pointerId)
+                cleanup(false);
+        };
+        const onBlur = () => cleanup(false);
+        const onToolCancel = () => cleanup(false);
+        endDragRef.current = cleanup;
+        emitter.on('tool:cancel', onToolCancel);
+        window.addEventListener('pointermove', onMove);
+        window.addEventListener('pointerup', onUp);
+        window.addEventListener('pointercancel', onCancel);
+        window.addEventListener('blur', onBlur);
+    }, [camera, gl.domElement, levelId, levelObject, node, polygon, surfaceQuery]);
+    return (_jsxs(_Fragment, { children: [axisGuide ? _jsx(MeasurementEditGuide, { guide: axisGuide }) : null, points.map((point, index) => (_jsx(MeasurementEditHandle, { active: activeIndex === index, onPointerDown: (event) => startDrag(index, event), position: point }, index)))] }));
+}
+const MeasurementSelectionAffordance = () => {
+    const selectedIds = useViewer((state) => state.selection.selectedIds);
+    const showMeasurements = useViewer((state) => state.showMeasurements);
+    const node = useScene((state) => {
+        if (selectedIds.length !== 1)
+            return null;
+        const selected = state.nodes[selectedIds[0]];
+        return selected?.type === 'measurement' ? selected : null;
+    });
+    const levelId = node ? resolveLevelId(node, useScene.getState().nodes) : null;
+    const [levelObject, setLevelObject] = useState(() => levelId ? (sceneRegistry.nodes.get(levelId) ?? null) : null);
+    useEffect(() => {
+        if (!levelId) {
+            setLevelObject(null);
+            return;
+        }
+        let frameId = 0;
+        const resolve = () => {
+            const next = sceneRegistry.nodes.get(levelId) ?? null;
+            setLevelObject((current) => (current === next ? current : next));
+            if (!next)
+                frameId = window.requestAnimationFrame(resolve);
+        };
+        resolve();
+        return () => window.cancelAnimationFrame(frameId);
+    }, [levelId]);
+    if (!(showMeasurements && node && node.visible !== false && levelId && levelObject))
+        return null;
+    return createPortal(_jsx(MeasurementEditHandles, { levelId: levelId, levelObject: levelObject, node: node }), levelObject);
+};
+export default MeasurementSelectionAffordance;

package/dist/measurement/smart-surface.d.ts

@@ -0,0 +1,4 @@
+import { type AnyNode } from '@pascal-app/core';
+import type { LocalSurfaceHit } from './surface-query';
+export declare function resolveSmartMeasurementSurfaceHit(hit: LocalSurfaceHit, nodes: Readonly<Record<string, AnyNode | undefined>>, levelId: string): LocalSurfaceHit;
+//# sourceMappingURL=smart-surface.d.ts.map

package/dist/measurement/smart-surface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smart-surface.d.ts","sourceRoot":"","sources":["../../src/measurement/smart-surface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAmC,MAAM,kBAAkB,CAAA;AAChF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAYtD,wBAAgB,iCAAiC,CAC/C,GAAG,EAAE,eAAe,EACpB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,SAAS,CAAC,CAAC,EACpD,OAAO,EAAE,MAAM,GACd,eAAe,CAcjB"}

package/dist/measurement/smart-surface.js

@@ -0,0 +1,21 @@
+import { pointInPolygon2D } from '@pascal-app/core';
+function polygonArea(polygon) {
+    let area = 0;
+    for (let index = 0; index < polygon.length; index += 1) {
+        const current = polygon[index];
+        const next = polygon[(index + 1) % polygon.length];
+        area += current[0] * next[1] - next[0] * current[1];
+    }
+    return Math.abs(area) * 0.5;
+}
+export function resolveSmartMeasurementSurfaceHit(hit, nodes, levelId) {
+    const target = hit.targetNodeId ? nodes[hit.targetNodeId] : undefined;
+    if (target?.type !== 'slab' || Math.abs(hit.normal[1]) < 0.75)
+        return hit;
+    const zone = Object.values(nodes)
+        .filter((node) => node?.type === 'zone' &&
+        node.parentId === levelId &&
+        pointInPolygon2D([hit.point[0], hit.point[2]], node.polygon))
+        .sort((left, right) => polygonArea(left.polygon) - polygonArea(right.polygon))[0];
+    return zone ? { ...hit, targetNodeId: zone.id } : hit;
+}

package/dist/measurement/smart-tool.d.ts

@@ -0,0 +1,3 @@
+export declare function SmartMeasurementTool(): import("react").JSX.Element;
+export default SmartMeasurementTool;
+//# sourceMappingURL=smart-tool.d.ts.map

package/dist/measurement/smart-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smart-tool.d.ts","sourceRoot":"","sources":["../../src/measurement/smart-tool.tsx"],"names":[],"mappings":"AA6MA,wBAAgB,oBAAoB,gCAqLnC;AAED,eAAe,oBAAoB,CAAA"}

package/dist/measurement/smart-tool.js

@@ -0,0 +1,264 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { sceneRegistry, useScene } from '@pascal-app/core';
+import { activateQuickMeasurementHudSource, clearQuickMeasurementHudSource, createQuickMeasurementPointerScheduler, EDITOR_LAYER, NO_RAYCAST, publishQuickMeasurementHudSource, resolveQuickMeasurementReport, useInteractionScope, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { useFrame, useThree } from '@react-three/fiber';
+import { memo, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react';
+import { DoubleSide, MathUtils, Quaternion, Vector3, } from 'three';
+import { MeshBasicNodeMaterial } from 'three/webgpu';
+import { resolveSmartMeasurementSurfaceHit } from './smart-surface';
+import { createMeasurementSurfaceQuerySession } from './surface-query';
+const MARKER_NORMAL = new Vector3(0, 0, 1);
+const MARKER_ORIGIN = new Vector3();
+const MARKER_USER_DATA = { measurementSurface: false };
+const HALO_RING_ARGS = [0.5, 1, 48];
+const LIVE_TARGET_RING_ARGS = [0.64, 0.84, 48];
+const PINNED_TARGET_RING_ARGS = [0.48, 0.84, 48];
+const PINNED_CENTER_ARGS = [0.22, 32];
+function localPointToBuildingFrame(levelObject, buildingObject, point) {
+    const worldPoint = levelObject.localToWorld(new Vector3(...point));
+    return buildingObject ? buildingObject.worldToLocal(worldPoint) : worldPoint;
+}
+function localNormalToBuildingFrame(levelObject, buildingObject, normal) {
+    const value = new Vector3(...normal).applyQuaternion(levelObject.getWorldQuaternion(new Quaternion()));
+    if (buildingObject)
+        value.applyQuaternion(buildingObject.getWorldQuaternion(new Quaternion()).invert());
+    return value.normalize();
+}
+const SmartSurfaceMarker = memo(function SmartSurfaceMarker({ position, normal, pinned, markerRef, }) {
+    const localRef = useRef(null);
+    const ref = markerRef ?? localRef;
+    const worldPosition = useMemo(() => new Vector3(), []);
+    const cameraPosition = useMemo(() => new Vector3(), []);
+    const rotation = useMemo(() => new Quaternion().setFromUnitVectors(MARKER_NORMAL, normal && normal.lengthSq() > 1e-12 ? normal.clone().normalize() : MARKER_NORMAL), [normal]);
+    const materials = useMemo(() => ({
+        halo: new MeshBasicNodeMaterial({
+            color: '#f8fafc',
+            depthTest: true,
+            depthWrite: false,
+            opacity: 0.96,
+            polygonOffset: true,
+            polygonOffsetFactor: -2,
+            polygonOffsetUnits: -2,
+            side: DoubleSide,
+            transparent: true,
+        }),
+        target: new MeshBasicNodeMaterial({
+            color: pinned ? '#0e7490' : '#0891b2',
+            depthTest: true,
+            depthWrite: false,
+            polygonOffset: true,
+            polygonOffsetFactor: -3,
+            polygonOffsetUnits: -3,
+            side: DoubleSide,
+        }),
+        center: new MeshBasicNodeMaterial({
+            color: '#0e7490',
+            depthTest: true,
+            depthWrite: false,
+            polygonOffset: true,
+            polygonOffsetFactor: -4,
+            polygonOffsetUnits: -4,
+            side: DoubleSide,
+        }),
+    }), [pinned]);
+    useLayoutEffect(() => {
+        if (!position && ref.current)
+            ref.current.visible = false;
+    }, [position, ref]);
+    useEffect(() => () => {
+        materials.halo.dispose();
+        materials.target.dispose();
+        materials.center.dispose();
+    }, [materials]);
+    useFrame(({ camera, size }) => {
+        const group = ref.current;
+        if (!group)
+            return;
+        group.getWorldPosition(worldPosition);
+        let worldUnitsPerPixel = 0.01;
+        if (camera.isPerspectiveCamera) {
+            const perspective = camera;
+            const depth = Math.abs(cameraPosition.copy(worldPosition).applyMatrix4(perspective.matrixWorldInverse).z);
+            worldUnitsPerPixel =
+                (2 * depth * Math.tan(MathUtils.degToRad(perspective.getEffectiveFOV() * 0.5))) /
+                    Math.max(size.height, 1);
+        }
+        else if (camera.isOrthographicCamera) {
+            const orthographic = camera;
+            worldUnitsPerPixel =
+                (orthographic.top - orthographic.bottom) / Math.max(orthographic.zoom * size.height, 1);
+        }
+        const scale = worldUnitsPerPixel * 13;
+        if (Number.isFinite(scale))
+            group.scale.setScalar(MathUtils.clamp(scale, 0.003, 0.42));
+    });
+    return (_jsxs("group", { position: position ?? MARKER_ORIGIN, quaternion: rotation, ref: ref, userData: MARKER_USER_DATA, children: [_jsx("mesh", { layers: EDITOR_LAYER, material: materials.halo, raycast: NO_RAYCAST, renderOrder: 1002, children: _jsx("ringGeometry", { args: HALO_RING_ARGS }) }), _jsx("mesh", { layers: EDITOR_LAYER, material: materials.target, raycast: NO_RAYCAST, renderOrder: 1003, children: _jsx("ringGeometry", { args: pinned ? PINNED_TARGET_RING_ARGS : LIVE_TARGET_RING_ARGS }) }), pinned ? (_jsx("mesh", { layers: EDITOR_LAYER, material: materials.center, raycast: NO_RAYCAST, renderOrder: 1004, children: _jsx("circleGeometry", { args: PINNED_CENTER_ARGS }) })) : null] }));
+});
+function showSmartSurfaceMarker(marker, levelObject, buildingObject, hit) {
+    if (!marker)
+        return;
+    levelObject.updateWorldMatrix(true, false);
+    buildingObject?.updateWorldMatrix(true, false);
+    marker.position.copy(localPointToBuildingFrame(levelObject, buildingObject, hit.point));
+    marker.quaternion.setFromUnitVectors(MARKER_NORMAL, localNormalToBuildingFrame(levelObject, buildingObject, hit.normal));
+    marker.visible = true;
+}
+function hideSmartSurfaceMarker(marker) {
+    if (marker)
+        marker.visible = false;
+}
+export function SmartMeasurementTool() {
+    const { camera, gl, scene } = useThree();
+    const buildingId = useViewer((state) => state.selection.buildingId);
+    const levelId = useViewer((state) => state.selection.levelId);
+    const levelRef = useRef(levelId);
+    const nodes = useScene((state) => state.nodes);
+    const hoverRef = useRef(null);
+    const hoverNodeIdRef = useRef(null);
+    const candidateNodeIdRef = useRef(undefined);
+    const candidateHasReportRef = useRef(false);
+    const candidateNodesRef = useRef(nodes);
+    const hoverMarkerRef = useRef(null);
+    const [hoverNodeId, setHoverNodeId] = useState(null);
+    const [pinned, setPinned] = useState(null);
+    const surfaceQuery = useMemo(() => createMeasurementSurfaceQuerySession(scene, { includeZoneLayer: true }), [scene]);
+    const hoverReport = useMemo(() => resolveQuickMeasurementReport(hoverNodeId, nodes), [hoverNodeId, nodes]);
+    const pinnedReport = useMemo(() => resolveQuickMeasurementReport(pinned?.targetNodeId ?? null, nodes), [pinned?.targetNodeId, nodes]);
+    useEffect(() => () => surfaceQuery.dispose(), [surfaceQuery]);
+    useEffect(() => {
+        if (levelRef.current === levelId)
+            return;
+        levelRef.current = levelId;
+        hoverRef.current = null;
+        hoverNodeIdRef.current = null;
+        candidateNodeIdRef.current = undefined;
+        candidateHasReportRef.current = false;
+        hideSmartSurfaceMarker(hoverMarkerRef.current);
+        setHoverNodeId(null);
+        setPinned(null);
+    }, [levelId]);
+    useEffect(() => {
+        const scope = useInteractionScope.getState();
+        scope.begin({ kind: 'drafting', tool: 'measurement' });
+        return () => {
+            useInteractionScope
+                .getState()
+                .endIf((active) => active.kind === 'drafting' && active.tool === 'measurement');
+        };
+    }, []);
+    useEffect(() => {
+        const canvas = gl.domElement;
+        const updateHover = (next, levelObject, buildingObject) => {
+            hoverRef.current = next;
+            if (next && levelObject) {
+                showSmartSurfaceMarker(hoverMarkerRef.current, levelObject, buildingObject ?? null, next);
+            }
+            else {
+                hideSmartSurfaceMarker(hoverMarkerRef.current);
+            }
+            const nextNodeId = next?.targetNodeId ?? null;
+            if (nextNodeId === hoverNodeIdRef.current)
+                return;
+            hoverNodeIdRef.current = nextNodeId;
+            setHoverNodeId(nextNodeId);
+        };
+        const processPointerMove = (event) => {
+            activateQuickMeasurementHudSource('3d');
+            if (useViewer.getState().cameraDragging || !levelId) {
+                updateHover(null);
+                return;
+            }
+            const levelObject = sceneRegistry.nodes.get(levelId);
+            if (!levelObject) {
+                updateHover(null);
+                return;
+            }
+            const buildingObject = buildingId
+                ? (sceneRegistry.nodes.get(buildingId) ?? null)
+                : null;
+            const resolved = surfaceQuery.resolvePointer({
+                event,
+                camera,
+                canvas,
+                levelObject,
+                anchorOrAnchors: null,
+                applyMagneticSnap: false,
+                showAlignmentGuides: false,
+            });
+            const sceneNodes = useScene.getState().nodes;
+            const next = resolved
+                ? resolveSmartMeasurementSurfaceHit(resolved.hit, sceneNodes, levelId)
+                : null;
+            if (candidateNodesRef.current !== sceneNodes) {
+                candidateNodesRef.current = sceneNodes;
+                candidateNodeIdRef.current = undefined;
+            }
+            const candidateNodeId = next?.targetNodeId ?? null;
+            if (candidateNodeId !== candidateNodeIdRef.current) {
+                candidateNodeIdRef.current = candidateNodeId;
+                candidateHasReportRef.current = Boolean(resolveQuickMeasurementReport(candidateNodeId, sceneNodes));
+            }
+            updateHover(candidateHasReportRef.current ? next : null, levelObject, buildingObject);
+        };
+        const pointerScheduler = createQuickMeasurementPointerScheduler(processPointerMove);
+        const onPointerMove = (event) => pointerScheduler.enqueue(event);
+        const clear = () => {
+            pointerScheduler.clear();
+            updateHover(null);
+        };
+        const onPointerLeave = (event) => {
+            if (document.elementFromPoint(event.clientX, event.clientY) === canvas)
+                return;
+            clear();
+        };
+        const onClick = (event) => {
+            const next = hoverRef.current;
+            if (!(next && event.button === 0) || useViewer.getState().cameraDragging)
+                return;
+            event.preventDefault();
+            event.stopImmediatePropagation();
+            activateQuickMeasurementHudSource('3d');
+            setPinned(next);
+        };
+        canvas.addEventListener('pointermove', onPointerMove, true);
+        canvas.addEventListener('pointerleave', onPointerLeave, true);
+        canvas.addEventListener('click', onClick, true);
+        return () => {
+            canvas.removeEventListener('pointermove', onPointerMove, true);
+            canvas.removeEventListener('pointerleave', onPointerLeave, true);
+            canvas.removeEventListener('click', onClick, true);
+            pointerScheduler.clear();
+        };
+    }, [buildingId, camera, gl, levelId, surfaceQuery]);
+    const pinnedPreview = useMemo(() => {
+        if (!levelId)
+            return null;
+        const levelObject = sceneRegistry.nodes.get(levelId);
+        if (!levelObject)
+            return null;
+        const buildingObject = buildingId
+            ? (sceneRegistry.nodes.get(buildingId) ?? null)
+            : null;
+        levelObject.updateWorldMatrix(true, false);
+        buildingObject?.updateWorldMatrix(true, false);
+        return pinned && pinnedReport
+            ? {
+                normal: localNormalToBuildingFrame(levelObject, buildingObject, pinned.normal),
+                position: localPointToBuildingFrame(levelObject, buildingObject, pinned.point),
+            }
+            : null;
+    }, [buildingId, levelId, pinned, pinnedReport]);
+    const activeHit = hoverReport ? hoverRef.current : pinnedReport ? pinned : null;
+    const report = hoverReport ?? pinnedReport;
+    const lensState = pinnedReport && activeHit?.targetNodeId === pinned?.targetNodeId
+        ? 'pinned'
+        : 'live';
+    useEffect(() => {
+        publishQuickMeasurementHudSource('3d', report ? { lensState, report } : null);
+    }, [lensState, report]);
+    useEffect(() => () => clearQuickMeasurementHudSource('3d'), []);
+    return (_jsxs("group", { children: [pinnedPreview ? (_jsx(SmartSurfaceMarker, { normal: pinnedPreview.normal, pinned: true, position: pinnedPreview.position })) : null, _jsx(SmartSurfaceMarker, { markerRef: hoverMarkerRef, pinned: false })] }));
+}
+export default SmartMeasurementTool;

package/dist/measurement/surface-query.d.ts

@@ -0,0 +1,90 @@
+import { type AlignmentAnchor, type MeasurementFeatureAnchor, type MeasurementSnapKind } from '@pascal-app/core';
+import type { MeasurementAxis, MeasurementAxisGuide, MeasurementPoint } from '@pascal-app/editor';
+import { type Camera, type Intersection, type Object3D, Raycaster, Vector3 } from 'three';
+export type MeasurementRaycastContext = {
+    ownerByObject: Map<Object3D, string>;
+    roots: Object3D[];
+    includeZoneLayer?: boolean;
+};
+export type WorldSurfaceHit = {
+    intersection: Intersection<Object3D>;
+    targetNodeId: string | null;
+};
+export type LocalSurfaceHit = {
+    point: MeasurementPoint;
+    normal: MeasurementPoint;
+    targetNodeId: string | null;
+};
+export type MeasurementSurfacePreference = {
+    kind: 'horizontal';
+} | {
+    kind: 'plane';
+    point: MeasurementPoint;
+    normal: MeasurementPoint;
+};
+export type MeasurementAxisProjection = {
+    axis: MeasurementAxis;
+    point: MeasurementPoint;
+};
+export type MeasurementAxisSurfaceIntersection = {
+    axis: MeasurementAxis;
+    normal: MeasurementPoint;
+    point: MeasurementPoint;
+};
+export type MeasurementAxisCandidate = MeasurementAxisProjection & {
+    anchor?: MeasurementPoint;
+    proximity?: boolean;
+    screenDistance: number;
+    verified: boolean;
+};
+export type MeasurementSurfaceQuerySession = {
+    resolvePointer(args: {
+        event: MouseEvent | PointerEvent;
+        camera: Camera;
+        canvas: HTMLCanvasElement;
+        levelObject: Object3D;
+        anchorOrAnchors: MeasurementPoint | readonly MeasurementPoint[] | null;
+        lockedGuide?: MeasurementAxisGuide | null;
+        planarProximityAnchors?: readonly AlignmentAnchor[];
+        surfacePreference?: MeasurementSurfacePreference | null;
+        applyMagneticSnap: boolean;
+        showAlignmentGuides: boolean;
+    }): {
+        hit: LocalSurfaceHit;
+        guide: MeasurementAxisGuide | null;
+    } | null;
+    collectAxisIntersections(args: {
+        levelObject: Object3D;
+        anchor: MeasurementPoint;
+        maxDistance?: number;
+    }): MeasurementAxisSurfaceIntersection[];
+    invalidate(): void;
+    dispose(): void;
+};
+export declare function projectMeasurementPointToAxes(anchor: MeasurementPoint, point: MeasurementPoint): MeasurementAxisProjection[];
+export declare function projectMeasurementPointToPlanarAxes(anchor: MeasurementPoint, point: MeasurementPoint): MeasurementAxisProjection[];
+export declare function selectClosestVerifiedAxisProjection(candidates: readonly MeasurementAxisCandidate[], threshold?: number, lockedAxis?: MeasurementAxis | null, releaseThreshold?: number, lockedFrom?: MeasurementPoint | null): MeasurementAxisProjection | null;
+export declare function selectAxisCandidateForSurfaceVerification<T extends MeasurementAxisCandidate>(candidates: readonly T[], threshold?: number, lockedAxis?: MeasurementAxis | null, releaseThreshold?: number, lockedFrom?: MeasurementPoint | null): T | null;
+export declare function measurementVertexSnapAnchors(points: readonly MeasurementPoint[], index: number, polygon: boolean): MeasurementPoint[];
+export declare function selectClosestMeasurementVertexIndex(screenDistances: readonly number[], threshold?: number): number | null;
+export declare function isMeasurementSurfaceMaterialVisible(object: Object3D, materialIndex?: number): boolean;
+export declare function collectMeasurementSurfaceRoots(scene: Object3D, registeredRoots: readonly Object3D[]): Object3D[];
+export declare function createMeasurementRaycastContext(scene: Object3D, options?: {
+    includeZoneLayer?: boolean;
+}): MeasurementRaycastContext;
+export declare function castVisibleMeasurementSurface(raycaster: Raycaster, context: MeasurementRaycastContext): WorldSurfaceHit | null;
+export declare function measurementIntersectionWorldNormal(intersection: Intersection<Object3D>): Vector3;
+export declare function selectMeasurementSurfaceHit(hits: readonly WorldSurfaceHit[], levelObject: Object3D, preference: MeasurementSurfacePreference | null): WorldSurfaceHit | null;
+export declare function worldPointScreenDistance(point: Vector3, event: MouseEvent | PointerEvent, camera: Camera, canvas: HTMLCanvasElement): number;
+export declare function createMeasurementSurfaceQuerySession(scene: Object3D, options?: {
+    includeZoneLayer?: boolean;
+}): MeasurementSurfaceQuerySession;
+export declare function associateSurfaceHit(hit: LocalSurfaceHit, maxDistance?: number): LocalSurfaceHit & {
+    anchor?: MeasurementFeatureAnchor;
+    semantic?: {
+        label: string;
+        length: number | null;
+        snapKind: MeasurementSnapKind;
+    };
+};
+//# sourceMappingURL=surface-query.d.ts.map

package/dist/measurement/surface-query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"surface-query.d.ts","sourceRoot":"","sources":["../../src/measurement/surface-query.ts"],"names":[],"mappings":"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"}