@pascal-app/nodes 0.1.1

package/dist/shared/polygon-vertex-affordance.js

@@ -0,0 +1,325 @@
+import { useScene, } from '@pascal-app/core';
+import { getSegmentGridStep, snapPointToGrid, snapScalarToGrid, } from '@pascal-app/editor';
+function getRing(node, holeIndex) {
+    if (holeIndex === undefined) {
+        return node.polygon.map(([x, y]) => [x, y]);
+    }
+    const hole = node.holes?.[holeIndex];
+    if (!hole)
+        return null;
+    return hole.map(([x, y]) => [x, y]);
+}
+/**
+ * Returns a patch object that, when applied to the node, updates the
+ * targeted ring (boundary polygon or specific hole) to `nextRing`. The
+ * cast through `unknown → Partial<unknown> → never` satisfies the
+ * generic `updateNodes` patch type without forcing every variant of
+ * the kind union into scope here.
+ */
+function buildRingPatch(node, holeIndex, nextRing, boundaryCommitData) {
+    if (holeIndex === undefined) {
+        return { ...boundaryCommitData, polygon: nextRing };
+    }
+    const nextHoles = (node.holes ?? []).map((hole, i) => i === holeIndex ? nextRing : hole.map(([x, y]) => [x, y]));
+    return { holes: nextHoles };
+}
+function resolveAffordancePlanPoint(options, context) {
+    return options?.resolvePlanPoint?.(context) ?? context.fallbackPoint;
+}
+export function createPolygonVertexAffordance(kind, options) {
+    return {
+        start({ node, payload, nodes }) {
+            const { vertexIndex, holeIndex } = payload;
+            const originalRing = getRing(node, holeIndex);
+            if (!originalRing) {
+                return {
+                    affectedIds: [node.id],
+                    apply() { },
+                    canCommit() {
+                        return false;
+                    },
+                };
+            }
+            return {
+                affectedIds: [node.id],
+                apply({ planPoint, modifiers }) {
+                    const rawPoint = [planPoint[0], planPoint[1]];
+                    // Mode-driven grid snap (matches the chip): `getSegmentGridStep()` is
+                    // 0 in any non-`grid` mode, so `lines` / `off` pass the raw point
+                    // through (the resolver's wall-snap/alignment handles `lines`); `grid`
+                    // quantizes to the live grid step. No Shift hold-to-bypass.
+                    const fallbackPoint = snapPointToGrid(rawPoint, getSegmentGridStep());
+                    const snapped = resolveAffordancePlanPoint(options, {
+                        node,
+                        nodes,
+                        rawPoint,
+                        fallbackPoint,
+                        modifiers,
+                        holeIndex,
+                        mode: 'move-vertex',
+                    });
+                    const nextRing = originalRing.map((p, i) => i === vertexIndex ? [snapped[0], snapped[1]] : p);
+                    const patch = buildRingPatch(node, holeIndex, nextRing, options?.boundaryCommitData);
+                    useScene
+                        .getState()
+                        .updateNodes([{ id: node.id, data: patch }]);
+                },
+                canCommit() {
+                    const final = useScene.getState().nodes[node.id];
+                    if (!final || final.type !== kind)
+                        return false;
+                    const finalRing = holeIndex === undefined ? final.polygon : (final.holes ?? [])[holeIndex];
+                    return !!finalRing && finalRing.length >= 3;
+                },
+            };
+        },
+    };
+}
+/**
+ * Companion to `createPolygonVertexAffordance`. Inserts a new vertex at
+ * the midpoint of edge `edgeIndex` (between vertices i and i+1) and
+ * then drags that new vertex with the pointer. The dispatcher's
+ * snapshot was taken **before** `start()` ran, so a pointer-up without
+ * movement reverts to the pre-insert ring — "click without drag" is a
+ * no-op, matching the legacy slab boundary editor.
+ */
+export function createPolygonAddVertexAffordance(kind, options) {
+    return {
+        start({ node, payload, nodes }) {
+            const { edgeIndex, holeIndex } = payload;
+            const originalRing = getRing(node, holeIndex);
+            if (!originalRing) {
+                return {
+                    affectedIds: [node.id],
+                    apply() { },
+                    canCommit() {
+                        return false;
+                    },
+                };
+            }
+            const a = originalRing[edgeIndex];
+            const b = originalRing[(edgeIndex + 1) % originalRing.length];
+            if (!a || !b) {
+                return {
+                    affectedIds: [node.id],
+                    apply() { },
+                    canCommit() {
+                        return false;
+                    },
+                };
+            }
+            const midpoint = [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2];
+            const newVertexIndex = edgeIndex + 1;
+            const initialRing = [
+                ...originalRing.slice(0, newVertexIndex),
+                midpoint,
+                ...originalRing.slice(newVertexIndex),
+            ];
+            // Apply the insert immediately so the user sees the new vertex
+            // before they even move.
+            const initialPatch = buildRingPatch(node, holeIndex, initialRing, options?.boundaryCommitData);
+            useScene
+                .getState()
+                .updateNodes([{ id: node.id, data: initialPatch }]);
+            return {
+                affectedIds: [node.id],
+                apply({ planPoint, modifiers }) {
+                    const rawPoint = [planPoint[0], planPoint[1]];
+                    // Mode-driven grid snap (matches the chip): `getSegmentGridStep()` is
+                    // 0 in any non-`grid` mode, so `lines` / `off` pass the raw point
+                    // through (the resolver's wall-snap/alignment handles `lines`); `grid`
+                    // quantizes to the live grid step. No Shift hold-to-bypass.
+                    const fallbackPoint = snapPointToGrid(rawPoint, getSegmentGridStep());
+                    const snapped = resolveAffordancePlanPoint(options, {
+                        node,
+                        nodes,
+                        rawPoint,
+                        fallbackPoint,
+                        modifiers,
+                        holeIndex,
+                        mode: 'add-vertex',
+                    });
+                    const nextRing = initialRing.map((p, i) => i === newVertexIndex ? [snapped[0], snapped[1]] : p);
+                    const patch = buildRingPatch(node, holeIndex, nextRing, options?.boundaryCommitData);
+                    useScene
+                        .getState()
+                        .updateNodes([{ id: node.id, data: patch }]);
+                },
+                canCommit() {
+                    const final = useScene.getState().nodes[node.id];
+                    if (!final || final.type !== kind)
+                        return false;
+                    const finalRing = holeIndex === undefined ? final.polygon : (final.holes ?? [])[holeIndex];
+                    return !!finalRing && finalRing.length >= 3;
+                },
+            };
+        },
+    };
+}
+export function createPolygonDeleteVertexAffordance(kind, options) {
+    return {
+        start({ node, payload }) {
+            const { vertexIndex, holeIndex } = payload;
+            const canDeleteCurrentVertex = () => {
+                const current = useScene.getState().nodes[node.id];
+                if (!current || current.type !== kind)
+                    return false;
+                const ring = getRing(current, holeIndex);
+                return Boolean(ring &&
+                    ring.length > 3 &&
+                    Number.isInteger(vertexIndex) &&
+                    vertexIndex >= 0 &&
+                    vertexIndex < ring.length);
+            };
+            return {
+                affectedIds: [node.id],
+                apply() { },
+                canCommit: canDeleteCurrentVertex,
+                commit() {
+                    const current = useScene.getState().nodes[node.id];
+                    if (!current || current.type !== kind)
+                        return;
+                    const ring = getRing(current, holeIndex);
+                    if (!ring ||
+                        ring.length <= 3 ||
+                        !Number.isInteger(vertexIndex) ||
+                        vertexIndex < 0 ||
+                        vertexIndex >= ring.length) {
+                        return;
+                    }
+                    const nextRing = ring.filter((_, index) => index !== vertexIndex);
+                    const patch = buildRingPatch(current, holeIndex, nextRing, options?.boundaryCommitData);
+                    useScene
+                        .getState()
+                        .updateNodes([{ id: node.id, data: patch }]);
+                },
+            };
+        },
+    };
+}
+/**
+ * Edge-drag: move a whole edge perpendicular to itself. Both endpoints
+ * translate by `edgeNormal * projectedDelta`. The other vertices of
+ * the ring stay put — adjacent edges effectively pivot around their
+ * far endpoints.
+ *
+ * Snap is grid-aligned on the projected scalar (so a Shift-free drag
+ * lands on grid lines along the edge normal).
+ */
+export function createPolygonMoveEdgeAffordance(kind, options) {
+    return {
+        start({ node, payload, initialPlanPoint, nodes }) {
+            const { edgeIndex, holeIndex } = payload;
+            const originalRing = getRing(node, holeIndex);
+            if (!originalRing) {
+                return {
+                    affectedIds: [node.id],
+                    apply() { },
+                    canCommit() {
+                        return false;
+                    },
+                };
+            }
+            const startVertex = originalRing[edgeIndex];
+            const endVertex = originalRing[(edgeIndex + 1) % originalRing.length];
+            if (!startVertex || !endVertex) {
+                return {
+                    affectedIds: [node.id],
+                    apply() { },
+                    canCommit() {
+                        return false;
+                    },
+                };
+            }
+            const dx = endVertex[0] - startVertex[0];
+            const dy = endVertex[1] - startVertex[1];
+            const len = Math.hypot(dx, dy);
+            if (len < 1e-6) {
+                return {
+                    affectedIds: [node.id],
+                    apply() { },
+                    canCommit() {
+                        return false;
+                    },
+                };
+            }
+            // Perpendicular unit normal (rotate 90° CCW).
+            const normalX = -dy / len;
+            const normalY = dx / len;
+            const startX = initialPlanPoint[0];
+            const startY = initialPlanPoint[1];
+            const edgeStartIndex = edgeIndex;
+            const edgeEndIndex = (edgeIndex + 1) % originalRing.length;
+            return {
+                affectedIds: [node.id],
+                apply({ planPoint, modifiers }) {
+                    // Project the pointer delta onto the edge normal — that's the
+                    // signed perpendicular distance the edge should travel.
+                    const rawPoint = [planPoint[0], planPoint[1]];
+                    const deltaX = rawPoint[0] - startX;
+                    const deltaY = rawPoint[1] - startY;
+                    // Mode-driven snap of the perpendicular distance (matches the chip):
+                    // `getSegmentGridStep()` is 0 in non-`grid` modes, so `snapScalarToGrid`
+                    // passes the raw projection through; `grid` quantizes to the live step.
+                    const projection = snapScalarToGrid(deltaX * normalX + deltaY * normalY, getSegmentGridStep());
+                    const fallbackPoint = [
+                        startX + normalX * projection,
+                        startY + normalY * projection,
+                    ];
+                    const snappedPoint = resolveAffordancePlanPoint(options, {
+                        node,
+                        nodes,
+                        rawPoint,
+                        fallbackPoint,
+                        modifiers,
+                        holeIndex,
+                        mode: 'move-edge',
+                    });
+                    let normalDistance = (snappedPoint[0] - startX) * normalX + (snappedPoint[1] - startY) * normalY;
+                    if (options?.snapEdge) {
+                        const candidate = [
+                            [
+                                startVertex[0] + normalX * normalDistance,
+                                startVertex[1] + normalY * normalDistance,
+                            ],
+                            [endVertex[0] + normalX * normalDistance, endVertex[1] + normalY * normalDistance],
+                        ];
+                        const snappedEdge = options.snapEdge({
+                            node,
+                            nodes,
+                            edge: candidate,
+                            rawPoint,
+                            modifiers,
+                            holeIndex,
+                        });
+                        if (snappedEdge) {
+                            // Measure the final travel from the ORIGINAL edge so the
+                            // stored edge lands exactly on the snapped line — grab
+                            // offset and pointer position drop out entirely.
+                            normalDistance =
+                                (snappedEdge[0][0] - startVertex[0]) * normalX +
+                                    (snappedEdge[0][1] - startVertex[1]) * normalY;
+                        }
+                    }
+                    const nextRing = originalRing.map((p, i) => {
+                        if (i === edgeStartIndex || i === edgeEndIndex) {
+                            return [p[0] + normalX * normalDistance, p[1] + normalY * normalDistance];
+                        }
+                        return [p[0], p[1]];
+                    });
+                    const patch = buildRingPatch(node, holeIndex, nextRing, options?.boundaryCommitData);
+                    useScene
+                        .getState()
+                        .updateNodes([{ id: node.id, data: patch }]);
+                },
+                canCommit() {
+                    const final = useScene.getState().nodes[node.id];
+                    if (!final || final.type !== kind)
+                        return false;
+                    const finalRing = holeIndex === undefined ? final.polygon : (final.holes ?? [])[holeIndex];
+                    return !!finalRing && finalRing.length >= 3;
+                },
+            };
+        },
+    };
+}

package/dist/shared/ports.d.ts

@@ -0,0 +1,75 @@
+import { type AnyNodeId, type NodePort } from '@pascal-app/core';
+/** A port plus the scene node that owns it. */
+export type ScenePort = NodePort & {
+    nodeId: AnyNodeId;
+};
+/** Air-loop port systems — what duct runs and fittings snap to. */
+export declare const DUCT_PORT_SYSTEMS: readonly ["supply", "return"];
+/** DWV port systems — what drain / waste / vent pipe runs snap to. */
+export declare const DWV_PORT_SYSTEMS: readonly ["waste", "vent"];
+/** Refrigerant-loop port system — what linesets snap to. */
+export declare const REFRIGERANT_PORT_SYSTEMS: readonly ["refrigerant"];
+/**
+ * Filter narrowing which ports a tool will snap to.
+ *   - `excludeNodeId` skips the node currently being drawn/placed so a
+ *     tool doesn't snap to its own preview.
+ *   - `systems` keeps only ports on the listed distribution loops — duct
+ *     tools pass the air loops so they ignore refrigerant service ports;
+ *     the lineset tool passes `'refrigerant'` so it ignores duct collars.
+ *     A port with no `system` matches any filter.
+ */
+export type PortFilter = {
+    excludeNodeId?: AnyNodeId;
+    systems?: readonly string[];
+};
+/**
+ * Gather every typed port in the scene by asking each node's registered
+ * `def.ports`. Positions are level-local meters (the kind applies its own
+ * transform inside `def.ports`).
+ */
+export declare function collectScenePorts(filter?: PortFilter): ScenePort[];
+/**
+ * Nearest port within `radius` of `point` on the XZ plane. Y is ignored —
+ * grid events ride the floor plane while ports usually hang at duct
+ * height, so a vertical-distance check would make elevated ports
+ * unreachable. The snap adopts the port's full 3D position.
+ */
+export declare function findNearestPortXZ(point: readonly [number, number, number], ports: ScenePort[], radius: number): ScenePort | null;
+/** Closest-point hit on a duct run's centerline (not its end ports). */
+export type RunBodyHit = {
+    nodeId: AnyNodeId;
+    /** Polyline segment hit — between `path[segmentIndex]` and `path[segmentIndex + 1]`. */
+    segmentIndex: number;
+    /** Closest point on the centerline, level-local meters (Y interpolated). */
+    point: [number, number, number];
+};
+/**
+ * Nearest point on any duct-segment CENTERLINE within `radius` of `point`
+ * on the XZ plane — how a branch taps the side of a trunk. Same XZ-only
+ * distance convention as `findNearestPortXZ` (grid events ride the floor,
+ * runs hang at duct height); the hit adopts the centerline's full 3D
+ * position. Vertical risers project to a point in XZ and are skipped —
+ * tapping those isn't meaningful.
+ */
+export declare function findNearestRunBodyXZ(point: readonly [number, number, number], radius: number, filter?: {
+    excludeNodeId?: AnyNodeId;
+    kinds?: readonly string[];
+}): RunBodyHit | null;
+/**
+ * Where a drawn segment `start`→`end` crosses straight THROUGH an
+ * existing run's centerline in XZ — the four-way (cross) case, as
+ * opposed to ending ON a run (the tee case). The crossing must be
+ * INTERIOR to both: strictly between the drawn segment's ends (so the
+ * run truly passes through, not just touches at a tip — those are tee
+ * taps) and strictly inside the hit trunk segment, clear of its joints
+ * by `endMargin` meters so the run legs have room. The hit's `point`
+ * adopts the trunk centerline's interpolated 3D position (the drawn run
+ * snaps onto the trunk's height). Returns the nearest such crossing, or
+ * null. Vertical risers (no XZ extent) are skipped, same as the body
+ * query.
+ */
+export declare function findRunBodyCrossingXZ(start: readonly [number, number, number], end: readonly [number, number, number], endMargin: number, filter?: {
+    excludeNodeId?: AnyNodeId;
+    kinds?: readonly string[];
+}): RunBodyHit | null;
+//# sourceMappingURL=ports.d.ts.map

package/dist/shared/ports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ports.d.ts","sourceRoot":"","sources":["../../src/shared/ports.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,QAAQ,EAA0B,MAAM,kBAAkB,CAAA;AAExF,+CAA+C;AAC/C,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG;IAAE,MAAM,EAAE,SAAS,CAAA;CAAE,CAAA;AAExD,mEAAmE;AACnE,eAAO,MAAM,iBAAiB,+BAAgC,CAAA;AAC9D,sEAAsE;AACtE,eAAO,MAAM,gBAAgB,4BAA6B,CAAA;AAC1D,4DAA4D;AAC5D,eAAO,MAAM,wBAAwB,0BAA2B,CAAA;AAEhE;;;;;;;;GAQG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,aAAa,CAAC,EAAE,SAAS,CAAA;IACzB,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAC5B,CAAA;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,GAAE,UAAe,GAAG,SAAS,EAAE,CActE;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EACxC,KAAK,EAAE,SAAS,EAAE,EAClB,MAAM,EAAE,MAAM,GACb,SAAS,GAAG,IAAI,CAalB;AAID,wEAAwE;AACxE,MAAM,MAAM,UAAU,GAAG;IACvB,MAAM,EAAE,SAAS,CAAA;IACjB,wFAAwF;IACxF,YAAY,EAAE,MAAM,CAAA;IACpB,4EAA4E;IAC5E,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;CAChC,CAAA;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EACxC,MAAM,EAAE,MAAM,EACd,MAAM,GAAE;IAAE,aAAa,CAAC,EAAE,SAAS,CAAC;IAAC,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAAO,GACpE,UAAU,GAAG,IAAI,CAoCnB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EACxC,GAAG,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EACtC,SAAS,EAAE,MAAM,EACjB,MAAM,GAAE;IAAE,aAAa,CAAC,EAAE,SAAS,CAAC;IAAC,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAAO,GACpE,UAAU,GAAG,IAAI,CAgDnB"}

package/dist/shared/ports.js

@@ -0,0 +1,164 @@
+import { nodeRegistry, useScene } from '@pascal-app/core';
+/** Air-loop port systems — what duct runs and fittings snap to. */
+export const DUCT_PORT_SYSTEMS = ['supply', 'return'];
+/** DWV port systems — what drain / waste / vent pipe runs snap to. */
+export const DWV_PORT_SYSTEMS = ['waste', 'vent'];
+/** Refrigerant-loop port system — what linesets snap to. */
+export const REFRIGERANT_PORT_SYSTEMS = ['refrigerant'];
+/**
+ * Gather every typed port in the scene by asking each node's registered
+ * `def.ports`. Positions are level-local meters (the kind applies its own
+ * transform inside `def.ports`).
+ */
+export function collectScenePorts(filter = {}) {
+    const { excludeNodeId, systems } = filter;
+    const { nodes } = useScene.getState();
+    const result = [];
+    for (const node of Object.values(nodes)) {
+        if (!node || node.id === excludeNodeId)
+            continue;
+        const ports = nodeRegistry.get(node.type)?.ports?.(node);
+        if (!ports)
+            continue;
+        for (const port of ports) {
+            if (systems && port.system !== undefined && !systems.includes(port.system))
+                continue;
+            result.push({ ...port, nodeId: node.id });
+        }
+    }
+    return result;
+}
+/**
+ * Nearest port within `radius` of `point` on the XZ plane. Y is ignored —
+ * grid events ride the floor plane while ports usually hang at duct
+ * height, so a vertical-distance check would make elevated ports
+ * unreachable. The snap adopts the port's full 3D position.
+ */
+export function findNearestPortXZ(point, ports, radius) {
+    let best = null;
+    let bestDistSq = radius * radius;
+    for (const port of ports) {
+        const dx = port.position[0] - point[0];
+        const dz = port.position[2] - point[2];
+        const distSq = dx * dx + dz * dz;
+        if (distSq <= bestDistSq) {
+            bestDistSq = distSq;
+            best = port;
+        }
+    }
+    return best;
+}
+/**
+ * Nearest point on any duct-segment CENTERLINE within `radius` of `point`
+ * on the XZ plane — how a branch taps the side of a trunk. Same XZ-only
+ * distance convention as `findNearestPortXZ` (grid events ride the floor,
+ * runs hang at duct height); the hit adopts the centerline's full 3D
+ * position. Vertical risers project to a point in XZ and are skipped —
+ * tapping those isn't meaningful.
+ */
+export function findNearestRunBodyXZ(point, radius, filter = {}) {
+    const kinds = filter.kinds ?? ['duct-segment'];
+    const { nodes } = useScene.getState();
+    let best = null;
+    let bestDistSq = radius * radius;
+    for (const node of Object.values(nodes)) {
+        if (!node || !kinds.includes(node.type) || node.id === filter.excludeNodeId)
+            continue;
+        const path = node.path;
+        if (!path)
+            continue;
+        for (let i = 0; i < path.length - 1; i++) {
+            const a = path[i];
+            const b = path[i + 1];
+            const abx = b[0] - a[0];
+            const abz = b[2] - a[2];
+            const lenSq = abx * abx + abz * abz;
+            if (lenSq < 1e-8)
+                continue; // vertical riser — no XZ extent
+            const t = Math.min(1, Math.max(0, ((point[0] - a[0]) * abx + (point[2] - a[2]) * abz) / lenSq));
+            const cx = a[0] + abx * t;
+            const cz = a[2] + abz * t;
+            const dx = point[0] - cx;
+            const dz = point[2] - cz;
+            const distSq = dx * dx + dz * dz;
+            if (distSq <= bestDistSq) {
+                bestDistSq = distSq;
+                best = {
+                    nodeId: node.id,
+                    segmentIndex: i,
+                    point: [cx, a[1] + (b[1] - a[1]) * t, cz],
+                };
+            }
+        }
+    }
+    return best;
+}
+/**
+ * Where a drawn segment `start`→`end` crosses straight THROUGH an
+ * existing run's centerline in XZ — the four-way (cross) case, as
+ * opposed to ending ON a run (the tee case). The crossing must be
+ * INTERIOR to both: strictly between the drawn segment's ends (so the
+ * run truly passes through, not just touches at a tip — those are tee
+ * taps) and strictly inside the hit trunk segment, clear of its joints
+ * by `endMargin` meters so the run legs have room. The hit's `point`
+ * adopts the trunk centerline's interpolated 3D position (the drawn run
+ * snaps onto the trunk's height). Returns the nearest such crossing, or
+ * null. Vertical risers (no XZ extent) are skipped, same as the body
+ * query.
+ */
+export function findRunBodyCrossingXZ(start, end, endMargin, filter = {}) {
+    const kinds = filter.kinds ?? ['duct-segment'];
+    const { nodes } = useScene.getState();
+    const dx = end[0] - start[0];
+    const dz = end[2] - start[2];
+    const drawnLenSq = dx * dx + dz * dz;
+    if (drawnLenSq < 1e-8)
+        return null;
+    const drawnLen = Math.sqrt(drawnLenSq);
+    // Interior margins as a fraction of each segment's length.
+    const drawnPad = Math.min(0.45, endMargin / drawnLen);
+    let best = null;
+    let bestScore = Number.POSITIVE_INFINITY;
+    for (const node of Object.values(nodes)) {
+        if (!node || !kinds.includes(node.type) || node.id === filter.excludeNodeId)
+            continue;
+        const path = node.path;
+        if (!path)
+            continue;
+        for (let i = 0; i < path.length - 1; i++) {
+            const a = path[i];
+            const b = path[i + 1];
+            const ex = b[0] - a[0];
+            const ez = b[2] - a[2];
+            const runLenSq = ex * ex + ez * ez;
+            if (runLenSq < 1e-8)
+                continue; // vertical riser — no XZ extent
+            // Solve start + s·d = a + t·e in XZ. denom is the 2D cross of the
+            // two directions; ~0 means parallel (no single crossing).
+            const denom = dx * ez - dz * ex;
+            if (Math.abs(denom) < 1e-9)
+                continue;
+            const wx = a[0] - start[0];
+            const wz = a[2] - start[2];
+            const s = (wx * ez - wz * ex) / denom;
+            const t = (wx * dz - wz * dx) / denom;
+            const runLen = Math.sqrt(runLenSq);
+            const runPad = Math.min(0.45, endMargin / runLen);
+            // Strictly interior to both segments, clear of the trunk's joints.
+            if (s <= drawnPad || s >= 1 - drawnPad)
+                continue;
+            if (t <= runPad || t >= 1 - runPad)
+                continue;
+            // Prefer the crossing nearest the drawn start (first run hit).
+            if (s < bestScore) {
+                bestScore = s;
+                best = {
+                    nodeId: node.id,
+                    segmentIndex: i,
+                    point: [a[0] + ex * t, a[1] + (b[1] - a[1]) * t, a[2] + ez * t],
+                };
+            }
+        }
+    }
+    return best;
+}

package/dist/shared/quick-measurement.d.ts

@@ -0,0 +1,8 @@
+import { type MeasurementPoint } from '@pascal-app/core';
+type PolygonPoint = readonly [number, number];
+export declare function polygonMeasurementPoints(polygon: readonly PolygonPoint[], height: number): MeasurementPoint[];
+export declare function polygonSurfaceArea(polygon: readonly PolygonPoint[], holes?: readonly (readonly PolygonPoint[])[]): number;
+export declare function polygonBoundaryLength(polygon: readonly PolygonPoint[]): number;
+export declare function polygonReportAnchor(polygon: readonly PolygonPoint[], height: number): MeasurementPoint;
+export {};
+//# sourceMappingURL=quick-measurement.d.ts.map

package/dist/shared/quick-measurement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quick-measurement.d.ts","sourceRoot":"","sources":["../../src/shared/quick-measurement.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,gBAAgB,EAItB,MAAM,kBAAkB,CAAA;AAEzB,KAAK,YAAY,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAE7C,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,SAAS,YAAY,EAAE,EAChC,MAAM,EAAE,MAAM,GACb,gBAAgB,EAAE,CAEpB;AAED,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,SAAS,YAAY,EAAE,EAChC,KAAK,GAAE,SAAS,CAAC,SAAS,YAAY,EAAE,CAAC,EAAO,GAC/C,MAAM,CAOR;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,SAAS,YAAY,EAAE,GAAG,MAAM,CAE9E;AAED,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,SAAS,YAAY,EAAE,EAChC,MAAM,EAAE,MAAM,GACb,gBAAgB,CAElB"}

package/dist/shared/quick-measurement.js

@@ -0,0 +1,15 @@
+import { measurementArea, measurementCentroid, measurementPerimeter, } from '@pascal-app/core';
+export function polygonMeasurementPoints(polygon, height) {
+    return polygon.map(([x, z]) => [x, height, z]);
+}
+export function polygonSurfaceArea(polygon, holes = []) {
+    const outer = measurementArea(polygonMeasurementPoints(polygon, 0));
+    const openings = holes.reduce((total, hole) => total + measurementArea(polygonMeasurementPoints(hole, 0)), 0);
+    return Math.max(0, outer - openings);
+}
+export function polygonBoundaryLength(polygon) {
+    return measurementPerimeter(polygonMeasurementPoints(polygon, 0));
+}
+export function polygonReportAnchor(polygon, height) {
+    return measurementCentroid(polygonMeasurementPoints(polygon, height)) ?? [0, height, 0];
+}

package/dist/shared/refrigerant-line-selection.d.ts

@@ -0,0 +1,4 @@
+type RefrigerantLineKind = 'lineset' | 'liquid-line';
+export declare function createRefrigerantLineSelectionAffordance(kind: RefrigerantLineKind): () => import("react").JSX.Element | null;
+export {};
+//# sourceMappingURL=refrigerant-line-selection.d.ts.map

package/dist/shared/refrigerant-line-selection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"refrigerant-line-selection.d.ts","sourceRoot":"","sources":["../../src/shared/refrigerant-line-selection.tsx"],"names":[],"mappings":"AAyBA,KAAK,mBAAmB,GAAG,SAAS,GAAG,aAAa,CAAA;AA6CpD,wBAAgB,wCAAwC,CAAC,IAAI,EAAE,mBAAmB,4CAiCjF"}