@pascal-app/nodes 0.1.1

package/dist/pipe-fitting/tool.js

@@ -0,0 +1,162 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { emitter, PipeFittingNode, useScene } from '@pascal-app/core';
+import { CursorSphere, EDITOR_LAYER, isGridSnapActive, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { Html } from '@react-three/drei';
+import { useEffect, useMemo, useRef, useState } from 'react';
+import { Euler, Quaternion, Vector3 } from 'three';
+import { AXIS_VECTORS, cycleRotationAxis, getRotationAxis, ROTATE_STEP_RAD, } from '../shared/fitting-rotation';
+import { LevelOffsetGroup } from '../shared/level-offset-group';
+import { collectScenePorts, DWV_PORT_SYSTEMS, findNearestPortXZ, } from '../shared/ports';
+import { pipeFittingDefinition } from './definition';
+import { buildPipeFittingGeometry } from './geometry';
+import { localPipeFittingPorts } from './ports';
+/** Snap radius (meters, XZ) for mating onto an existing DWV port. */
+const PORT_SNAP_RADIUS_M = 0.5;
+const PREVIEW_OPACITY = 0.55;
+function snap(value, step) {
+    if (step <= 0)
+        return value;
+    return Math.round(value / step) * step;
+}
+/**
+ * Resolve where the fitting would land for a cursor at `raw`:
+ *   - Near an existing DWV port → mate: orientation aligns the inlet
+ *     onto the port (plus the user's manual R/T rotation, pivoting
+ *     around the inlet collar so it stays on the port while the body
+ *     sweeps).
+ *   - Otherwise → grid-snapped free placement on the floor, manual
+ *     rotation only.
+ */
+function resolvePlacement(raw, previewNode, gridStep, manualQuat) {
+    const port = findNearestPortXZ(raw, collectScenePorts({ systems: DWV_PORT_SYSTEMS }), PORT_SNAP_RADIUS_M);
+    if (port) {
+        const direction = new Vector3(...port.direction).normalize();
+        // Local +X must map onto the port's outward direction so the inlet
+        // (local -X) faces back into the run it's joining. Manual rotation
+        // composes in the world frame on top of the mate orientation.
+        const mate = new Quaternion().setFromUnitVectors(new Vector3(1, 0, 0), direction);
+        const final = manualQuat.clone().multiply(mate);
+        const inlet = localPipeFittingPorts(previewNode)[0];
+        const inletWorldOffset = inlet.position.clone().applyQuaternion(final);
+        const position = new Vector3(...port.position).sub(inletWorldOffset);
+        const euler = new Euler().setFromQuaternion(final);
+        return {
+            position: [position.x, position.y, position.z],
+            rotation: [euler.x, euler.y, euler.z],
+            snapPort: port,
+        };
+    }
+    const euler = new Euler().setFromQuaternion(manualQuat);
+    return {
+        position: [snap(raw[0], gridStep), 0, snap(raw[2], gridStep)],
+        rotation: [euler.x, euler.y, euler.z],
+        snapPort: null,
+    };
+}
+/**
+ * Click-place tool for DWV pipe fittings (elbow / wye / sanitary tee) —
+ * the plumbing sibling of the duct-fitting tool.
+ *
+ * A translucent ghost of the fitting follows the cursor. Within snap
+ * range of any DWV port (pipe run ends, other fittings' collars) the
+ * ghost jumps onto the port — position AND orientation — so one click
+ * mates the fitting onto the run.
+ *
+ * Rotation while placing: **R / T** turn the ghost ±45° around the
+ * active world axis; **Alt** cycles the axis (Y → X → Z). The HUD badge
+ * above the ghost shows the current axis. When snapped to a port the
+ * rotation pivots around the inlet collar so the joint stays mated.
+ * Handlers run in the capture phase so R doesn't also spin whatever
+ * node happens to be selected.
+ */
+const PipeFittingTool = () => {
+    const activeLevelId = useViewer((s) => s.selection.levelId);
+    const [placement, setPlacement] = useState(null);
+    const axis = useEditor((s) => s.rotationAxis);
+    // Accumulated manual rotation from R/T presses. Ref (not state) so the
+    // emitter callbacks always read the latest without re-subscribing; a
+    // placement recompute is triggered explicitly after each change.
+    const manualQuatRef = useRef(new Quaternion());
+    // Last raw cursor position so a key press can recompute the placement
+    // without waiting for the next mouse move.
+    const lastRawRef = useRef(null);
+    // Ghost matches exactly what a click creates (the kind's defaults).
+    const previewNode = useMemo(() => PipeFittingNode.parse({ ...pipeFittingDefinition.defaults(), name: 'Pipe fitting' }), []);
+    const ghost = useMemo(() => {
+        const group = buildPipeFittingGeometry(previewNode);
+        group.traverse((child) => {
+            // Overlay layer keeps the placement ghost out of the ink / SSGI
+            // buffers and the thumbnail export, like every other tool preview.
+            child.layers.set(EDITOR_LAYER);
+            const mesh = child;
+            if (mesh.material) {
+                mesh.material.transparent = true;
+                mesh.material.opacity = PREVIEW_OPACITY;
+            }
+        });
+        return group;
+    }, [previewNode]);
+    useEffect(() => {
+        if (!activeLevelId)
+            return;
+        const recompute = () => {
+            const raw = lastRawRef.current;
+            if (!raw)
+                return;
+            setPlacement(resolvePlacement(raw, previewNode, isGridSnapActive() ? useEditor.getState().gridSnapStep : 0, manualQuatRef.current));
+        };
+        const onMove = (event) => {
+            lastRawRef.current = [event.localPosition[0], 0, event.localPosition[2]];
+            recompute();
+        };
+        const onClick = (event) => {
+            lastRawRef.current = [event.localPosition[0], 0, event.localPosition[2]];
+            const { position, rotation } = resolvePlacement(lastRawRef.current, previewNode, isGridSnapActive() ? useEditor.getState().gridSnapStep : 0, manualQuatRef.current);
+            const fitting = PipeFittingNode.parse({
+                ...pipeFittingDefinition.defaults(),
+                name: 'Pipe fitting',
+                position,
+                rotation,
+            });
+            useScene.getState().createNode(fitting, activeLevelId);
+            useViewer.getState().setSelection({ selectedIds: [fitting.id] });
+            triggerSFX('sfx:item-place');
+        };
+        const onKeyDown = (e) => {
+            const tag = e.target?.tagName;
+            if (tag === 'INPUT' || tag === 'TEXTAREA')
+                return;
+            const key = e.key;
+            if (key === 'r' || key === 'R' || key === 't' || key === 'T') {
+                // Capture-phase + stopPropagation so the editor's selection-rotate
+                // R handler doesn't also fire while the placement tool owns R.
+                e.preventDefault();
+                e.stopPropagation();
+                const steps = key === 't' || key === 'T' || e.shiftKey ? -1 : 1;
+                const turn = new Quaternion().setFromAxisAngle(AXIS_VECTORS[getRotationAxis()], steps * ROTATE_STEP_RAD);
+                manualQuatRef.current = turn.multiply(manualQuatRef.current);
+                triggerSFX('sfx:item-rotate');
+                recompute();
+            }
+            else if (key === 'Alt' && !e.repeat) {
+                e.preventDefault();
+                e.stopPropagation();
+                cycleRotationAxis();
+            }
+        };
+        emitter.on('grid:move', onMove);
+        emitter.on('grid:click', onClick);
+        window.addEventListener('keydown', onKeyDown, true);
+        return () => {
+            emitter.off('grid:move', onMove);
+            emitter.off('grid:click', onClick);
+            window.removeEventListener('keydown', onKeyDown, true);
+        };
+    }, [activeLevelId, previewNode]);
+    if (!activeLevelId || !placement)
+        return null;
+    return (_jsxs(LevelOffsetGroup, { children: [_jsx(CursorSphere, { position: placement.position }), _jsx("group", { position: placement.position, rotation: placement.rotation, children: _jsx("primitive", { object: ghost }) }), _jsx(Html, { center: true, position: [placement.position[0], placement.position[1] + 1.45, placement.position[2]], style: { pointerEvents: 'none', userSelect: 'none' }, zIndexRange: [100, 0], children: _jsxs("div", { className: "flex items-center gap-2 whitespace-nowrap rounded-full border border-border/60 bg-background/90 px-4 py-1.5 text-xs tabular-nums shadow-sm backdrop-blur", children: [_jsxs("span", { className: "font-medium text-foreground", children: ["Axis ", axis.toUpperCase()] }), _jsx("span", { "aria-hidden": true, className: "text-muted-foreground", children: "\u00B7" }), _jsx("span", { className: "text-muted-foreground", children: "R/T rotate" }), _jsx("span", { "aria-hidden": true, className: "text-muted-foreground", children: "\u00B7" }), _jsx("span", { className: "text-muted-foreground", children: "\u2325 axis" })] }) }), placement.snapPort && (_jsxs("mesh", { layers: EDITOR_LAYER, position: placement.snapPort.position, children: [_jsx("sphereGeometry", { args: [0.18, 24, 16] }), _jsx("meshBasicMaterial", { color: "#818cf8", depthTest: false, opacity: 0.35, transparent: true })] }))] }));
+};
+export default PipeFittingTool;

package/dist/pipe-segment/definition.d.ts

@@ -0,0 +1,14 @@
+import type { NodeDefinition } from '@pascal-app/core';
+import { PipeSegmentNode } from './schema';
+/**
+ * Phase 4 of the distribution-system effort (the research doc's Phase 2)
+ * — DWV plumbing's first kind: the pipe run. The plumbing sibling of
+ * `duct-segment`: same polyline + typed-ports model, with SLOPE as the
+ * new ingredient (the draw tool drops waste runs ¼"/ft; vents run level
+ * or vertical).
+ *
+ * Deferred to later slices: DWV fittings (wye / sanitary tee / closet
+ * bend), fixtures, traps, cleanouts, IPC validators, riser view.
+ */
+export declare const pipeSegmentDefinition: NodeDefinition<typeof PipeSegmentNode>;
+//# sourceMappingURL=definition.d.ts.map

package/dist/pipe-segment/definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAKtD,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE1C;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC,OAAO,eAAe,CAmHxE,CAAA"}

package/dist/pipe-segment/definition.js

@@ -0,0 +1,116 @@
+import { createPathPointMoveAffordance } from '../shared/path-point-affordance';
+import { buildPipeSegmentFloorplan } from './floorplan';
+import { buildPipeSegmentGeometry } from './geometry';
+import { pipeSegmentParametrics } from './parametrics';
+import { PipeSegmentNode } from './schema';
+/**
+ * Phase 4 of the distribution-system effort (the research doc's Phase 2)
+ * — DWV plumbing's first kind: the pipe run. The plumbing sibling of
+ * `duct-segment`: same polyline + typed-ports model, with SLOPE as the
+ * new ingredient (the draw tool drops waste runs ¼"/ft; vents run level
+ * or vertical).
+ *
+ * Deferred to later slices: DWV fittings (wye / sanitary tee / closet
+ * bend), fixtures, traps, cleanouts, IPC validators, riser view.
+ */
+export const pipeSegmentDefinition = {
+    kind: 'pipe-segment',
+    schemaVersion: 1,
+    schema: PipeSegmentNode,
+    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],
+            [3, -0.0625, 0],
+        ],
+        diameter: 2,
+        pipeMaterial: 'pvc',
+        system: 'waste',
+    }),
+    capabilities: {
+        selectable: { hitVolume: 'bbox' },
+        duplicable: true,
+        deletable: true,
+    },
+    parametrics: pipeSegmentParametrics,
+    geometry: buildPipeSegmentGeometry,
+    geometryKey: (n) => JSON.stringify([n.path, n.diameter, n.pipeMaterial, n.system]),
+    // Open run ends as typed ports — system 'waste'/'vent' keeps the DWV
+    // network invisible to duct / refrigerant tools and vice versa.
+    ports: (n) => {
+        if (n.path.length < 2)
+            return [];
+        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: n.diameter,
+                system: n.system,
+            },
+            {
+                id: 'end',
+                position: last,
+                direction: unit(last, prev),
+                diameter: n.diameter,
+                system: n.system,
+            },
+        ];
+    },
+    floorplan: buildPipeSegmentFloorplan,
+    // 2D selection-time path-point handles — the floor-plan twin of the 3D
+    // `affordanceTools.selection` handles. The builder emits an
+    // `endpoint-handle` per path vertex; this drags the matching point.
+    floorplanAffordances: {
+        'move-path-point': createPathPointMoveAffordance('pipe-segment'),
+    },
+    // Selection-time path-point handles (drag to edit a committed run).
+    // Editor-only UI (reads gridSnapStep, renders DimensionPill), so it
+    // mounts via the editor's SelectionAffordanceManager — not `def.system`,
+    // which the viewer package mounts for the read-only route.
+    affordanceTools: {
+        selection: () => import('./selection'),
+        // Ghost-preview duplicate / move (the plumbing sibling of duct-segment's
+        // mover). Duplicate is pure drag-to-place: a translucent copy of the run,
+        // wrapped in a footprint bounding box, follows the cursor and only lands
+        // on the commit click — nothing is inserted into the scene before that.
+        move: () => import('./move-tool'),
+    },
+    tool: () => import('./tool'),
+    toolHints: [
+        { key: 'Click', label: 'Start run' },
+        { key: 'Click again', label: 'Place it (waste falls ¼″/ft)' },
+        { key: 'Q', label: 'Waste / vent' },
+        { key: '[ / ]', label: 'Pipe size down / up' },
+        { key: 'Alt + drag', label: 'Vertical stack ↕, click to place' },
+        { key: 'Esc', label: 'Cancel start point' },
+    ],
+    presentation: {
+        label: 'DWV Pipe',
+        description: 'Drain / waste / vent pipe run — waste lines fall at ¼″ per foot, vents run level or vertical.',
+        icon: { kind: 'url', src: '/icons/dwv-pipes.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 95,
+    },
+    mcp: {
+        description: 'A DWV (drain-waste-vent) pipe run defined as a polyline. Waste runs slope downward (slope lives in the path Y coordinates); vents run level or vertical. Sized in nominal inches.',
+    },
+};

package/dist/pipe-segment/floorplan.d.ts

@@ -0,0 +1,9 @@
+import type { FloorplanGeometry, GeometryContext } from '@pascal-app/core';
+import type { PipeSegmentNode } from './schema';
+/**
+ * Floor-plan representation of a DWV run, following drafting convention:
+ * waste lines draw SOLID at the pipe's width, vent lines draw DASHED and
+ * thin. Vertical stacks collapse to a circle.
+ */
+export declare function buildPipeSegmentFloorplan(node: PipeSegmentNode, ctx: GeometryContext): FloorplanGeometry | null;
+//# sourceMappingURL=floorplan.d.ts.map

package/dist/pipe-segment/floorplan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAkB,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAE1F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAK/C;;;;GAIG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,eAAe,EACrB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAmF1B"}

package/dist/pipe-segment/floorplan.js

@@ -0,0 +1,87 @@
+import { INCHES_TO_METERS } from '../duct-segment/geometry';
+const WASTE_COLOR = '#57534e';
+const VENT_COLOR = '#78716c';
+/**
+ * Floor-plan representation of a DWV run, following drafting convention:
+ * waste lines draw SOLID at the pipe's width, vent lines draw DASHED and
+ * thin. Vertical stacks collapse to a circle.
+ */
+export function buildPipeSegmentFloorplan(node, ctx) {
+    if (node.path.length < 2)
+        return null;
+    const points = [];
+    // Plan point k ← original path index indexMap[k] (stacks 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 diameterM = node.diameter * INCHES_TO_METERS;
+    const view = ctx.viewState;
+    const palette = view?.palette;
+    const showSelectedChrome = (view?.selected || view?.highlighted) ?? false;
+    const isVent = node.system === 'vent';
+    const stroke = showSelectedChrome && palette ? palette.selectedStroke : isVent ? VENT_COLOR : WASTE_COLOR;
+    // Vertical stack — a single plan point: hub circle.
+    if (points.length < 2) {
+        const p = points[0] ?? [node.path[0][0], node.path[0][2]];
+        return {
+            kind: 'group',
+            children: [
+                {
+                    kind: 'circle',
+                    cx: p[0],
+                    cy: p[1],
+                    r: diameterM / 2 + 0.01,
+                    fill: 'none',
+                    stroke,
+                    strokeWidth: 2,
+                    vectorEffect: 'non-scaling-stroke',
+                    opacity: 0.95,
+                },
+            ],
+        };
+    }
+    const children = [
+        isVent
+            ? {
+                kind: 'polyline',
+                points,
+                stroke,
+                strokeWidth: 1.5,
+                vectorEffect: 'non-scaling-stroke',
+                strokeDasharray: '6 4',
+                strokeLinecap: 'round',
+                strokeLinejoin: 'round',
+                opacity: 0.9,
+            }
+            : {
+                kind: 'polyline',
+                points,
+                stroke,
+                strokeWidth: diameterM,
+                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/pipe-segment/geometry.d.ts

@@ -0,0 +1,16 @@
+import { Group, MeshStandardMaterial } from 'three';
+import type { PipeSegmentNode } from './schema';
+type PipeAppearance = {
+    pipeMaterial: 'pvc' | 'abs' | 'cast-iron';
+    system: 'waste' | 'vent';
+};
+export declare function createPipeMaterial(node: PipeAppearance): MeshStandardMaterial;
+/**
+ * Pure geometry builder for a DWV pipe run: capped cylinder sections
+ * between consecutive path points with sphere hubs at interior joints
+ * (proper wyes / sanitary tees come in the next slice). Slope lives in
+ * the path's Y coordinates — nothing here is slope-aware.
+ */
+export declare function buildPipeSegmentGeometry(node: PipeSegmentNode): Group;
+export {};
+//# sourceMappingURL=geometry.d.ts.map

package/dist/pipe-segment/geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAQ,oBAAoB,EAA2B,MAAM,OAAO,CAAA;AAElF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAW/C,KAAK,cAAc,GAAG;IACpB,YAAY,EAAE,KAAK,GAAG,KAAK,GAAG,WAAW,CAAA;IACzC,MAAM,EAAE,OAAO,GAAG,MAAM,CAAA;CACzB,CAAA;AAQD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,cAAc,GAAG,oBAAoB,CAQ7E;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,eAAe,GAAG,KAAK,CAuBrE"}

package/dist/pipe-segment/geometry.js

@@ -0,0 +1,54 @@
+import { Group, Mesh, MeshStandardMaterial, SphereGeometry, Vector3 } from 'three';
+import { buildSection, INCHES_TO_METERS } from '../duct-segment/geometry';
+const PVC_COLOR = '#f5f5f5';
+const ABS_COLOR = '#3a3a3a';
+const CAST_IRON_COLOR = '#54575c';
+/** Vents read slightly translucent-matte so they don't visually compete
+ *  with the water-carrying waste runs. */
+const VENT_OPACITY = 0.85;
+const RADIAL_SEGMENTS = 20;
+function getPipeColor(node) {
+    if (node.pipeMaterial === 'abs')
+        return ABS_COLOR;
+    if (node.pipeMaterial === 'cast-iron')
+        return CAST_IRON_COLOR;
+    return PVC_COLOR;
+}
+export function createPipeMaterial(node) {
+    return new MeshStandardMaterial({
+        color: getPipeColor(node),
+        metalness: node.pipeMaterial === 'cast-iron' ? 0.5 : 0.05,
+        roughness: node.pipeMaterial === 'cast-iron' ? 0.6 : 0.45,
+        transparent: node.system === 'vent',
+        opacity: node.system === 'vent' ? VENT_OPACITY : 1,
+    });
+}
+/**
+ * Pure geometry builder for a DWV pipe run: capped cylinder sections
+ * between consecutive path points with sphere hubs at interior joints
+ * (proper wyes / sanitary tees come in the next slice). Slope lives in
+ * the path's Y coordinates — nothing here is slope-aware.
+ */
+export function buildPipeSegmentGeometry(node) {
+    const group = new Group();
+    if (node.path.length < 2)
+        return group;
+    const radius = (node.diameter * INCHES_TO_METERS) / 2;
+    const material = createPipeMaterial(node);
+    const points = node.path.map(([x, y, z]) => new Vector3(x, y, z));
+    for (let i = 0; i < points.length - 1; i++) {
+        const a = points[i];
+        const b = points[i + 1];
+        const mesh = buildSection(a, b, radius, material, `pipe-section-${i}`);
+        if (mesh)
+            group.add(mesh);
+    }
+    // Slightly proud hubs at interior joints — reads as a coupling.
+    for (let i = 1; i < points.length - 1; i++) {
+        const hub = new Mesh(new SphereGeometry(radius * 1.12, RADIAL_SEGMENTS, 12), material);
+        hub.name = `pipe-hub-${i}`;
+        hub.position.copy(points[i]);
+        group.add(hub);
+    }
+    return group;
+}

package/dist/pipe-segment/index.d.ts

@@ -0,0 +1,4 @@
+export { pipeSegmentDefinition } from './definition';
+export { buildPipeSegmentGeometry } from './geometry';
+export { PipeSegmentNode } from './schema';
+//# sourceMappingURL=index.d.ts.map

package/dist/pipe-segment/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAA;AACpD,OAAO,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAA;AACrD,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA"}

package/dist/pipe-segment/index.js

@@ -0,0 +1,3 @@
+export { pipeSegmentDefinition } from './definition';
+export { buildPipeSegmentGeometry } from './geometry';
+export { PipeSegmentNode } from './schema';

package/dist/pipe-segment/move-tool.d.ts

@@ -0,0 +1,25 @@
+import { type AnyNode } from '@pascal-app/core';
+/**
+ * Ghost-preview duplicate / move tool for DWV pipe runs — the plumbing
+ * sibling of `MoveDuctSegmentTool`. Pipes are always round, so the ghost
+ * is a translucent cylinder per section (no rect branch).
+ *
+ * **Duplicate** (`metadata.isNew`): pure drag-to-place — NOTHING is
+ * inserted into the scene until the commit click. A translucent ghost of
+ * the run rides the cursor inside a footprint bounding box — the same
+ * affordance other items get — and Figma-style alignment guides snap the
+ * box's edges to nearby geometry. The next grid click calls `createNode`;
+ * Esc discards. The run's Y coords (slope) ride along untouched: the move
+ * only shifts XZ.
+ *
+ * **Move** (existing run): the real node's mesh is hidden while the same
+ * ghost + box tracks the cursor; the commit click writes the translated
+ * `path` and reveals it, Esc reveals it unchanged.
+ *
+ * Wired via `def.affordanceTools.move`.
+ */
+export declare const MovePipeSegmentTool: React.FC<{
+    node: AnyNode;
+}>;
+export default MovePipeSegmentTool;
+//# sourceMappingURL=move-tool.d.ts.map

package/dist/pipe-segment/move-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/pipe-segment/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,OAAO,EAOb,MAAM,kBAAkB,CAAA;AAoEzB;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,mBAAmB,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CAqM3D,CAAA;AAiCD,eAAe,mBAAmB,CAAA"}