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

package/dist/shared/distribution-run-tool.js

@@ -0,0 +1,986 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { emitter, sceneRegistry, useScene } from '@pascal-app/core';
+import { CursorSphere, clearPlacementSurface, DimensionPill, getGridEventScreenProjection, isAngleSnapActive, isGridSnapActive, isMagneticSnapActive, markToolCancelConsumed, publishPlacementSurface, triggerSFX, useEditor, useInteractionScope, } from '@pascal-app/editor';
+import { Html } from '@react-three/drei';
+import { useThree } from '@react-three/fiber';
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { createPortal } from 'react-dom';
+import { Vector3 } from 'three';
+import { clearDrawAlignment } from './draw-alignment';
+import { resolveRunCursorPlane } from './run-cursor';
+import { RunDirectionFeedback, run3DDirectionCandidates, runHorizontalDirectionCandidates, } from './run-direction-feedback';
+import { findScreenPort } from './run-port-snap';
+import { chooseScreenDirection, screenDirectionScore } from './run-screen-direction';
+export function shouldLockRunWallSurface(target, connection) {
+    return target?.kind === 'wall' && !connection.port && !connection.body;
+}
+export function isSameRunWallSurface(target, hit) {
+    return (hit?.kind === 'wall' &&
+        hit.hostId === target.hostId &&
+        hit.face === 'side' &&
+        hit.side === target.side);
+}
+const UP = [0, 1, 0];
+const X_AXIS = [1, 0, 0];
+const Z_AXIS = [0, 0, 1];
+function dotRun(a, b) {
+    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+function crossRun(a, b) {
+    return [
+        a[1] * b[2] - a[2] * b[1],
+        a[2] * b[0] - a[0] * b[2],
+        a[0] * b[1] - a[1] * b[0],
+    ];
+}
+function normalizeRun(vector, fallback) {
+    const length = Math.hypot(vector[0], vector[1], vector[2]);
+    return length < 1e-9
+        ? [...fallback]
+        : [vector[0] / length, vector[1] / length, vector[2] / length];
+}
+/** Build a stable 2D drawing frame for a floor, wall, ceiling, or sloped face. */
+export function createRunSurfaceFrame(origin, surfaceNormal = UP) {
+    const normal = normalizeRun(surfaceNormal, UP);
+    // Prefer the building's vertical axis for walls and sloped surfaces. For a
+    // horizontal floor/ceiling this deliberately falls back to world X so the
+    // frame remains stable and matches the existing floor grid orientation.
+    const horizontal = Math.abs(dotRun(normal, UP)) > 0.98;
+    const tangent = horizontal
+        ? [...X_AXIS]
+        : normalizeRun(crossRun(UP, normal), X_AXIS);
+    const bitangent = horizontal
+        ? [...Z_AXIS]
+        : normalizeRun(crossRun(normal, tangent), Z_AXIS);
+    return {
+        origin: [origin[0], origin[1], origin[2]],
+        normal,
+        tangent,
+        bitangent,
+    };
+}
+export function projectRunPointToSurface(point, frame) {
+    const offset = [
+        point[0] - frame.origin[0],
+        point[1] - frame.origin[1],
+        point[2] - frame.origin[2],
+    ];
+    const distance = dotRun(offset, frame.normal);
+    return [
+        point[0] - frame.normal[0] * distance,
+        point[1] - frame.normal[1] * distance,
+        point[2] - frame.normal[2] * distance,
+    ];
+}
+export function snapRunPointToSurface(point, frame, step) {
+    const projected = projectRunPointToSurface(point, frame);
+    if (step <= 0)
+        return projected;
+    const offset = [
+        projected[0] - frame.origin[0],
+        projected[1] - frame.origin[1],
+        projected[2] - frame.origin[2],
+    ];
+    const u = snapRunValue(dotRun(offset, frame.tangent), step);
+    const v = snapRunValue(dotRun(offset, frame.bitangent), step);
+    return [
+        frame.origin[0] + frame.tangent[0] * u + frame.bitangent[0] * v,
+        frame.origin[1] + frame.tangent[1] * u + frame.bitangent[1] * v,
+        frame.origin[2] + frame.tangent[2] * u + frame.bitangent[2] * v,
+    ];
+}
+export function projectRunToSurfaceAngleLock(from, raw, frame, sourceDirection = null) {
+    const fromOffset = [
+        from[0] - frame.origin[0],
+        from[1] - frame.origin[1],
+        from[2] - frame.origin[2],
+    ];
+    const rawOffset = [raw[0] - from[0], raw[1] - from[1], raw[2] - from[2]];
+    const rawU = dotRun(rawOffset, frame.tangent);
+    const rawV = dotRun(rawOffset, frame.bitangent);
+    const sourceU = sourceDirection ? dotRun(sourceDirection, frame.tangent) : 0;
+    const sourceV = sourceDirection ? dotRun(sourceDirection, frame.bitangent) : 0;
+    const sourceAngle = sourceDirection && Math.hypot(sourceU, sourceV) > 1e-6
+        ? Math.atan2(sourceV, sourceU)
+        : Math.atan2(rawV, rawU);
+    const angle = Math.round(sourceAngle / ANGLE_STEP_RAD) * ANGLE_STEP_RAD;
+    const distance = Math.max(0, rawU * Math.cos(angle) + rawV * Math.sin(angle));
+    const u = dotRun(fromOffset, frame.tangent) + Math.cos(angle) * distance;
+    const v = dotRun(fromOffset, frame.bitangent) + Math.sin(angle) * distance;
+    return [
+        frame.origin[0] + frame.tangent[0] * u + frame.bitangent[0] * v,
+        frame.origin[1] + frame.tangent[1] * u + frame.bitangent[1] * v,
+        frame.origin[2] + frame.tangent[2] * u + frame.bitangent[2] * v,
+    ];
+}
+const ANGLE_STEP_RAD = Math.PI / 4;
+const ALT_PIXELS_PER_METER = 100;
+export const RUN_PREVIEW_OPACITY = 0.55;
+export const RUN_SNAP_CURSOR_COLOR = '#22c55e';
+export function runSectionHalfSizeM(nominalInches) {
+    return (nominalInches * 0.0254) / 2;
+}
+export function snapRunValue(value, step) {
+    if (step <= 0)
+        return value;
+    return Math.round(value / step) * step;
+}
+export function runDistanceSquared(a, b) {
+    const dx = a[0] - b[0];
+    const dy = a[1] - b[1];
+    const dz = a[2] - b[2];
+    return dx * dx + dy * dy + dz * dz;
+}
+export function projectRunToAngleLock(from, raw, sourceDirection = null) {
+    const dx = raw[0] - from[0];
+    const dz = raw[2] - from[2];
+    const length = Math.hypot(dx, dz);
+    if (length < 1e-4)
+        return [...from];
+    if (!sourceDirection) {
+        const angle = Math.round(Math.atan2(dz, dx) / ANGLE_STEP_RAD) * ANGLE_STEP_RAD;
+        const distance = Math.max(0, dx * Math.cos(angle) + dz * Math.sin(angle));
+        return [from[0] + Math.cos(angle) * distance, from[1], from[2] + Math.sin(angle) * distance];
+    }
+    const candidates = runHorizontalDirectionCandidates(sourceDirection);
+    let winner = candidates[0];
+    let winningProjection = Number.NEGATIVE_INFINITY;
+    for (const candidate of candidates) {
+        const projection = dx * candidate[0] + dz * candidate[2];
+        if (projection > winningProjection) {
+            winner = candidate;
+            winningProjection = projection;
+        }
+    }
+    const distance = Math.max(0, winningProjection);
+    return [from[0] + winner[0] * distance, from[1], from[2] + winner[2] * distance];
+}
+function dotRunVector(a, b) {
+    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+function normalizedRunVector(vector) {
+    const length = Math.hypot(vector[0], vector[1], vector[2]);
+    return length < 1e-9 ? null : [vector[0] / length, vector[1] / length, vector[2] / length];
+}
+export function snapRunLength(from, point, step) {
+    const delta = [point[0] - from[0], point[1] - from[1], point[2] - from[2]];
+    const length = Math.hypot(...delta);
+    if (step <= 0 || length < 1e-9)
+        return point;
+    const scale = snapRunValue(length, step) / length;
+    return [from[0] + delta[0] * scale, from[1] + delta[1] * scale, from[2] + delta[2] * scale];
+}
+export function projectRunToDirection(from, raw, direction) {
+    const distance = Math.max(0, dotRun([raw[0] - from[0], raw[1] - from[1], raw[2] - from[2]], direction));
+    return [
+        from[0] + direction[0] * distance,
+        from[1] + direction[1] * distance,
+        from[2] + direction[2] * distance,
+    ];
+}
+export function projectRunToCameraDirection(from, ray, sourceDirection, minimumDistance, gridStep, candidates = run3DDirectionCandidates(sourceDirection), surfaceFrame, screen) {
+    const rayDirection = normalizedRunVector(ray.direction);
+    if (!rayDirection)
+        return null;
+    const fromRayOrigin = [
+        ray.origin[0] - from[0],
+        ray.origin[1] - from[1],
+        ray.origin[2] - from[2],
+    ];
+    let winner = null;
+    let winningAim = Number.NEGATIVE_INFINITY;
+    const projectedCandidates = [];
+    const scores = [];
+    for (const direction of candidates) {
+        const parallel = dotRunVector(rayDirection, direction);
+        const denominator = 1 - parallel * parallel;
+        const projectedDistance = Math.abs(denominator) < 1e-9
+            ? minimumDistance
+            : (dotRunVector(fromRayOrigin, direction) -
+                parallel * dotRunVector(fromRayOrigin, rayDirection)) /
+                denominator;
+        const distance = Math.max(minimumDistance, snapRunValue(Math.max(projectedDistance, minimumDistance), gridStep));
+        const point = [
+            from[0] + direction[0] * distance,
+            from[1] + direction[1] * distance,
+            from[2] + direction[2] * distance,
+        ];
+        if (surfaceFrame &&
+            runDistanceSquared(point, projectRunPointToSurface(point, surfaceFrame)) > 1e-8) {
+            continue;
+        }
+        const aim = normalizedRunVector([
+            point[0] - ray.origin[0],
+            point[1] - ray.origin[1],
+            point[2] - ray.origin[2],
+        ]);
+        if (!aim)
+            continue;
+        if (screen) {
+            const origin = screen.project(from);
+            const tip = screen.project(from.map((value, i) => value + direction[i]));
+            scores.push(origin && tip ? screenDirectionScore(origin, tip, screen.pointer) : Infinity);
+            projectedCandidates.push({ point, direction });
+        }
+        const aimDot = dotRunVector(rayDirection, aim);
+        if (aimDot > winningAim) {
+            winningAim = aimDot;
+            winner = { point, direction };
+        }
+    }
+    if (screen) {
+        const previous = projectedCandidates.findIndex((candidate) => screen.previous && dotRunVector(candidate.direction, screen.previous) > 0.9999);
+        return projectedCandidates[chooseScreenDirection(scores, previous)] ?? null;
+    }
+    return winner;
+}
+export function stepNominalRunSize(sizes, current, direction) {
+    let nearest = 0;
+    for (let index = 1; index < sizes.length; index++) {
+        if (Math.abs(sizes[index] - current) < Math.abs(sizes[nearest] - current))
+            nearest = index;
+    }
+    return sizes[Math.min(sizes.length - 1, Math.max(0, nearest + direction))] ?? current;
+}
+function wallSurfaceBounds(hostId) {
+    const wall = useScene.getState().nodes[hostId];
+    if (wall?.type !== 'wall') {
+        return { minU: 0, maxU: 0, minV: 0, maxV: 0 };
+    }
+    return {
+        minU: 0,
+        maxU: Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]),
+        minV: 0,
+        maxV: Math.max(0, wall.height ?? 0),
+    };
+}
+function stableWallFrame(frame, hostId, activeLevelId) {
+    const wall = useScene.getState().nodes[hostId];
+    if (wall?.type !== 'wall')
+        return frame;
+    const origin = new Vector3(wall.start[0], 0, wall.start[1]);
+    const ownerLevel = wall.parentId ? sceneRegistry.nodes.get(wall.parentId) : null;
+    const activeLevel = activeLevelId ? sceneRegistry.nodes.get(activeLevelId) : null;
+    if (ownerLevel)
+        ownerLevel.localToWorld(origin);
+    if (activeLevel)
+        activeLevel.worldToLocal(origin);
+    return {
+        ...frame,
+        origin: projectRunPointToSurface(origin.toArray(), frame),
+    };
+}
+function publishRunSurface(target, point, activeLevelId) {
+    if (!target) {
+        clearPlacementSurface();
+        return;
+    }
+    const building = activeLevelId ? sceneRegistry.nodes.get(activeLevelId) : null;
+    const worldPoint = new Vector3(...point);
+    const worldAnchor = new Vector3(...target.frame.origin);
+    const worldNormalPoint = new Vector3(target.frame.origin[0] + target.frame.normal[0], target.frame.origin[1] + target.frame.normal[1], target.frame.origin[2] + target.frame.normal[2]);
+    if (building) {
+        building.localToWorld(worldPoint);
+        building.localToWorld(worldAnchor);
+        building.localToWorld(worldNormalPoint);
+    }
+    const worldNormal = worldNormalPoint.sub(worldAnchor).normalize();
+    publishPlacementSurface(worldPoint, worldNormal, 'fixed-plane', worldAnchor);
+}
+function surfacePointFromEvent(event, activeLevelId) {
+    const source = event.surfaceLocalPosition ?? event.localPosition;
+    const point = [source[0], source[1], source[2]];
+    const frame = createRunSurfaceFrame(point, event.surfaceNormal ?? UP);
+    const planeDistance = dotRun(point, frame.normal);
+    frame.origin = frame.normal.map((value) => value * planeDistance);
+    const floorLevelId = event.surfaceHit?.levelId ?? activeLevelId;
+    const wallNode = event.surfaceHit?.hostId
+        ? useScene.getState().nodes[event.surfaceHit.hostId]
+        : undefined;
+    // The selected level can legitimately remain on the ground floor while the
+    // cursor is over a wall on another storey. Resolve the wall's owning level
+    // from the hit node so the wall target cannot be downgraded to a floor target.
+    const wallLevelId = wallNode?.type === 'wall' ? wallNode.parentId : undefined;
+    const target = event.surfaceHit?.kind === 'wall' && event.surfaceHit.face === 'side' && wallLevelId
+        ? {
+            kind: 'wall',
+            levelId: wallLevelId,
+            hostId: event.surfaceHit.hostId,
+            side: event.surfaceHit.side ?? 'front',
+            frame: stableWallFrame(frame, event.surfaceHit.hostId, activeLevelId),
+            bounds: wallSurfaceBounds(event.surfaceHit.hostId),
+        }
+        : floorLevelId
+            ? {
+                kind: event.surfaceHit?.kind === 'ceiling' || frame.normal[1] < -0.98
+                    ? 'ceiling'
+                    : Math.abs(frame.normal[1]) > 0.98
+                        ? 'floor'
+                        : 'surface',
+                hostId: event.surfaceHit?.hostId,
+                levelId: floorLevelId,
+                frame,
+            }
+            : null;
+    return {
+        point,
+        frame: target?.frame ?? frame,
+        isHorizontal: event.surfaceNormal == null || Math.abs(frame.normal[1]) > 0.98,
+        target,
+    };
+}
+export function useDistributionRunTool(config) {
+    const { camera, gl } = useThree();
+    const initialStartRef = useRef(config.initialStart ? [...config.initialStart] : null);
+    const initialConnectionRef = useRef(config.initialConnection ?? { port: null, body: null });
+    const [start, setStart] = useState(initialStartRef.current);
+    const [cursor, setCursor] = useState(initialStartRef.current);
+    const [snapTarget, setSnapTarget] = useState(null);
+    const [snapScreen, setSnapScreen] = useState(null);
+    const [endConnection, setEndConnection] = useState({
+        port: null,
+        body: null,
+    });
+    const [altActive, setAltActive] = useState(false);
+    const [directionMode, setDirectionMode] = useState('free');
+    const [lengthInput, setLengthInput] = useState('');
+    const [validationMessage, setValidationMessage] = useState(null);
+    const configRef = useRef(config);
+    configRef.current = config;
+    const startRef = useRef(start);
+    startRef.current = start;
+    const startConnectionRef = useRef(initialConnectionRef.current);
+    const altAnchorRef = useRef(null);
+    const lastPointerRef = useRef(null);
+    const refreshCursorRef = useRef(() => { });
+    const lastClientYRef = useRef(null);
+    const lastResolvedRef = useRef(null);
+    const lockedWallTargetRef = useRef(null);
+    const forcedDirectionRef = useRef(null);
+    const hoveredDirectionRef = useRef(null);
+    const lengthInputRef = useRef('');
+    useEffect(() => {
+        if (!config.active)
+            return;
+        const toolName = config.toolName;
+        useInteractionScope.getState().begin({ kind: 'drafting', tool: toolName });
+        return () => {
+            useInteractionScope
+                .getState()
+                .endIf((scope) => scope.kind === 'drafting' && scope.tool === toolName);
+            clearPlacementSurface();
+        };
+    }, [config.active, config.toolName]);
+    const refreshCursor = useCallback(() => refreshCursorRef.current(), []);
+    const updateLengthInput = useCallback((value) => {
+        const normalized = value.replace(',', '.').replace(/[^0-9.]/g, '');
+        const firstDot = normalized.indexOf('.');
+        const cleaned = firstDot < 0
+            ? normalized
+            : `${normalized.slice(0, firstDot + 1)}${normalized.slice(firstDot + 1).replace(/\./g, '')}`;
+        lengthInputRef.current = cleaned.slice(0, 12);
+        setLengthInput(lengthInputRef.current);
+        refreshCursorRef.current();
+    }, []);
+    useEffect(() => {
+        if (!config.active)
+            return;
+        const applyTypedLength = (resolved) => {
+            const currentStart = startRef.current;
+            const typed = Number.parseFloat(lengthInputRef.current);
+            if (!currentStart ||
+                !Number.isFinite(typed) ||
+                typed <= 0 ||
+                resolved.port ||
+                resolved.body) {
+                return resolved;
+            }
+            const direction = normalizedRunVector([
+                resolved.point[0] - currentStart[0],
+                resolved.point[1] - currentStart[1],
+                resolved.point[2] - currentStart[2],
+            ]);
+            if (!direction)
+                return resolved;
+            return {
+                ...resolved,
+                point: [
+                    currentStart[0] + direction[0] * typed,
+                    currentStart[1] + direction[1] * typed,
+                    currentStart[2] + direction[2] * typed,
+                ],
+                snapped: null,
+                directionMode: resolved.directionMode,
+            };
+        };
+        const resolvePoint = (event) => {
+            const adapter = configRef.current;
+            const hit = surfacePointFromEvent(event, adapter.levelId);
+            const currentStart = startRef.current;
+            const previous = lastResolvedRef.current;
+            const lockedWallTarget = currentStart ? lockedWallTargetRef.current : null;
+            const lockedWallHit = lockedWallTarget && isSameRunWallSurface(lockedWallTarget, event.surfaceHit);
+            const working = lockedWallTarget
+                ? {
+                    ...lockedWallTarget.frame,
+                    origin: lockedWallTarget.frame.origin.map((value, index) => value +
+                        lockedWallTarget.frame.normal[index] *
+                            (adapter.surfaceClearance?.(lockedWallTarget) ?? 0)),
+                }
+                : !event.surfaceHit && previous?.surfaceTarget?.kind === 'wall' && currentStart
+                    ? createRunSurfaceFrame(currentStart, UP)
+                    : (previous?.frame ?? (currentStart ? createRunSurfaceFrame(currentStart) : null));
+            const hasSurface = !!event.surfaceHit || !working || !event.localRay;
+            const target = lockedWallTarget ?? (hasSurface ? hit.target : null);
+            const hitForCursor = lockedWallTarget
+                ? lockedWallHit
+                    ? { point: hit.point, frame: lockedWallTarget.frame }
+                    : null
+                : hasSurface
+                    ? { point: hit.point, frame: hit.frame }
+                    : null;
+            const resolved = resolveRunCursorPlane({
+                hit: hitForCursor,
+                working,
+                ray: event.localRay,
+                fallback: previous?.point ?? currentStart ?? hit.point,
+                clearance: adapter.surfaceClearance?.(target) ?? 0,
+            });
+            const bypass = event.nativeEvent?.altKey === true;
+            const gridStep = !bypass && isGridSnapActive() ? useEditor.getState().gridSnapStep : 0;
+            const angleLocked = !bypass && (isAngleSnapActive() || isGridSnapActive());
+            let point = currentStart
+                ? resolved.point
+                : snapRunPointToSurface(resolved.point, resolved.frame, gridStep);
+            const forcedDirection = forcedDirectionRef.current;
+            if (currentStart && forcedDirection) {
+                point = projectRunToDirection(currentStart, point, forcedDirection);
+            }
+            if (currentStart && angleLocked && !forcedDirection) {
+                const from = projectRunPointToSurface(currentStart, resolved.frame);
+                if (runDistanceSquared(from, currentStart) < 1e-6) {
+                    point = projectRunToSurfaceAngleLock(currentStart, point, resolved.frame);
+                }
+            }
+            if (currentStart && gridStep > 0) {
+                point = snapRunLength(currentStart, point, gridStep);
+            }
+            const sample = { frame: resolved.frame, surfaceTarget: target };
+            const native = (event.nativeEvent ?? {});
+            const screenProjection = getGridEventScreenProjection(event);
+            const pointer = screenProjection?.pointer ?? [native.clientX ?? NaN, native.clientY ?? NaN];
+            const rect = gl.domElement.getBoundingClientRect();
+            const level = adapter.levelId ? sceneRegistry.nodes.get(adapter.levelId) : null;
+            const origin = camera.getWorldPosition(new Vector3());
+            const projectConnection = (candidate) => {
+                if (screenProjection) {
+                    const [a, b, c, d, e, f] = screenProjection.localToScreen;
+                    return {
+                        x: a * candidate[0] + c * candidate[2] + e,
+                        y: b * candidate[0] + d * candidate[2] + f,
+                        depth: 0,
+                    };
+                }
+                const world = new Vector3(...candidate);
+                if (level)
+                    level.localToWorld(world);
+                const projected = world.clone().project(camera);
+                if (projected.z < -1 || projected.z > 1)
+                    return null;
+                if (event.surfaceHit &&
+                    world.distanceTo(origin) > new Vector3(...event.position).distanceTo(origin) + 0.03)
+                    return null;
+                return {
+                    x: rect.left + ((projected.x + 1) * rect.width) / 2,
+                    y: rect.top + ((1 - projected.y) * rect.height) / 2,
+                    depth: world.distanceTo(origin),
+                };
+            };
+            const acceptsConnection = (candidate) => {
+                const screen = projectConnection(candidate);
+                return !!screen && Math.hypot(screen.x - pointer[0], screen.y - pointer[1]) <= 12;
+            };
+            const resolveConnection = (candidate) => {
+                if (bypass || !(isGridSnapActive() || isMagneticSnapActive() || isAngleSnapActive()))
+                    return null;
+                const source = startConnectionRef.current.port;
+                const hit = findScreenPort(adapter.getPorts(), pointer, projectConnection, source);
+                if (hit) {
+                    return {
+                        frame: createRunSurfaceFrame([...hit.port.position]),
+                        surfaceTarget: null,
+                        point: [...hit.port.position],
+                        snapped: [...hit.port.position],
+                        snapScreen: hit.screen,
+                        directionMode: 'snap',
+                        port: hit.port,
+                        body: null,
+                    };
+                }
+                const body = adapter.findBody(candidate, target);
+                if (body && acceptsConnection(body.point) && body.nodeId !== source?.nodeId) {
+                    return {
+                        ...sample,
+                        point: body.point,
+                        snapped: body.point,
+                        directionMode: 'snap',
+                        port: null,
+                        body,
+                    };
+                }
+                return null;
+            };
+            const connection = resolveConnection(resolved.point);
+            if (connection)
+                return connection;
+            // Rank displayed directions before a surface projection discards height.
+            if (currentStart && event.localRay && !bypass && (forcedDirection || angleLocked)) {
+                const source = startConnectionRef.current.port?.direction ?? null;
+                const candidates = forcedDirection
+                    ? [forcedDirection]
+                    : source
+                        ? run3DDirectionCandidates(source)
+                        : runHorizontalDirectionCandidates(null);
+                const directionHit = projectRunToCameraDirection(currentStart, event.localRay, source ?? X_AXIS, adapter.minimumSegmentLength ?? 0.05, gridStep, candidates, (target?.kind === 'wall' || target?.kind === 'ceiling') && !forcedDirection
+                    ? resolved.frame
+                    : undefined, !forcedDirection && event.nativeEvent
+                    ? {
+                        project: (candidate) => {
+                            const level = adapter.levelId ? sceneRegistry.nodes.get(adapter.levelId) : null;
+                            const world = new Vector3(...candidate);
+                            if (level)
+                                level.localToWorld(world);
+                            world.project(camera);
+                            if (world.z < -1 || world.z > 1)
+                                return null;
+                            const rect = gl.domElement.getBoundingClientRect();
+                            return [
+                                rect.left + ((world.x + 1) * rect.width) / 2,
+                                rect.top + ((1 - world.y) * rect.height) / 2,
+                            ];
+                        },
+                        pointer: [event.nativeEvent.clientX, event.nativeEvent.clientY],
+                        previous: hoveredDirectionRef.current,
+                    }
+                    : undefined);
+                if (directionHit) {
+                    hoveredDirectionRef.current = directionHit.direction;
+                    const directionConnection = resolveConnection(directionHit.point);
+                    if (directionConnection)
+                        return directionConnection;
+                    return {
+                        point: Math.abs(directionHit.direction[1]) < 1e-6 && target?.kind !== 'ceiling'
+                            ? (adapter.resolveFreeEnd?.(currentStart, directionHit.point, startConnectionRef.current) ?? directionHit.point)
+                            : directionHit.point,
+                        frame: event.surfaceHit && !forcedDirection
+                            ? resolved.frame
+                            : createRunSurfaceFrame(currentStart),
+                        surfaceTarget: forcedDirection ||
+                            (Math.abs(directionHit.direction[1]) > 1e-6 && target?.kind === 'floor')
+                            ? null
+                            : target,
+                        snapped: null,
+                        directionMode: 'angle',
+                        port: null,
+                        body: null,
+                    };
+                }
+            }
+            if (currentStart && target?.kind !== 'ceiling' && Math.abs(resolved.frame.normal[1]) > 0.98) {
+                point = adapter.resolveFreeEnd?.(currentStart, point, startConnectionRef.current) ?? point;
+            }
+            return {
+                ...sample,
+                point,
+                snapped: null,
+                directionMode: angleLocked ? 'angle' : 'free',
+                port: null,
+                body: null,
+            };
+        };
+        const resolveVerticalPoint = (clientY) => {
+            const anchor = altAnchorRef.current;
+            const currentStart = startRef.current;
+            if (!anchor || !currentStart)
+                return null;
+            const step = isGridSnapActive() ? useEditor.getState().gridSnapStep : 0;
+            const delta = snapRunValue((anchor.clientY - clientY) / ALT_PIXELS_PER_METER, step);
+            const y = anchor.baseY + delta;
+            return [currentStart[0], y, currentStart[2]];
+        };
+        const updateCursor = (resolved) => {
+            if (!resolved.frame && lastResolvedRef.current?.frame)
+                resolved = {
+                    ...resolved,
+                    frame: { ...lastResolvedRef.current.frame, origin: resolved.point },
+                    surfaceTarget: lockedWallTargetRef.current,
+                };
+            lastResolvedRef.current = resolved;
+            const currentStart = startRef.current;
+            const minimumLength = configRef.current.minimumSegmentLength ?? 0.05;
+            const length = currentStart
+                ? Math.hypot(resolved.point[0] - currentStart[0], resolved.point[1] - currentStart[1], resolved.point[2] - currentStart[2])
+                : 0;
+            const typed = lengthInputRef.current;
+            setValidationMessage(currentStart &&
+                typed &&
+                (!Number.isFinite(Number.parseFloat(typed)) || Number.parseFloat(typed) <= 0)
+                ? 'Enter a positive length'
+                : currentStart && length < minimumLength
+                    ? `Run must be at least ${minimumLength.toFixed(2)} m`
+                    : null);
+            setCursor(resolved.point);
+            setSnapTarget(resolved.snapped);
+            setSnapScreen(resolved.snapScreen ?? null);
+            setEndConnection({
+                port: resolved.port,
+                body: resolved.port ? null : resolved.body,
+            });
+            setDirectionMode(resolved.directionMode);
+            if (resolved.frame)
+                publishRunSurface({
+                    kind: 'surface',
+                    levelId: configRef.current.levelId,
+                    frame: resolved.frame,
+                }, resolved.point, configRef.current.levelId);
+        };
+        const commit = (end, connection) => {
+            const currentStart = startRef.current;
+            if (!currentStart)
+                return;
+            if (lengthInputRef.current && !(Number(lengthInputRef.current) > 0))
+                return;
+            const minimumLength = configRef.current.minimumSegmentLength ?? 0.05;
+            const length = Math.hypot(end[0] - currentStart[0], end[1] - currentStart[1], end[2] - currentStart[2]);
+            if (length < minimumLength) {
+                return;
+            }
+            const capturedTarget = lastResolvedRef.current?.surfaceTarget ?? null;
+            const clearance = configRef.current.surfaceClearance?.(capturedTarget) ?? 0;
+            const surfaceTarget = capturedTarget?.kind === 'wall' &&
+                [currentStart, end].some((point) => {
+                    const projected = projectRunPointToSurface(point, capturedTarget.frame);
+                    return Math.abs(Math.sqrt(runDistanceSquared(point, projected)) - clearance) > 1e-4;
+                })
+                ? null
+                : capturedTarget;
+            const result = configRef.current.commit({
+                start: currentStart,
+                end,
+                startConnection: startConnectionRef.current,
+                endConnection: connection,
+                surfaceTarget,
+            });
+            if (!result) {
+                setValidationMessage('Fitting clearance is too small for this connection');
+                return;
+            }
+            const lockedWallTarget = lockedWallTargetRef.current;
+            if (lockedWallTarget) {
+                const offset = result.nextStart.map((value, index) => value - lockedWallTarget.frame.origin[index]);
+                const clearance = configRef.current.surfaceClearance?.(lockedWallTarget) ?? 0;
+                if (Math.abs(dotRun(offset, lockedWallTarget.frame.normal) - clearance) > 1e-4) {
+                    lockedWallTargetRef.current = null;
+                    lastResolvedRef.current = {
+                        point: result.nextStart,
+                        frame: createRunSurfaceFrame(result.nextStart),
+                        surfaceTarget: null,
+                        snapped: null,
+                        directionMode: 'free',
+                        port: null,
+                        body: null,
+                    };
+                    clearPlacementSurface();
+                }
+            }
+            triggerSFX('sfx:item-place');
+            startRef.current = result.nextStart;
+            setStart(result.nextStart);
+            setSnapTarget(null);
+            setSnapScreen(null);
+            setEndConnection({ port: null, body: null });
+            lengthInputRef.current = '';
+            setLengthInput('');
+            setValidationMessage(null);
+            startConnectionRef.current = result.nextConnection;
+            forcedDirectionRef.current = null;
+            hoveredDirectionRef.current = null;
+            altAnchorRef.current = null;
+            setAltActive(false);
+        };
+        const onMove = (event) => {
+            lastPointerRef.current = event;
+            const clientY = event.nativeEvent?.clientY;
+            if (typeof clientY === 'number')
+                lastClientYRef.current = clientY;
+            if (altAnchorRef.current && typeof clientY === 'number') {
+                const point = resolveVerticalPoint(clientY);
+                if (point) {
+                    clearDrawAlignment();
+                    updateCursor({
+                        point,
+                        snapped: null,
+                        port: null,
+                        body: null,
+                        directionMode: 'vertical',
+                    });
+                    return;
+                }
+            }
+            updateCursor(applyTypedLength(resolvePoint(event)));
+        };
+        const onClick = (event) => {
+            event.nativeEvent?.stopPropagation?.();
+            const currentStart = startRef.current;
+            if (altAnchorRef.current && currentStart) {
+                const clientY = event.nativeEvent?.clientY ?? lastClientYRef.current;
+                if (typeof clientY === 'number') {
+                    const point = resolveVerticalPoint(clientY);
+                    if (point && Math.abs(point[1] - currentStart[1]) >= 1e-4) {
+                        commit(point, { port: null, body: null });
+                    }
+                }
+                return;
+            }
+            const resolved = applyTypedLength(resolvePoint(event));
+            updateCursor(resolved);
+            if (!currentStart) {
+                const connection = {
+                    port: resolved.port,
+                    body: resolved.port ? null : resolved.body,
+                };
+                if (shouldLockRunWallSurface(resolved.surfaceTarget, connection)) {
+                    lockedWallTargetRef.current = resolved.surfaceTarget;
+                }
+                triggerSFX('sfx:grid-snap');
+                startConnectionRef.current = connection;
+                configRef.current.inheritFromConnection?.(connection);
+                startRef.current = resolved.point;
+                setStart(resolved.point);
+                setCursor(resolved.point);
+                setSnapTarget(resolved.snapped);
+                setSnapScreen(resolved.snapScreen ?? null);
+                setEndConnection({ port: null, body: null });
+                return;
+            }
+            const typedResolved = applyTypedLength(resolved);
+            commit(typedResolved.point, {
+                port: resolved.port,
+                body: resolved.port ? null : resolved.body,
+            });
+        };
+        const onKeyDown = (event) => {
+            const target = event.target;
+            const tag = target?.tagName;
+            const isLengthField = target ? target.closest('[data-run-length-input]') !== null : false;
+            if ((tag === 'INPUT' || tag === 'TEXTAREA' || tag === 'SELECT' || tag === 'BUTTON') &&
+                !isLengthField)
+                return;
+            if (event.key === 'Escape' && startRef.current) {
+                event.preventDefault();
+                event.stopImmediatePropagation();
+                onCancel();
+                useEditor.getState().armToolMode({ mode: 'select' });
+                return;
+            }
+            if (event.key === 'Alt') {
+                const currentStart = startRef.current;
+                if (!currentStart || lastClientYRef.current === null || altAnchorRef.current)
+                    return;
+                event.preventDefault();
+                altAnchorRef.current = {
+                    clientY: lastClientYRef.current,
+                    baseY: currentStart[1],
+                };
+                setAltActive(true);
+                return;
+            }
+            if (event.key === 'Tab' &&
+                startRef.current &&
+                !event.altKey &&
+                !event.metaKey &&
+                !event.ctrlKey) {
+                event.preventDefault();
+                event.stopImmediatePropagation();
+                const source = startConnectionRef.current.port?.direction;
+                const candidates = source
+                    ? run3DDirectionCandidates(source)
+                    : runHorizontalDirectionCandidates(null);
+                const current = forcedDirectionRef.current ?? hoveredDirectionRef.current;
+                const index = candidates.findIndex((direction) => current && dotRunVector(direction, current) > 0.9999);
+                forcedDirectionRef.current =
+                    candidates[(index + (event.shiftKey ? candidates.length - 1 : 1)) % candidates.length];
+                refreshCursorRef.current();
+                return;
+            }
+            if (startRef.current && isLengthField && /^[0-9.,]$/.test(event.key)) {
+                event.stopImmediatePropagation();
+                return;
+            }
+            if (startRef.current && !isLengthField && /^[0-9.,]$/.test(event.key)) {
+                event.preventDefault();
+                event.stopImmediatePropagation();
+                updateLengthInput(`${lengthInputRef.current}${event.key}`);
+                return;
+            }
+            if (startRef.current && event.key === 'Enter') {
+                event.preventDefault();
+                event.stopImmediatePropagation();
+                const resolved = lastResolvedRef.current;
+                if (resolved) {
+                    const typedResolved = applyTypedLength(resolved);
+                    commit(typedResolved.point, {
+                        port: typedResolved.port,
+                        body: typedResolved.port ? null : typedResolved.body,
+                    });
+                }
+                return;
+            }
+            configRef.current.onShortcut?.(event, startRef.current);
+        };
+        const onKeyUp = (event) => {
+            if (event.key !== 'Alt' || !altAnchorRef.current)
+                return;
+            event.preventDefault();
+            altAnchorRef.current = null;
+            setAltActive(false);
+            setDirectionMode('free');
+        };
+        const onCancel = () => {
+            lockedWallTargetRef.current = null;
+            clearDrawAlignment();
+            if (!startRef.current)
+                return;
+            markToolCancelConsumed();
+            startRef.current = null;
+            setStart(null);
+            setCursor(null);
+            setSnapTarget(null);
+            setSnapScreen(null);
+            setEndConnection({ port: null, body: null });
+            lengthInputRef.current = '';
+            setLengthInput('');
+            setValidationMessage(null);
+            startConnectionRef.current = { port: null, body: null };
+            forcedDirectionRef.current = null;
+            hoveredDirectionRef.current = null;
+            lastPointerRef.current = null;
+            clearPlacementSurface();
+            lastResolvedRef.current = null;
+            altAnchorRef.current = null;
+            setAltActive(false);
+        };
+        refreshCursorRef.current = () => {
+            if (lastPointerRef.current)
+                updateCursor(applyTypedLength(resolvePoint(lastPointerRef.current)));
+            else if (lastResolvedRef.current)
+                updateCursor(applyTypedLength(lastResolvedRef.current));
+        };
+        const unsubscribeSnapping = useEditor.subscribe((state, previous) => {
+            const modeChanged = state.snappingModeByContext !== previous.snappingModeByContext;
+            if (!modeChanged && state.gridSnapStep === previous.gridSnapStep)
+                return;
+            if (modeChanged) {
+                forcedDirectionRef.current = null;
+                hoveredDirectionRef.current = null;
+            }
+            refreshCursorRef.current();
+        });
+        emitter.on('grid:click', onClick);
+        emitter.on('grid:move', onMove);
+        emitter.on('tool:cancel', onCancel);
+        window.addEventListener('keydown', onKeyDown, true);
+        window.addEventListener('keyup', onKeyUp);
+        return () => {
+            unsubscribeSnapping();
+            emitter.off('grid:click', onClick);
+            emitter.off('grid:move', onMove);
+            emitter.off('tool:cancel', onCancel);
+            window.removeEventListener('keydown', onKeyDown, true);
+            window.removeEventListener('keyup', onKeyUp);
+            altAnchorRef.current = null;
+            lastPointerRef.current = null;
+            lockedWallTargetRef.current = null;
+            refreshCursorRef.current = () => { };
+            clearPlacementSurface();
+            clearDrawAlignment();
+        };
+    }, [camera, gl, config.active, updateLengthInput]);
+    return {
+        refreshCursor,
+        start,
+        cursor,
+        snapTarget,
+        snapScreen,
+        altActive,
+        directionMode,
+        lengthInput,
+        validationMessage,
+        onLengthInputChange: updateLengthInput,
+        onDirectionSelect: (direction) => {
+            forcedDirectionRef.current = direction;
+            setDirectionMode('angle');
+            refreshCursorRef.current();
+        },
+        startConnection: startConnectionRef.current,
+        endConnection,
+        surfaceTarget: lastResolvedRef.current?.surfaceTarget ?? null,
+    };
+}
+export function DistributionRunCursor({ cursor, start, snapTarget, snapScreen, altActive, unit, extraParts = [], cursorRef, directionMode, startDirection, lengthInput, validationMessage, onLengthInputChange, onDirectionSelect, }) {
+    const lengthFieldRef = useRef(null);
+    useEffect(() => {
+        if (start)
+            lengthFieldRef.current?.focus();
+    }, [start]);
+    if (!cursor)
+        return null;
+    const parts = [
+        ...(start
+            ? [
+                {
+                    key: 'length',
+                    prefix: 'L',
+                    value: Math.hypot(cursor[0] - start[0], cursor[1] - start[1], cursor[2] - start[2]),
+                },
+            ]
+            : []),
+        {
+            key: 'x',
+            prefix: 'X',
+            value: start ? cursor[0] - start[0] : cursor[0],
+            signed: !!start,
+        },
+        {
+            key: 'y',
+            prefix: 'Y',
+            value: start ? cursor[1] - start[1] : cursor[1],
+            signed: !!start,
+        },
+        {
+            key: 'z',
+            prefix: 'Z',
+            value: start ? cursor[2] - start[2] : cursor[2],
+            signed: !!start,
+        },
+        ...extraParts,
+    ];
+    const primary = start ? (altActive ? 'y' : 'length') : undefined;
+    const elevated = cursor[1] > 0.001;
+    const ground = [cursor[0], 0, cursor[2]];
+    return (_jsxs(_Fragment, { children: [snapScreen && (_jsx(Html, { style: { pointerEvents: 'none' }, children: createPortal(_jsx("div", { style: {
+                        position: 'fixed',
+                        left: snapScreen.x,
+                        top: snapScreen.y,
+                        pointerEvents: 'none',
+                        zIndex: 110,
+                    }, children: _jsx("div", { className: "absolute h-5 w-5 -translate-x-1/2 -translate-y-1/2 rounded-full border-2 border-emerald-500 bg-emerald-500/20 ring-2 ring-background" }) }), document.body) })), start && (_jsx(RunDirectionFeedback, { cursor: cursor, mode: directionMode, snapped: !!snapTarget, sourceDirection: startDirection ?? null, start: start, onDirectionSelect: onDirectionSelect })), _jsx(CursorSphere, { color: snapTarget ? RUN_SNAP_CURSOR_COLOR : undefined, dotAtTip: elevated || undefined, height: elevated ? cursor[1] : undefined, position: elevated ? ground : cursor, ref: cursorRef }), _jsx("group", { position: cursor, children: _jsx(Html, { center: true, position: [0, 1.45, 0], style: { pointerEvents: 'none', userSelect: 'none' }, zIndexRange: [100, 0], children: _jsxs("div", { className: "flex flex-col items-center gap-1", children: [_jsx(DimensionPill, { parts: parts, primary: primary, unit: unit }), start ? (_jsxs("label", { className: "rounded-full border border-border/60 bg-background/90 px-3 py-1 text-[11px] tabular-nums text-muted-foreground shadow-sm backdrop-blur", children: ["Length:", ' ', _jsx("input", { className: "w-20 bg-transparent text-center text-foreground outline-none", "data-run-length-input": true, inputMode: "decimal", onKeyDown: (event) => {
+                                            if (event.key === 'Backspace' ||
+                                                event.key === 'Delete' ||
+                                                event.key === 'ArrowLeft' ||
+                                                event.key === 'ArrowRight') {
+                                                event.stopPropagation();
+                                            }
+                                        }, onChange: (event) => onLengthInputChange?.(event.target.value), onPointerDown: (event) => event.stopPropagation(), placeholder: "type a length", ref: lengthFieldRef, style: { pointerEvents: 'auto' }, type: "text", value: lengthInput ?? '' }), ' ', "m", _jsx("span", { className: "ml-2", children: "Tab: direction" })] })) : null, validationMessage ? (_jsx("div", { className: "rounded-full border border-red-500/50 bg-red-500/10 px-3 py-1 text-[11px] text-red-700 shadow-sm backdrop-blur dark:text-red-300", children: validationMessage })) : null] }) }) })] }));
+}