@pascal-app/nodes 0.1.1

package/dist/liquid-line/tool.js

@@ -0,0 +1,517 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { emitter, LiquidLineNode, useScene, } from '@pascal-app/core';
+import { CursorSphere, DimensionPill, EDITOR_LAYER, isAngleSnapActive, isGridSnapActive, isMagneticSnapActive, markToolCancelConsumed, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { Html } from '@react-three/drei';
+import { useEffect, useRef, useState } from 'react';
+import { Vector3 } from 'three';
+import { alignDrawPoint, clearDrawAlignment } from '../shared/draw-alignment';
+import { LevelOffsetGroup } from '../shared/level-offset-group';
+import { offsetPathHorizontal } from '../shared/path-offset';
+import { collectScenePorts, findNearestPortXZ, REFRIGERANT_PORT_SYSTEMS } from '../shared/ports';
+import { liquidLineDefinition } from './definition';
+import { useLiquidLineToolOptions } from './options';
+/**
+ * Continuous placement tool for standalone liquid lines — the same draw model
+ * as the lineset tool (the line it used to be a rail of):
+ *   - **First click** anchors the run start; within range of a refrigerant
+ *     service port it snaps onto it so a run mates flush.
+ *   - **Second click** commits a two-point line and keeps its far end anchored,
+ *     so the next click continues the run; the in-flight end follows the active
+ *     snapping mode (`angles` locks it to 45°; Shift cycles the mode), Alt drags
+ *     it vertical.
+ *
+ * **Follow mode** (toggled by the MEP panel's Follow button or the `F` key):
+ * instead of free-drawing, hover an existing lineset and click — a liquid line
+ * is laid beside it, tracing the lineset's whole path at a fixed offset on the
+ * side the cursor is on. This is the "place it exactly next to this" affordance.
+ */
+const PREVIEW_OPACITY = 0.6;
+const PREVIEW_COLOR = '#b06b3f';
+/** Snap radius (meters) for joining onto a refrigerant port. */
+const ENDPOINT_SNAP_RADIUS_M = 0.5;
+/** Angle step (radians) for the XZ angle lock — 45°. */
+const ANGLE_STEP_RAD = Math.PI / 4;
+/** Mouse pixels → meters mapping for Alt-vertical drag. 100 px ≈ 1 m. */
+const ALT_PIXELS_PER_METER = 100;
+const ALT_Y_MIN_M = -3;
+const ALT_Y_MAX_M = 10;
+const IN_TO_M = 0.0254;
+/** Default liquid OD (~3/8") — the ghost radius and trace-line size. */
+const DEFAULT_DIAMETER_IN = 0.375;
+const GHOST_RADIUS_M = (DEFAULT_DIAMETER_IN * IN_TO_M) / 2;
+/** Matches the lineset's foam-jacket thickness so the traced line sits just
+ *  outside an insulated suction line, exactly where the old paired rail was. */
+const INSULATION_THICKNESS_M = 0.01;
+/** How close (meters, XZ) the cursor must be to a lineset path to trace it. */
+const FOLLOW_PICK_RADIUS_M = 0.6;
+/** Clear-air gap (meters) between the lineset's outer surface and the traced
+ *  liquid line, so the new run reads as its own line instead of fusing onto
+ *  the lineset (~2"). */
+const FOLLOW_GAP_M = 0.05;
+function snap(value, step) {
+    if (step <= 0)
+        return value;
+    return Math.round(value / step) * step;
+}
+/** Nearest refrigerant port within snap range on the XZ plane, as a position
+ * tuple. Y is ignored for the distance check; the snap adopts the port's full
+ * 3D position. */
+function findNearbyPort(point) {
+    const port = findNearestPortXZ(point, collectScenePorts({ systems: REFRIGERANT_PORT_SYSTEMS }), ENDPOINT_SNAP_RADIUS_M);
+    return port ? [port.position[0], port.position[1], port.position[2]] : null;
+}
+function projectToAngleLock(from, raw) {
+    const dx = raw[0] - from[0];
+    const dz = raw[2] - from[2];
+    const len = Math.hypot(dx, dz);
+    if (len < 1e-4)
+        return [from[0], from[1], from[2]];
+    const theta = Math.atan2(dz, dx);
+    const snapped = Math.round(theta / ANGLE_STEP_RAD) * ANGLE_STEP_RAD;
+    const proj = dx * Math.cos(snapped) + dz * Math.sin(snapped);
+    const d = Math.max(0, proj);
+    return [from[0] + Math.cos(snapped) * d, from[1], from[2] + Math.sin(snapped) * d];
+}
+/** Distance (XZ) from point `p` to segment `a`→`b`. */
+function distToSegmentXZ(p, a, b) {
+    const dx = b[0] - a[0];
+    const dz = b[2] - a[2];
+    const len2 = dx * dx + dz * dz;
+    let t = len2 > 0 ? ((p[0] - a[0]) * dx + (p[2] - a[2]) * dz) / len2 : 0;
+    t = Math.max(0, Math.min(1, t));
+    const cx = a[0] + t * dx;
+    const cz = a[2] + t * dz;
+    return Math.hypot(p[0] - cx, p[2] - cz);
+}
+/** Center-to-center offset (meters) that drops the liquid line a small gap
+ *  outside the lineset's outer surface, so the two read as separate lines. */
+function traceOffsetMeters(lineset) {
+    const suctionR = (lineset.suctionDiameter * IN_TO_M) / 2;
+    const jacket = lineset.insulated ? INSULATION_THICKNESS_M : 0;
+    return suctionR + jacket + FOLLOW_GAP_M + GHOST_RADIUS_M;
+}
+/** Coincidence tolerance (meters) for treating two endpoints as the same joint
+ *  when chaining linesets — the draw tool snaps endpoints exactly, so this only
+ *  needs to absorb float drift. */
+const JOINT_EPS_M = 1e-3;
+function samePt(a, b) {
+    return (Math.abs(a[0] - b[0]) < JOINT_EPS_M &&
+        Math.abs(a[1] - b[1]) < JOINT_EPS_M &&
+        Math.abs(a[2] - b[2]) < JOINT_EPS_M);
+}
+/** Quantized coordinate key so endpoints sharing a joint hash together. */
+function jointKey(p) {
+    return `${Math.round(p[0] / JOINT_EPS_M)},${Math.round(p[1] / JOINT_EPS_M)},${Math.round(p[2] / JOINT_EPS_M)}`;
+}
+/**
+ * Walk the chain of linesets joined end-to-end at shared joint coordinates,
+ * starting from `start`, into one continuous centerline. Follows a joint only
+ * when it has a single unvisited continuation (degree-2) — a branch / junction
+ * (degree ≥ 3) ends the run so the trace stays a simple path.
+ */
+function assembleRun(start, linesets) {
+    const byJoint = new Map();
+    for (const ls of linesets) {
+        const a = ls.path[0];
+        const b = ls.path[ls.path.length - 1];
+        for (const key of [jointKey(a), jointKey(b)]) {
+            const arr = byJoint.get(key);
+            if (arr)
+                arr.push(ls);
+            else
+                byJoint.set(key, [ls]);
+        }
+    }
+    const visited = new Set([start.id]);
+    let points = start.path.map((p) => [...p]);
+    // Grow the run one lineset at a time off the chosen terminal, until a joint
+    // has no unique continuation. `atEnd` extends after the last point; otherwise
+    // before the first.
+    const grow = (atEnd) => {
+        for (;;) {
+            const terminal = atEnd ? points[points.length - 1] : points[0];
+            const next = (byJoint.get(jointKey(terminal)) ?? []).filter((ls) => !visited.has(ls.id));
+            if (next.length !== 1)
+                break;
+            const node = next[0];
+            visited.add(node.id);
+            const np = node.path.map((p) => [...p]);
+            if (atEnd) {
+                if (samePt(np[np.length - 1], terminal))
+                    np.reverse(); // np must start at terminal
+                points = [...points, ...np.slice(1)];
+            }
+            else {
+                if (samePt(np[0], terminal))
+                    np.reverse(); // np must end at terminal
+                points = [...np.slice(0, np.length - 1), ...points];
+            }
+        }
+    };
+    grow(true);
+    grow(false);
+    return points;
+}
+/** Cursor side relative to the assembled run's nearest segment, as the offset
+ *  sign for `offsetPathHorizontal`. */
+function sideSign(path, point) {
+    let bestD = Number.POSITIVE_INFINITY;
+    let bi = 0;
+    for (let i = 0; i < path.length - 1; i++) {
+        const d = distToSegmentXZ(point, path[i], path[i + 1]);
+        if (d < bestD) {
+            bestD = d;
+            bi = i;
+        }
+    }
+    const a = path[bi];
+    const b = path[bi + 1];
+    // Side vector = normalize(heading_xz) × UP = (-hz, 0, hx).
+    const hx = b[0] - a[0];
+    const hz = b[2] - a[2];
+    const hlen = Math.hypot(hx, hz);
+    const sx = hlen > 1e-9 ? -hz / hlen : 0;
+    const sz = hlen > 1e-9 ? hx / hlen : 0;
+    return (point[0] - a[0]) * sx + (point[2] - a[2]) * sz >= 0 ? 1 : -1;
+}
+/**
+ * Nearest lineset within `FOLLOW_PICK_RADIUS_M` of the cursor, expanded into
+ * the whole connected run it belongs to. Restricted to the active level.
+ */
+function findFollowTarget(point, levelId) {
+    const scene = useScene.getState();
+    const linesets = [];
+    for (const n of Object.values(scene.nodes)) {
+        if (n?.type !== 'lineset')
+            continue;
+        if (n.parentId !== levelId)
+            continue;
+        const ls = n;
+        if (ls.path.length >= 2)
+            linesets.push(ls);
+    }
+    let hovered = null;
+    let bestD = FOLLOW_PICK_RADIUS_M;
+    for (const ls of linesets) {
+        for (let i = 0; i < ls.path.length - 1; i++) {
+            const d = distToSegmentXZ(point, ls.path[i], ls.path[i + 1]);
+            if (d >= bestD)
+                continue;
+            bestD = d;
+            hovered = ls;
+        }
+    }
+    if (!hovered)
+        return null;
+    const path = assembleRun(hovered, linesets);
+    if (path.length < 2)
+        return null;
+    return { path, sign: sideSign(path, point), lineset: hovered };
+}
+/** The offset centerline a follow-target would trace, or null if degenerate. */
+function tracePath(target) {
+    const offset = target.sign * traceOffsetMeters(target.lineset);
+    const traced = offsetPathHorizontal(target.path, offset);
+    return traced.length >= 2 ? traced : null;
+}
+const LiquidLineTool = () => {
+    const activeLevelId = useViewer((s) => s.selection.levelId);
+    const unit = useViewer((s) => s.unit);
+    const follow = useLiquidLineToolOptions((s) => s.follow);
+    const cursorRef = useRef(null);
+    const [draftPoints, setDraftPoints] = useState([]);
+    const [cursorPos, setCursorPos] = useState(null);
+    const [snapTarget, setSnapTarget] = useState(null);
+    const [traceGhost, setTraceGhost] = useState(null);
+    const [altActive, setAltActive] = useState(false);
+    const draftRef = useRef(draftPoints);
+    draftRef.current = draftPoints;
+    const followTargetRef = useRef(null);
+    const altAnchorRef = useRef(null);
+    const lastClientYRef = useRef(null);
+    // Clear in-flight draft / trace whenever Follow toggles (panel button or F).
+    // biome-ignore lint/correctness/useExhaustiveDependencies: `follow` is an intentional re-run trigger; the body clears the in-flight draft when it toggles.
+    useEffect(() => {
+        setDraftPoints([]);
+        setTraceGhost(null);
+        followTargetRef.current = null;
+        altAnchorRef.current = null;
+        setAltActive(false);
+    }, [follow]);
+    // Leaving the tool clears Follow so re-arming it starts in free-draw.
+    useEffect(() => () => useLiquidLineToolOptions.getState().setFollow(false), []);
+    useEffect(() => {
+        if (!activeLevelId)
+            return;
+        const commitSegment = (start, end) => {
+            const sameSpot = Math.abs(start[0] - end[0]) < 1e-4 &&
+                Math.abs(start[1] - end[1]) < 1e-4 &&
+                Math.abs(start[2] - end[2]) < 1e-4;
+            if (sameSpot)
+                return;
+            // Each drawn segment is its own standalone two-point liquid-line node.
+            // Independent nodes mean each segment selects and deletes on its own,
+            // rather than folding into one mitered polyline run.
+            const line = LiquidLineNode.parse({
+                ...liquidLineDefinition.defaults(),
+                name: 'Liquid Line',
+                path: [start, end],
+            });
+            useScene.getState().createNode(line, activeLevelId);
+            triggerSFX('sfx:item-place');
+            setDraftPoints([end]);
+            setSnapTarget(null);
+            altAnchorRef.current = null;
+            setAltActive(false);
+        };
+        // Lay liquid lines beside the whole connected lineset run, tracing its
+        // assembled centerline at the offset. One two-point node per segment so the
+        // result stays per-segment selectable, matching free-drawn liquid lines.
+        const commitTrace = (target) => {
+            const traced = tracePath(target);
+            if (!traced)
+                return;
+            const defaults = liquidLineDefinition.defaults();
+            const create = [];
+            for (let i = 0; i < traced.length - 1; i++) {
+                const a = traced[i];
+                const b = traced[i + 1];
+                if (samePt(a, b))
+                    continue;
+                const node = LiquidLineNode.parse({ ...defaults, name: 'Liquid Line', path: [a, b] });
+                create.push({ node, parentId: activeLevelId });
+            }
+            if (create.length === 0)
+                return;
+            useScene.getState().applyNodeChanges({ create });
+            triggerSFX('sfx:item-place');
+            setTraceGhost(null);
+            followTargetRef.current = null;
+        };
+        const resolveSnappedPoint = (event) => {
+            // Port mating is the run's primary affordance; it stays on in every
+            // snapping mode except `off` (the raw-cursor bypass).
+            const snapEnabled = isGridSnapActive() || isMagneticSnapActive() || isAngleSnapActive();
+            const last = draftRef.current.at(-1);
+            if (!last) {
+                const raw = [event.localPosition[0], 0, event.localPosition[2]];
+                if (event.nativeEvent?.altKey !== true && snapEnabled) {
+                    const target = findNearbyPort(raw);
+                    if (target)
+                        return { point: target, snapped: target };
+                }
+                const step = isGridSnapActive() ? useEditor.getState().gridSnapStep : 0;
+                return { point: [snap(raw[0], step), 0, snap(raw[2], step)], snapped: null };
+            }
+            const rawXZ = [event.localPosition[0], last[1], event.localPosition[2]];
+            // The 45° lock is now the `angles` snapping mode (Shift cycles to it),
+            // not a held key.
+            const angled = isAngleSnapActive() ? projectToAngleLock(last, rawXZ) : rawXZ;
+            if (event.nativeEvent?.altKey !== true && snapEnabled) {
+                const target = findNearbyPort(rawXZ);
+                if (target)
+                    return { point: target, snapped: target };
+            }
+            const step = isGridSnapActive() ? useEditor.getState().gridSnapStep : 0;
+            return { point: [snap(angled[0], step), angled[1], snap(angled[2], step)], snapped: null };
+        };
+        const resolveAltVerticalPoint = (clientY) => {
+            const anchor = altAnchorRef.current;
+            const last = draftRef.current.at(-1);
+            if (!anchor || !last)
+                return null;
+            const step = isGridSnapActive() ? useEditor.getState().gridSnapStep : 0;
+            const dy = (anchor.clientY - clientY) / ALT_PIXELS_PER_METER;
+            const snappedDy = snap(dy, step);
+            const y = Math.min(ALT_Y_MAX_M, Math.max(ALT_Y_MIN_M, anchor.baseY + snappedDy));
+            return [last[0], y, last[2]];
+        };
+        const resolveAlignedPoint = (event) => {
+            const r = resolveSnappedPoint(event);
+            const hasStart = draftRef.current.length > 0;
+            const alt = event.nativeEvent?.altKey === true;
+            const point = alignDrawPoint(r.point, {
+                applySnap: isMagneticSnapActive() && (!hasStart || !isAngleSnapActive()),
+                bypass: alt || r.snapped !== null,
+            });
+            return { ...r, point };
+        };
+        const onMove = (event) => {
+            // Follow mode: track the lineset under the cursor and preview its trace.
+            if (useLiquidLineToolOptions.getState().follow) {
+                const raw = [event.localPosition[0], 0, event.localPosition[2]];
+                clearDrawAlignment();
+                setCursorPos(raw);
+                setSnapTarget(null);
+                const target = findFollowTarget(raw, activeLevelId);
+                followTargetRef.current = target;
+                setTraceGhost(target ? tracePath(target) : null);
+                return;
+            }
+            const clientY = event.nativeEvent?.clientY;
+            if (typeof clientY === 'number')
+                lastClientYRef.current = clientY;
+            if (altAnchorRef.current && typeof clientY === 'number') {
+                const point = resolveAltVerticalPoint(clientY);
+                if (point) {
+                    clearDrawAlignment();
+                    setCursorPos(point);
+                    setSnapTarget(null);
+                    return;
+                }
+            }
+            const { point, snapped } = resolveAlignedPoint(event);
+            setCursorPos(point);
+            setSnapTarget(snapped);
+        };
+        const onClick = (event) => {
+            // Follow mode: a click commits the trace beside the hovered lineset.
+            if (useLiquidLineToolOptions.getState().follow) {
+                const target = followTargetRef.current;
+                if (target)
+                    commitTrace(target);
+                return;
+            }
+            const start = draftRef.current.at(-1);
+            if (altAnchorRef.current && start) {
+                const clientY = event.nativeEvent?.clientY ?? lastClientYRef.current;
+                if (typeof clientY === 'number') {
+                    const point = resolveAltVerticalPoint(clientY);
+                    if (point && Math.abs(point[1] - start[1]) >= 1e-4) {
+                        commitSegment(start, point);
+                    }
+                }
+                return;
+            }
+            const { point } = resolveAlignedPoint(event);
+            if (!start) {
+                triggerSFX('sfx:grid-snap');
+                setDraftPoints([point]);
+                return;
+            }
+            commitSegment(start, point);
+        };
+        const enterAltMode = () => {
+            if (useLiquidLineToolOptions.getState().follow)
+                return;
+            const last = draftRef.current.at(-1);
+            if (!last || lastClientYRef.current === null)
+                return;
+            if (altAnchorRef.current)
+                return;
+            altAnchorRef.current = { clientY: lastClientYRef.current, baseY: last[1] };
+            setAltActive(true);
+        };
+        const exitAltMode = () => {
+            if (!altAnchorRef.current)
+                return;
+            altAnchorRef.current = null;
+            setAltActive(false);
+        };
+        const onKeyDown = (e) => {
+            const tag = e.target?.tagName;
+            if (tag === 'INPUT' || tag === 'TEXTAREA')
+                return;
+            if (e.key === 'f' || e.key === 'F') {
+                e.preventDefault();
+                useLiquidLineToolOptions.getState().toggleFollow();
+                return;
+            }
+            if (e.key === 'Alt') {
+                e.preventDefault();
+                enterAltMode();
+            }
+        };
+        const onKeyUp = (e) => {
+            if (e.key === 'Alt') {
+                e.preventDefault();
+                exitAltMode();
+            }
+        };
+        const onCancel = () => {
+            clearDrawAlignment();
+            if (draftRef.current.length === 0 && !followTargetRef.current)
+                return;
+            markToolCancelConsumed();
+            setDraftPoints([]);
+            setCursorPos(null);
+            setSnapTarget(null);
+            setTraceGhost(null);
+            followTargetRef.current = null;
+        };
+        emitter.on('grid:move', onMove);
+        emitter.on('grid:click', onClick);
+        emitter.on('tool:cancel', onCancel);
+        window.addEventListener('keydown', onKeyDown);
+        window.addEventListener('keyup', onKeyUp);
+        return () => {
+            emitter.off('grid:move', onMove);
+            emitter.off('grid:click', onClick);
+            emitter.off('tool:cancel', onCancel);
+            window.removeEventListener('keydown', onKeyDown);
+            window.removeEventListener('keyup', onKeyUp);
+            altAnchorRef.current = null;
+            clearDrawAlignment();
+        };
+    }, [activeLevelId]);
+    if (!activeLevelId)
+        return null;
+    const previewSegments = [];
+    for (let i = 0; i < draftPoints.length - 1; i++) {
+        previewSegments.push({ a: draftPoints[i], b: draftPoints[i + 1] });
+    }
+    const last = draftPoints.at(-1);
+    if (last && cursorPos) {
+        previewSegments.push({ a: last, b: cursorPos });
+    }
+    const traceSegments = [];
+    if (traceGhost) {
+        for (let i = 0; i < traceGhost.length - 1; i++) {
+            traceSegments.push({ a: traceGhost[i], b: traceGhost[i + 1] });
+        }
+    }
+    const pillParts = cursorPos
+        ? ['x', 'y', 'z'].map((axis, i) => ({
+            key: axis,
+            prefix: axis.toUpperCase(),
+            value: last ? cursorPos[i] - last[i] : cursorPos[i],
+            signed: !!last,
+        }))
+        : null;
+    const pillPrimary = last && cursorPos
+        ? altActive
+            ? 'y'
+            : Math.abs(cursorPos[0] - last[0]) >= Math.abs(cursorPos[2] - last[2])
+                ? 'x'
+                : 'z'
+        : undefined;
+    return (_jsxs(LevelOffsetGroup, { children: [cursorPos && (_jsxs(_Fragment, { children: [_jsx(CursorSphere, { color: PREVIEW_COLOR, position: cursorPos, ref: cursorRef }), follow ? (_jsx("group", { position: cursorPos, children: _jsx(Html, { center: true, position: [0, 1.45, 0], style: { pointerEvents: 'none', userSelect: 'none' }, zIndexRange: [100, 0], children: _jsx("div", { style: {
+                                    background: 'rgba(17,17,20,0.85)',
+                                    border: '1px solid rgba(176,107,63,0.6)',
+                                    borderRadius: 6,
+                                    color: '#f3e7dd',
+                                    fontSize: 11,
+                                    padding: '3px 7px',
+                                    whiteSpace: 'nowrap',
+                                }, children: followTargetRef.current
+                                    ? 'Click to trace this lineset run'
+                                    : 'Follow: hover a lineset' }) }) })) : (pillParts && (_jsx("group", { position: cursorPos, children: _jsx(Html, { center: true, position: [0, 1.45, 0], style: { pointerEvents: 'none', userSelect: 'none' }, zIndexRange: [100, 0], children: _jsx(DimensionPill, { parts: pillParts, primary: pillPrimary, unit: unit }) }) })))] })), snapTarget && (_jsxs("mesh", { layers: EDITOR_LAYER, position: snapTarget, children: [_jsx("sphereGeometry", { args: [0.1, 24, 16] }), _jsx("meshBasicMaterial", { color: PREVIEW_COLOR, depthTest: false, opacity: 0.35, transparent: true })] })), draftPoints.map((p, i) => (_jsxs("mesh", { layers: EDITOR_LAYER, position: p, children: [_jsx("sphereGeometry", { args: [0.05, 16, 12] }), _jsx("meshBasicMaterial", { color: PREVIEW_COLOR, depthTest: false })] }, `pt-${i}`))), previewSegments.map((seg, i) => (_jsx(PreviewSegment, { a: seg.a, b: seg.b }, `seg-${i}`))), traceSegments.map((seg, i) => (_jsx(PreviewSegment, { a: seg.a, b: seg.b }, `trace-${i}`)))] }));
+};
+function PreviewSegment({ a, b }) {
+    const start = new Vector3(...a);
+    const end = new Vector3(...b);
+    const dir = new Vector3().subVectors(end, start);
+    const length = dir.length();
+    if (length < 1e-4)
+        return null;
+    dir.normalize();
+    const mid = new Vector3().addVectors(start, end).multiplyScalar(0.5);
+    return (_jsxs("mesh", { layers: EDITOR_LAYER, position: mid.toArray(), ref: (m) => {
+            if (!m)
+                return;
+            m.quaternion.setFromUnitVectors(new Vector3(0, 1, 0), dir);
+        }, children: [_jsx("cylinderGeometry", { args: [GHOST_RADIUS_M, GHOST_RADIUS_M, length, 16, 1, false] }), _jsx("meshBasicMaterial", { color: PREVIEW_COLOR, depthTest: false, opacity: PREVIEW_OPACITY, transparent: true })] }));
+}
+export default LiquidLineTool;

package/dist/measurement/definition.d.ts

@@ -0,0 +1,4 @@
+import { type NodeDefinition } from '@pascal-app/core';
+import { MeasurementNode } from './schema';
+export declare const measurementDefinition: NodeDefinition<typeof MeasurementNode>;
+//# sourceMappingURL=definition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/measurement/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAA+B,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAGnF,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE1C,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC,OAAO,eAAe,CA+DxE,CAAA"}

package/dist/measurement/definition.js

@@ -0,0 +1,61 @@
+import { measurementReferenceNodeIds } from '@pascal-app/core';
+import { buildMeasurementFloorplan } from './floorplan';
+import { measurementMoveVertexAffordance } from './floorplan-affordance';
+import { MeasurementNode } from './schema';
+export const measurementDefinition = {
+    kind: 'measurement',
+    bake: 'strip',
+    snapProfile: 'structural',
+    schemaVersion: 2,
+    schema: MeasurementNode,
+    category: 'analysis',
+    defaults: () => ({
+        object: 'node',
+        parentId: null,
+        visible: true,
+        metadata: {},
+        measurement: {
+            kind: 'distance',
+            points: [
+                [0, 0, 0],
+                [1, 0, 0],
+            ],
+        },
+    }),
+    capabilities: {
+        selectable: { hitVolume: 'bbox' },
+        deletable: true,
+        duplicable: true,
+        presettable: false,
+    },
+    dirtyTracking: false,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer'),
+    },
+    floorplan: buildMeasurementFloorplan,
+    floorplanDependencies: (node) => measurementReferenceNodeIds(node.measurement),
+    floorplanAffordances: {
+        'move-measurement-vertex': measurementMoveVertexAffordance,
+    },
+    affordanceTools: {
+        selection: () => import('./selection'),
+    },
+    tool: () => import('./tool-router'),
+    toolHints: [
+        { key: 'Left click', label: 'Place measurement point' },
+        { key: 'Enter', label: 'Finish measurement' },
+        { key: 'Backspace', label: 'Remove last point' },
+        { key: 'Esc', label: 'Finish and continue' },
+    ],
+    presentation: {
+        label: 'Measurement',
+        description: 'A persistent distance, angle, area, perimeter, or volume annotation.',
+        icon: { kind: 'iconify', name: 'lucide:ruler' },
+        hidden: true,
+        actionMenu: false,
+    },
+    mcp: {
+        description: 'A persistent level-local distance, angle, area, perimeter, or volume measurement.',
+    },
+};

package/dist/measurement/edit.d.ts

@@ -0,0 +1,9 @@
+import { type MeasurementAnchor, type MeasurementPayload, type MeasurementPoint } from '@pascal-app/core';
+import type { ResolvedMeasurementPayload } from './resolve';
+export declare function measurementResolvedEditPoints(measurement: ResolvedMeasurementPayload): MeasurementPoint[];
+export declare function refreshMeasurementAnchorFallbacks(measurement: MeasurementPayload, resolved: ResolvedMeasurementPayload): MeasurementPayload;
+export declare function replaceMeasurementAnchor(measurement: MeasurementPayload, index: number, anchor: MeasurementAnchor): MeasurementPayload | null;
+export declare function constrainMeasurementSpatialEditPoint(measurement: ResolvedMeasurementPayload, point: MeasurementPoint): MeasurementPoint;
+export declare function constrainMeasurementPlanEditPoint(measurement: ResolvedMeasurementPayload, index: number, planPoint: readonly [number, number]): MeasurementPoint | null;
+export declare function measurementEditAnchor(measurement: ResolvedMeasurementPayload, point: MeasurementPoint, associatedAnchor?: MeasurementAnchor): MeasurementAnchor;
+//# sourceMappingURL=edit.d.ts.map

package/dist/measurement/edit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit.d.ts","sourceRoot":"","sources":["../../src/measurement/edit.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACvB,KAAK,gBAAgB,EAGtB,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,WAAW,CAAA;AAE3D,wBAAgB,6BAA6B,CAC3C,WAAW,EAAE,0BAA0B,GACtC,gBAAgB,EAAE,CAIpB;AA4BD,wBAAgB,iCAAiC,CAC/C,WAAW,EAAE,kBAAkB,EAC/B,QAAQ,EAAE,0BAA0B,GACnC,kBAAkB,CAOpB;AAED,wBAAgB,wBAAwB,CACtC,WAAW,EAAE,kBAAkB,EAC/B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,iBAAiB,GACxB,kBAAkB,GAAG,IAAI,CAS3B;AAQD,wBAAgB,oCAAoC,CAClD,WAAW,EAAE,0BAA0B,EACvC,KAAK,EAAE,gBAAgB,GACtB,gBAAgB,CAelB;AAED,wBAAgB,iCAAiC,CAC/C,WAAW,EAAE,0BAA0B,EACvC,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,GACnC,gBAAgB,GAAG,IAAI,CAsBzB;AAED,wBAAgB,qBAAqB,CACnC,WAAW,EAAE,0BAA0B,EACvC,KAAK,EAAE,gBAAgB,EACvB,gBAAgB,CAAC,EAAE,iBAAiB,GACnC,iBAAiB,CAUnB"}