@pascal-app/nodes 0.1.1

package/dist/lineset/parametrics.js

@@ -0,0 +1,34 @@
+export const linesetParametrics = {
+    groups: [
+        {
+            label: 'Lines',
+            fields: [
+                {
+                    key: 'suctionDiameter',
+                    kind: 'number',
+                    unit: 'in',
+                    min: 0.25,
+                    max: 1.5,
+                    step: 0.125,
+                },
+                {
+                    key: 'liquidDiameter',
+                    kind: 'number',
+                    unit: 'in',
+                    min: 0.125,
+                    max: 0.75,
+                    step: 0.125,
+                },
+            ],
+        },
+        {
+            label: 'Insulation',
+            fields: [
+                {
+                    key: 'insulated',
+                    kind: 'boolean',
+                },
+            ],
+        },
+    ],
+};

package/dist/lineset/schema.d.ts

@@ -0,0 +1,2 @@
+export { LinesetNode } from '@pascal-app/core';
+//# sourceMappingURL=schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/lineset/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA"}

package/dist/lineset/schema.js

@@ -0,0 +1 @@
+export { LinesetNode } from '@pascal-app/core';

package/dist/lineset/selection.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"selection.d.ts","sourceRoot":"","sources":["../../src/lineset/selection.tsx"],"names":[],"mappings":";AAIA,wBAAkE"}

package/dist/lineset/selection.js

@@ -0,0 +1,3 @@
+'use client';
+import { createRefrigerantLineSelectionAffordance } from '../shared/refrigerant-line-selection';
+export default createRefrigerantLineSelectionAffordance('lineset');

package/dist/lineset/tool.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/lineset/tool.tsx"],"names":[],"mappings":"AAuFA,QAAA,MAAM,WAAW,0CAuQhB,CAAA;AAgCD,eAAe,WAAW,CAAA"}

package/dist/lineset/tool.js

@@ -0,0 +1,298 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { emitter, LinesetNode, 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 { collectScenePorts, findNearestPortXZ, REFRIGERANT_PORT_SYSTEMS } from '../shared/ports';
+import { linesetDefinition } from './definition';
+/**
+ * Continuous placement tool for refrigerant linesets — the refrigerant-loop
+ * sibling of the duct-segment tool.
+ *
+ * Mouse-driven model:
+ *   - **First click** anchors the run start. Within range of a refrigerant
+ *     service port (a condenser / coil valve, or another lineset's end) it
+ *     snaps onto the port so a run mates flush.
+ *   - **Second click** commits a two-point lineset and keeps its far end
+ *     anchored, so the next click continues the run like wall / duct drafting.
+ *   - The in-flight end follows the active snapping mode: `angles` locks it to
+ *     the nearest 45° step in XZ from the start (Y stays at the start's
+ *     height); `grid`/`lines`/`off` leave it free. Shift cycles the mode.
+ *   - Hold **Alt** → vertical mode. XZ locks to the start; vertical mouse
+ *     motion drives Y. Click commits the riser segment. (Drafting has no
+ *     validity gate, so Alt is the riser modifier here, not force-place.)
+ *   - Esc clears an anchored start point.
+ *
+ * Snapping is restricted to refrigerant ports, so a lineset never grabs a
+ * supply/return duct collar.
+ */
+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;
+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];
+}
+const LinesetTool = () => {
+    const activeLevelId = useViewer((s) => s.selection.levelId);
+    const unit = useViewer((s) => s.unit);
+    const cursorRef = useRef(null);
+    const [draftPoints, setDraftPoints] = useState([]);
+    const [cursorPos, setCursorPos] = useState(null);
+    const [snapTarget, setSnapTarget] = useState(null);
+    const [altActive, setAltActive] = useState(false);
+    const draftRef = useRef(draftPoints);
+    draftRef.current = draftPoints;
+    const altAnchorRef = useRef(null);
+    const lastClientYRef = useRef(null);
+    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 lineset node — the
+            // refrigerant-loop sibling of duct-segment. Independent nodes mean each
+            // segment selects and deletes on its own, rather than folding into one
+            // mitered polyline run.
+            const lineset = LinesetNode.parse({
+                ...linesetDefinition.defaults(),
+                name: 'Lineset',
+                path: [start, end],
+            });
+            useScene.getState().createNode(lineset, activeLevelId);
+            triggerSFX('sfx:item-place');
+            setDraftPoints([end]);
+            setSnapTarget(null);
+            altAnchorRef.current = null;
+            setAltActive(false);
+        };
+        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]];
+        };
+        // Resolve the cursor point (port / grid / angle snap) then layer
+        // Figma-style alignment so a lineset lines up with other runs, equipment,
+        // and items as it's drawn. A free point (first vertex, or no angle lock)
+        // snaps; an angle-locked continuation shows the guide passively so it
+        // doesn't fight the angle ray. Alignment follows the `lines` mode; a port
+        // snap or Alt-vertical bypasses it.
+        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) => {
+            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) => {
+            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 = () => {
+            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 === 'Alt') {
+                e.preventDefault();
+                enterAltMode();
+            }
+        };
+        const onKeyUp = (e) => {
+            if (e.key === 'Alt') {
+                e.preventDefault();
+                exitAltMode();
+            }
+        };
+        const onCancel = () => {
+            clearDrawAlignment();
+            if (draftRef.current.length === 0)
+                return;
+            markToolCancelConsumed();
+            setDraftPoints([]);
+            setCursorPos(null);
+            setSnapTarget(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 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 }), 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.06, 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}`)))] }));
+};
+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);
+    // Default suction OD (~7/8") for the ghost.
+    const radius = (0.875 * 0.0254) / 2;
+    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: [radius, radius, length, 16, 1, false] }), _jsx("meshBasicMaterial", { color: PREVIEW_COLOR, depthTest: false, opacity: PREVIEW_OPACITY, transparent: true })] }));
+}
+export default LinesetTool;

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

@@ -0,0 +1,16 @@
+import type { NodeDefinition } from '@pascal-app/core';
+import { LiquidLineNode } from './schema';
+/**
+ * Standalone refrigerant liquid line — the thin bare-copper line broken out of
+ * the lineset so it can be drawn on its own. The refrigerant-side sibling of
+ * `lineset`: same polyline model and draw tool, snapping onto refrigerant
+ * service ports, but a single thin line. Its tool adds a Follow mode that
+ * traces an existing lineset's path at an offset.
+ *
+ * Composition: `def.geometry` only, plus a selection-time path-handle system
+ * shared in spirit with the lineset. The framework's `<ParametricNodeRenderer>`
+ * mounts an empty group; `<GeometrySystem>` fills it via
+ * `buildLiquidLineGeometry` on dirty.
+ */
+export declare const liquidLineDefinition: NodeDefinition<typeof LiquidLineNode>;
+//# sourceMappingURL=definition.d.ts.map

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

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

package/dist/liquid-line/definition.js

@@ -0,0 +1,110 @@
+import { createPathPointMoveAffordance } from '../shared/path-point-affordance';
+import { buildLiquidLineFloorplan } from './floorplan';
+import { buildLiquidLineGeometry } from './geometry';
+import { liquidLineParametrics } from './parametrics';
+import { LiquidLineNode } from './schema';
+/**
+ * Standalone refrigerant liquid line — the thin bare-copper line broken out of
+ * the lineset so it can be drawn on its own. The refrigerant-side sibling of
+ * `lineset`: same polyline model and draw tool, snapping onto refrigerant
+ * service ports, but a single thin line. Its tool adds a Follow mode that
+ * traces an existing lineset's path at an offset.
+ *
+ * Composition: `def.geometry` only, plus a selection-time path-handle system
+ * shared in spirit with the lineset. The framework's `<ParametricNodeRenderer>`
+ * mounts an empty group; `<GeometrySystem>` fills it via
+ * `buildLiquidLineGeometry` on dirty.
+ */
+export const liquidLineDefinition = {
+    kind: 'liquid-line',
+    schemaVersion: 1,
+    schema: LiquidLineNode,
+    category: 'utility',
+    distributionRole: 'run',
+    // Directional run: like a wall, drafting sets a direction, so it takes the
+    // structural snapping context (grid / lines / angles / off) with a 45° angle
+    // lock available as a cyclable mode.
+    snapProfile: 'structural',
+    defaults: () => ({
+        object: 'node',
+        parentId: null,
+        visible: true,
+        metadata: {},
+        path: [
+            [0, 0, 0],
+            [2, 0, 0],
+        ],
+        diameter: 0.375,
+    }),
+    capabilities: {
+        selectable: { hitVolume: 'bbox' },
+        duplicable: true,
+        deletable: true,
+    },
+    parametrics: liquidLineParametrics,
+    geometry: buildLiquidLineGeometry,
+    geometryKey: (n) => JSON.stringify([n.path, n.diameter]),
+    // Open run ends as typed refrigerant ports — directions point outward along
+    // the path tangent so they mate flush onto a service valve. Path coords are
+    // already level-local, so no transform is needed.
+    ports: (n) => {
+        if (n.path.length < 2)
+            return [];
+        const diameter = n.diameter;
+        const unit = (a, b) => {
+            const d = [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+            const len = Math.hypot(d[0], d[1], d[2]);
+            return len < 1e-9 ? [1, 0, 0] : [d[0] / len, d[1] / len, d[2] / len];
+        };
+        const first = n.path[0];
+        const second = n.path[1];
+        const last = n.path[n.path.length - 1];
+        const prev = n.path[n.path.length - 2];
+        return [
+            {
+                id: 'start',
+                position: first,
+                direction: unit(first, second),
+                diameter,
+                system: 'refrigerant',
+            },
+            {
+                id: 'end',
+                position: last,
+                direction: unit(last, prev),
+                diameter,
+                system: 'refrigerant',
+            },
+        ];
+    },
+    floorplan: buildLiquidLineFloorplan,
+    // 2D selection-time path-point handles — the floor-plan twin of the 3D
+    // `affordanceTools.selection` handles.
+    floorplanAffordances: {
+        'move-path-point': createPathPointMoveAffordance('liquid-line'),
+    },
+    // Selection-time path-point handles (drag to edit a committed run) and the
+    // ghost-preview duplicate / move tool (drag-to-place a translucent copy).
+    affordanceTools: {
+        selection: () => import('./selection'),
+        move: () => import('./move-tool'),
+    },
+    tool: () => import('./tool'),
+    toolHints: [
+        { key: 'Click', label: 'Start liquid line' },
+        { key: 'Click again', label: 'Place it (locked to 45°)' },
+        { key: 'Alt + drag', label: 'Go vertical ↕, click to place' },
+        { key: 'F', label: 'Follow: trace a lineset' },
+        { key: 'Esc', label: 'Cancel' },
+    ],
+    presentation: {
+        label: 'Liquid Line',
+        description: 'Standalone refrigerant liquid line — a thin bare-copper run; Follow mode traces an existing lineset.',
+        icon: { kind: 'url', src: '/icons/lineset.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 94,
+    },
+    mcp: {
+        description: 'A standalone refrigerant liquid line defined as a polyline of thin bare copper. Snaps onto refrigerant service ports; can be traced alongside an existing lineset.',
+    },
+};

package/dist/liquid-line/floorplan.d.ts

@@ -0,0 +1,10 @@
+import type { FloorplanGeometry, GeometryContext } from '@pascal-app/core';
+import type { LiquidLineNode } from './schema';
+/**
+ * Floor-plan representation of a liquid line: a single thin copper polyline at
+ * the line's real width. Vertical risers collapse to a point in plan;
+ * consecutive duplicate plan points are dropped so they don't render
+ * zero-length artifacts.
+ */
+export declare function buildLiquidLineFloorplan(node: LiquidLineNode, ctx: GeometryContext): FloorplanGeometry | null;
+//# sourceMappingURL=floorplan.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/liquid-line/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAkB,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAE1F,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAI9C;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,cAAc,EACpB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CA6D1B"}

package/dist/liquid-line/floorplan.js

@@ -0,0 +1,66 @@
+import { INCHES_TO_METERS } from '../duct-segment/geometry';
+const COPPER_LINE = '#b06b3f';
+/**
+ * Floor-plan representation of a liquid line: a single thin copper polyline at
+ * the line's real width. Vertical risers collapse to a point in plan;
+ * consecutive duplicate plan points are dropped so they don't render
+ * zero-length artifacts.
+ */
+export function buildLiquidLineFloorplan(node, ctx) {
+    if (node.path.length < 2)
+        return null;
+    const points = [];
+    // Plan point k ← original path index indexMap[k] (risers collapse to one
+    // plan point), so the path-point drag handle edits the right vertex.
+    const indexMap = [];
+    for (let i = 0; i < node.path.length; i++) {
+        const [x, , z] = node.path[i];
+        const prev = points[points.length - 1];
+        if (prev && Math.abs(prev[0] - x) < 1e-6 && Math.abs(prev[1] - z) < 1e-6)
+            continue;
+        points.push([x, z]);
+        indexMap.push(i);
+    }
+    const widthM = node.diameter * INCHES_TO_METERS;
+    const view = ctx.viewState;
+    const palette = view?.palette;
+    const showSelectedChrome = (view?.selected || view?.highlighted) ?? false;
+    if (points.length < 2) {
+        const p = points[0] ?? [node.path[0][0], node.path[0][2]];
+        return {
+            kind: 'circle',
+            cx: p[0],
+            cy: p[1],
+            r: Math.max(widthM, 0.02),
+            fill: COPPER_LINE,
+            stroke: showSelectedChrome && palette ? palette.selectedStroke : COPPER_LINE,
+            strokeWidth: 0.02,
+            opacity: 0.9,
+        };
+    }
+    const children = [
+        {
+            kind: 'polyline',
+            points,
+            stroke: showSelectedChrome && palette ? palette.selectedStroke : COPPER_LINE,
+            strokeWidth: Math.max(widthM * 2, 0.04),
+            strokeLinecap: 'round',
+            strokeLinejoin: 'round',
+            opacity: showSelectedChrome ? 0.95 : 0.85,
+        },
+    ];
+    // Selection chrome: one draggable handle per path vertex (2D twin of the
+    // 3D selection handles). Routes to the shared `move-path-point` affordance.
+    if (view?.selected) {
+        for (let k = 0; k < points.length; k++) {
+            children.push({
+                kind: 'endpoint-handle',
+                point: points[k],
+                state: 'idle',
+                affordance: 'move-path-point',
+                payload: { pointIndex: indexMap[k] },
+            });
+        }
+    }
+    return { kind: 'group', children };
+}

package/dist/liquid-line/geometry.d.ts

@@ -0,0 +1,16 @@
+import { Group } from 'three';
+import type { LiquidLineNode } from './schema';
+/**
+ * Pure geometry builder for a standalone liquid line: a single thin bare-copper
+ * cylinder following the node path centerline.
+ *
+ * Each line is a standalone two-point node (no fitting system), so a sphere caps
+ * BOTH endpoints. On a free end it rounds the cap; where two segments share a
+ * coordinate the coincident spheres fill the miter gap, so the turn reads as
+ * continuous pipe.
+ *
+ * Children are level-local meters; `<ParametricNodeRenderer>` owns the node
+ * transform (identity today — the path is absolute within the level).
+ */
+export declare function buildLiquidLineGeometry(node: LiquidLineNode): Group;
+//# sourceMappingURL=geometry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/liquid-line/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,KAAK,EAAuD,MAAM,OAAO,CAAA;AAEpG,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AA6B9C;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,cAAc,GAAG,KAAK,CA6BnE"}

package/dist/liquid-line/geometry.js

@@ -0,0 +1,57 @@
+import { CylinderGeometry, Group, Mesh, MeshStandardMaterial, SphereGeometry, Vector3 } from 'three';
+import { INCHES_TO_METERS } from '../duct-segment/geometry';
+const RADIAL_SEGMENTS = 16;
+const COPPER_COLOR = '#b06b3f';
+const UP = new Vector3(0, 1, 0);
+/** Cylinder spanning `start`→`end` at `radius`, named for debugging. */
+function buildRun(start, end, radius, material, name) {
+    const dir = new Vector3().subVectors(end, start);
+    const length = dir.length();
+    if (length < 1e-6)
+        return null;
+    dir.normalize();
+    const mesh = new Mesh(new CylinderGeometry(radius, radius, length, RADIAL_SEGMENTS, 1, false), material);
+    mesh.name = name;
+    mesh.position.copy(start).addScaledVector(dir, length / 2);
+    mesh.quaternion.setFromUnitVectors(UP, dir);
+    return mesh;
+}
+/**
+ * Pure geometry builder for a standalone liquid line: a single thin bare-copper
+ * cylinder following the node path centerline.
+ *
+ * Each line is a standalone two-point node (no fitting system), so a sphere caps
+ * BOTH endpoints. On a free end it rounds the cap; where two segments share a
+ * coordinate the coincident spheres fill the miter gap, so the turn reads as
+ * continuous pipe.
+ *
+ * Children are level-local meters; `<ParametricNodeRenderer>` owns the node
+ * transform (identity today — the path is absolute within the level).
+ */
+export function buildLiquidLineGeometry(node) {
+    const group = new Group();
+    if (node.path.length < 2)
+        return group;
+    const radius = (node.diameter * INCHES_TO_METERS) / 2;
+    const copperMat = new MeshStandardMaterial({
+        color: COPPER_COLOR,
+        metalness: 0.8,
+        roughness: 0.3,
+    });
+    const points = node.path.map(([x, y, z]) => new Vector3(x, y, z));
+    for (let i = 0; i < points.length - 1; i++) {
+        const run = buildRun(points[i], points[i + 1], radius, copperMat, `liquid-line-${i}`);
+        if (run)
+            group.add(run);
+    }
+    // Spherical caps at every point: interior corners read as continuous pipe,
+    // and endpoint caps round the open ends so two separate segments sharing a
+    // coordinate fill the miter and look welded.
+    for (let i = 0; i < points.length; i++) {
+        const joint = new Mesh(new SphereGeometry(radius, RADIAL_SEGMENTS, 10), copperMat);
+        joint.name = `liquid-line-joint-${i}`;
+        joint.position.copy(points[i]);
+        group.add(joint);
+    }
+    return group;
+}

package/dist/liquid-line/index.d.ts

@@ -0,0 +1,5 @@
+export { liquidLineDefinition } from './definition';
+export { buildLiquidLineGeometry } from './geometry';
+export { useLiquidLineToolOptions } from './options';
+export { LiquidLineNode } from './schema';
+//# sourceMappingURL=index.d.ts.map