@pascal-app/nodes 0.1.1

package/dist/level/system.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../src/level/system.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAEhD,eAAe,WAAW,CAAA"}

package/dist/level/system.js

@@ -0,0 +1,3 @@
+'use client';
+import { LevelSystem } from '@pascal-app/viewer';
+export default LevelSystem;

package/dist/lineset/definition.d.ts

@@ -0,0 +1,15 @@
+import type { NodeDefinition } from '@pascal-app/core';
+import { LinesetNode } from './schema';
+/**
+ * Refrigerant lineset — the copper suction + liquid pair joining a split
+ * system's outdoor condenser to its indoor coil. The refrigerant-side
+ * sibling of `duct-segment`: same polyline model and draw tool, but it
+ * snaps onto refrigerant service ports instead of duct collars.
+ *
+ * Composition: `def.geometry` only, plus a selection-time path-handle
+ * system shared in spirit with the duct segment. The framework's
+ * `<ParametricNodeRenderer>` mounts an empty group; `<GeometrySystem>`
+ * fills it via `buildLinesetGeometry` on dirty.
+ */
+export declare const linesetDefinition: NodeDefinition<typeof LinesetNode>;
+//# sourceMappingURL=definition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/lineset/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAKtD,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAEtC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB,EAAE,cAAc,CAAC,OAAO,WAAW,CAoHhE,CAAA"}

package/dist/lineset/definition.js

@@ -0,0 +1,118 @@
+import { createPathPointMoveAffordance } from '../shared/path-point-affordance';
+import { buildLinesetFloorplan } from './floorplan';
+import { buildLinesetGeometry } from './geometry';
+import { linesetParametrics } from './parametrics';
+import { LinesetNode } from './schema';
+/**
+ * Refrigerant lineset — the copper suction + liquid pair joining a split
+ * system's outdoor condenser to its indoor coil. The refrigerant-side
+ * sibling of `duct-segment`: same polyline model and draw tool, but it
+ * snaps onto refrigerant service ports instead of duct collars.
+ *
+ * Composition: `def.geometry` only, plus a selection-time path-handle
+ * system shared in spirit with the duct segment. The framework's
+ * `<ParametricNodeRenderer>` mounts an empty group; `<GeometrySystem>`
+ * fills it via `buildLinesetGeometry` on dirty.
+ */
+export const linesetDefinition = {
+    kind: 'lineset',
+    schemaVersion: 1,
+    schema: LinesetNode,
+    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],
+        ],
+        suctionDiameter: 0.875,
+        liquidDiameter: 0.375,
+        insulated: true,
+    }),
+    capabilities: {
+        selectable: { hitVolume: 'bbox' },
+        duplicable: true,
+        deletable: true,
+    },
+    parametrics: linesetParametrics,
+    geometry: buildLinesetGeometry,
+    geometryKey: (n) => JSON.stringify([n.path, n.suctionDiameter, n.liquidDiameter, n.insulated]),
+    // 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.suctionDiameter;
+        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: buildLinesetFloorplan,
+    // 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('lineset'),
+    },
+    // 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 refrigerant-loop 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 lineset' },
+        { key: 'Click again', label: 'Place it (locked to 45°)' },
+        { key: 'Alt + drag', label: 'Go vertical ↕, click to place' },
+        { key: 'Esc', label: 'Cancel start point' },
+    ],
+    presentation: {
+        label: 'Lineset',
+        description: 'Refrigerant lineset — copper suction + liquid pair joining a condenser to the indoor coil.',
+        icon: { kind: 'url', src: '/icons/lineset.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 93,
+    },
+    mcp: {
+        description: 'A refrigerant lineset defined as a polyline: an insulated suction line plus a bare liquid line, joining an HVAC condenser to its indoor coil. Snaps onto refrigerant service ports.',
+    },
+};

package/dist/lineset/floorplan.d.ts

@@ -0,0 +1,10 @@
+import type { FloorplanGeometry, GeometryContext } from '@pascal-app/core';
+import type { LinesetNode } from './schema';
+/**
+ * Floor-plan representation of a lineset: the path drawn at the suction
+ * jacket's real width with a dashed copper centerline. 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 buildLinesetFloorplan(node: LinesetNode, ctx: GeometryContext): FloorplanGeometry | null;
+//# sourceMappingURL=floorplan.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/lineset/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAkB,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAE1F,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAK3C;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,WAAW,EACjB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAwE1B"}

package/dist/lineset/floorplan.js

@@ -0,0 +1,78 @@
+import { INCHES_TO_METERS } from '../duct-segment/geometry';
+const COPPER_LINE = '#b06b3f';
+const BODY_COLOR = '#9ca3af';
+/**
+ * Floor-plan representation of a lineset: the path drawn at the suction
+ * jacket's real width with a dashed copper centerline. Vertical risers
+ * collapse to a point in plan; consecutive duplicate plan points are
+ * dropped so they don't render zero-length artifacts.
+ */
+export function buildLinesetFloorplan(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 = Math.max(node.suctionDiameter, node.liquidDiameter) * 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: widthM,
+            fill: BODY_COLOR,
+            stroke: showSelectedChrome && palette ? palette.selectedStroke : COPPER_LINE,
+            strokeWidth: 0.02,
+            opacity: 0.9,
+        };
+    }
+    const children = [
+        {
+            kind: 'polyline',
+            points,
+            stroke: showSelectedChrome && palette ? palette.selectedStroke : BODY_COLOR,
+            strokeWidth: widthM * 2,
+            strokeLinecap: 'round',
+            strokeLinejoin: 'round',
+            opacity: showSelectedChrome ? 0.95 : 0.8,
+        },
+        {
+            kind: 'polyline',
+            points,
+            stroke: COPPER_LINE,
+            strokeWidth: 1.5,
+            vectorEffect: 'non-scaling-stroke',
+            strokeDasharray: '4 3',
+            strokeLinecap: 'round',
+            strokeLinejoin: 'round',
+            opacity: 0.9,
+        },
+    ];
+    // 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/lineset/geometry.d.ts

@@ -0,0 +1,20 @@
+import { Group } from 'three';
+import type { LinesetNode } from './schema';
+/**
+ * Pure geometry builder for a refrigerant lineset: a single copper line that
+ * follows the node path centerline, optionally wrapped in a foam jacket.
+ *
+ * One line per node — what the ghost previews is exactly what commits. To run
+ * the suction line beside the liquid line, draw them as two separate linesets
+ * rather than rendering both together off one path.
+ *
+ * Each line is a standalone two-point node (no fitting system, unlike ducts),
+ * so a sphere caps BOTH endpoints. On a free end it just 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 buildLinesetGeometry(node: LinesetNode): Group;
+//# sourceMappingURL=geometry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/lineset/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,KAAK,EAAuD,MAAM,OAAO,CAAA;AAEpG,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAwC3C;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,WAAW,GAAG,KAAK,CAoD7D"}

package/dist/lineset/geometry.js

@@ -0,0 +1,87 @@
+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';
+// Light foam sleeve. Real Armaflex is black, but a light jacket reads
+// cleaner against the scene and matches the white pipe materials.
+const INSULATION_COLOR = '#e8e8ea';
+const UP = new Vector3(0, 1, 0);
+/**
+ * Foam-jacket thickness (meters) wrapped around the line when `insulated`. A
+ * real ~3/4" black Armaflex sleeve adds ~3/8" of wall; this matches that so an
+ * insulated line reads visibly fatter than the bare copper underneath.
+ */
+const INSULATION_THICKNESS_M = 0.01;
+/** 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 refrigerant lineset: a single copper line that
+ * follows the node path centerline, optionally wrapped in a foam jacket.
+ *
+ * One line per node — what the ghost previews is exactly what commits. To run
+ * the suction line beside the liquid line, draw them as two separate linesets
+ * rather than rendering both together off one path.
+ *
+ * Each line is a standalone two-point node (no fitting system, unlike ducts),
+ * so a sphere caps BOTH endpoints. On a free end it just 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 buildLinesetGeometry(node) {
+    const group = new Group();
+    if (node.path.length < 2)
+        return group;
+    const copperR = (node.suctionDiameter * INCHES_TO_METERS) / 2;
+    const jacketR = node.insulated ? copperR + INSULATION_THICKNESS_M : copperR;
+    const copperMat = new MeshStandardMaterial({
+        color: COPPER_COLOR,
+        metalness: 0.8,
+        roughness: 0.3,
+    });
+    const insulationMat = new MeshStandardMaterial({
+        color: INSULATION_COLOR,
+        metalness: 0.1,
+        roughness: 0.9,
+    });
+    const points = node.path.map(([x, y, z]) => new Vector3(x, y, z));
+    for (let i = 0; i < points.length - 1; i++) {
+        const copper = buildRun(points[i], points[i + 1], copperR, copperMat, `lineset-copper-${i}`);
+        if (copper)
+            group.add(copper);
+        if (node.insulated) {
+            const jacket = buildRun(points[i], points[i + 1], jacketR, insulationMat, `lineset-jacket-${i}`);
+            if (jacket)
+                group.add(jacket);
+        }
+    }
+    // Spherical caps at every point. Interior corners read as continuous pipe;
+    // endpoint caps round the open ends and, where two separate segments share a
+    // coordinate, the coincident spheres fill the miter so the turn looks welded.
+    for (let i = 0; i < points.length; i++) {
+        const joint = new Mesh(new SphereGeometry(copperR, RADIAL_SEGMENTS, 10), copperMat);
+        joint.name = `lineset-copper-joint-${i}`;
+        joint.position.copy(points[i]);
+        group.add(joint);
+        if (node.insulated) {
+            const jJoint = new Mesh(new SphereGeometry(jacketR, RADIAL_SEGMENTS, 10), insulationMat);
+            jJoint.name = `lineset-jacket-joint-${i}`;
+            jJoint.position.copy(points[i]);
+            group.add(jJoint);
+        }
+    }
+    return group;
+}

package/dist/lineset/index.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/lineset/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAChD,OAAO,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAA;AACjD,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA"}

package/dist/lineset/index.js

@@ -0,0 +1,3 @@
+export { linesetDefinition } from './definition';
+export { buildLinesetGeometry } from './geometry';
+export { LinesetNode } from './schema';

package/dist/lineset/move-tool.d.ts

@@ -0,0 +1,27 @@
+import { type AnyNode } from '@pascal-app/core';
+/**
+ * Ghost-preview duplicate / move tool for refrigerant linesets — the
+ * refrigerant-loop sibling of `MovePipeSegmentTool`. A lineset is a
+ * suction + liquid copper pair; the ghost stands in with a single
+ * translucent cylinder at the suction OD per section (mirrors the draw
+ * tool's `PreviewSegment`).
+ *
+ * **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 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 MoveLinesetTool: React.FC<{
+    node: AnyNode;
+}>;
+export default MoveLinesetTool;
+//# sourceMappingURL=move-tool.d.ts.map

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

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

package/dist/lineset/move-tool.js

@@ -0,0 +1,256 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { emitter, LinesetNode, sceneRegistry, useScene, } from '@pascal-app/core';
+import { DragBoundingBox, EDITOR_LAYER, isAlignmentGuideActive, isGridSnapActive, isMagneticSnapActive, markToolCancelConsumed, stripPlacementMetadataFlags, triggerSFX, useAlignmentGuides, useEditor, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { useEffect, useRef, useState } from 'react';
+import { Vector3 } from 'three';
+import { collectGhostAlignmentCandidates, resolveGhostAlignment, } from '../shared/ghost-alignment';
+import { startRunMoveConnectivity } from '../shared/run-move-connectivity';
+const GHOST_COLOR = '#818cf8';
+const GHOST_OPACITY = 0.5;
+const IN_TO_M = 0.0254;
+/** Snap a coordinate to the editor's live grid step. */
+function snapToGridStep(value) {
+    const step = useEditor.getState().gridSnapStep;
+    if (step <= 0)
+        return value;
+    return Math.round(value / step) * step;
+}
+function pathCenterXZ(path) {
+    let x = 0;
+    let z = 0;
+    for (const p of path) {
+        x += p[0];
+        z += p[2];
+    }
+    const n = path.length || 1;
+    return [x / n, z / n];
+}
+/** The lineset's footprint radius (meters) — half the suction OD (the
+ *  bigger of the pair), used as box / footprint padding and ghost radius. */
+function linesetRadiusM(lineset) {
+    return (lineset.suctionDiameter * IN_TO_M) / 2;
+}
+/** XZ bounds of a path padded by the lineset's radius. */
+function pathAabb(path, r) {
+    let minX = Number.POSITIVE_INFINITY;
+    let maxX = Number.NEGATIVE_INFINITY;
+    let minZ = Number.POSITIVE_INFINITY;
+    let maxZ = Number.NEGATIVE_INFINITY;
+    for (const p of path) {
+        if (p[0] < minX)
+            minX = p[0];
+        if (p[0] > maxX)
+            maxX = p[0];
+        if (p[2] < minZ)
+            minZ = p[2];
+        if (p[2] > maxZ)
+            maxZ = p[2];
+    }
+    return { minX: minX - r, maxX: maxX + r, minZ: minZ - r, maxZ: maxZ + r };
+}
+/**
+ * Ghost-preview duplicate / move tool for refrigerant linesets — the
+ * refrigerant-loop sibling of `MovePipeSegmentTool`. A lineset is a
+ * suction + liquid copper pair; the ghost stands in with a single
+ * translucent cylinder at the suction OD per section (mirrors the draw
+ * tool's `PreviewSegment`).
+ *
+ * **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 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 const MoveLinesetTool = ({ node }) => {
+    const lineset = node;
+    const originalPathRef = useRef(lineset.path.map((p) => [...p]));
+    const isNew = typeof node.metadata === 'object' &&
+        node.metadata !== null &&
+        !Array.isArray(node.metadata) &&
+        node.metadata.isNew === true;
+    const [previewPath, setPreviewPath] = useState(originalPathRef.current);
+    const previewPathRef = useRef(originalPathRef.current);
+    const hasMovedRef = useRef(false);
+    const activatedAtRef = useRef(Date.now());
+    const prevSnapRef = useRef(null);
+    useEffect(() => {
+        const nodeId = node.id;
+        const originalPath = originalPathRef.current;
+        const [centerX, centerZ] = pathCenterXZ(originalPath);
+        const r = linesetRadiusM(lineset);
+        const baseAabb = pathAabb(originalPath, r);
+        useScene.temporal.getState().pause();
+        let committed = false;
+        const candidates = collectGhostAlignmentCandidates(useScene.getState().nodes, nodeId, useViewer.getState().selection.levelId ?? node.parentId);
+        // Moving an existing run: hide its 3D MESH imperatively (NOT the store
+        // `visible` flag — the 2D floor plan skips `visible:false` nodes, so a
+        // store hide makes the run vanish in 2D / split view). The ghost stands
+        // in until commit; the real mesh is restored on cancel / unmount.
+        const existedAtStart = !isNew && !!useScene.getState().nodes[nodeId];
+        const setMeshHidden = (hidden) => {
+            const obj = sceneRegistry.nodes.get(nodeId);
+            if (obj)
+                obj.visible = !hidden;
+        };
+        if (existedAtStart)
+            setMeshHidden(true);
+        // Carry connected fittings (+ their other runs) as the whole run slides.
+        // Snapshot once at drag start; only existing runs are mated to anything.
+        const connectivity = existedAtStart
+            ? startRunMoveConnectivity(node)
+            : null;
+        const setPreview = (path) => {
+            previewPathRef.current = path;
+            setPreviewPath(path);
+        };
+        const onMove = (event) => {
+            const snap = isGridSnapActive() ? snapToGridStep : (v) => v;
+            let dx = snap(event.localPosition[0] - centerX);
+            let dz = snap(event.localPosition[2] - centerZ);
+            // Figma-style magnetic alignment: snap the run's footprint box edges onto
+            // nearby geometry and publish the guides. Grid follows the snapping mode;
+            // lines follow magnetic alignment — the two are independent.
+            if (isAlignmentGuideActive()) {
+                const proposed = {
+                    minX: baseAabb.minX + dx,
+                    maxX: baseAabb.maxX + dx,
+                    minZ: baseAabb.minZ + dz,
+                    maxZ: baseAabb.maxZ + dz,
+                };
+                const { dx: sdx, dz: sdz, guides } = resolveGhostAlignment(nodeId, proposed, candidates);
+                if (isMagneticSnapActive()) {
+                    dx += sdx;
+                    dz += sdz;
+                }
+                useAlignmentGuides.getState().set(guides);
+            }
+            else {
+                useAlignmentGuides.getState().clear();
+            }
+            const cur = [centerX + dx, centerZ + dz];
+            if ((isGridSnapActive() || isMagneticSnapActive()) &&
+                (!prevSnapRef.current ||
+                    prevSnapRef.current[0] !== cur[0] ||
+                    prevSnapRef.current[1] !== cur[1])) {
+                triggerSFX('sfx:grid-snap');
+            }
+            prevSnapRef.current = cur;
+            hasMovedRef.current = true;
+            const nextPath = originalPath.map(([x, y, z]) => [x + dx, y, z + dz]);
+            setPreview(nextPath);
+            connectivity?.preview({ path: nextPath });
+        };
+        const commit = (event) => {
+            if (committed)
+                return;
+            if (Date.now() - activatedAtRef.current < 150) {
+                event.nativeEvent?.stopPropagation?.();
+                return;
+            }
+            if (!hasMovedRef.current) {
+                event.nativeEvent?.stopPropagation?.();
+                return;
+            }
+            committed = true;
+            const finalPath = previewPathRef.current;
+            useScene.temporal.getState().resume();
+            let selectId = nodeId;
+            if (isNew && !useScene.getState().nodes[nodeId]) {
+                const created = LinesetNode.parse({
+                    ...node,
+                    path: finalPath,
+                    metadata: stripPlacementMetadataFlags(node.metadata),
+                    visible: true,
+                });
+                useScene.getState().createNode(created, node.parentId);
+                selectId = created.id;
+            }
+            else {
+                // Fold connected-fitting / sibling-run follow-updates into the SAME
+                // batch as the moved run so the whole joint is one undo step.
+                const followUpdates = connectivity?.commitUpdates({ path: finalPath }) ?? [];
+                useScene
+                    .getState()
+                    .updateNodes([
+                    { id: nodeId, data: { path: finalPath } },
+                    ...followUpdates,
+                ]);
+                useScene.getState().markDirty(nodeId);
+            }
+            useScene.temporal.getState().pause();
+            // Followers are committed to the store — drop their live overrides so
+            // renderers read the canonical path/position.
+            connectivity?.clear();
+            setMeshHidden(false);
+            useAlignmentGuides.getState().clear();
+            triggerSFX('sfx:item-place');
+            useViewer.getState().setSelection({ selectedIds: [selectId] });
+            useEditor.getState().setMovingNodeOrigin('3d');
+            useEditor.getState().setMovingNode(null);
+            event.nativeEvent?.stopPropagation?.();
+        };
+        const onCancel = () => {
+            connectivity?.clear();
+            if (existedAtStart) {
+                setMeshHidden(false);
+                useViewer.getState().setSelection({ selectedIds: [nodeId] });
+            }
+            useAlignmentGuides.getState().clear();
+            useScene.temporal.getState().resume();
+            markToolCancelConsumed();
+            useEditor.getState().setMovingNodeOrigin('3d');
+            useEditor.getState().setMovingNode(null);
+        };
+        emitter.on('grid:move', onMove);
+        emitter.on('grid:click', commit);
+        emitter.on('tool:cancel', onCancel);
+        return () => {
+            emitter.off('grid:move', onMove);
+            emitter.off('grid:click', commit);
+            emitter.off('tool:cancel', onCancel);
+            connectivity?.clear();
+            useAlignmentGuides.getState().clear();
+            if (existedAtStart)
+                setMeshHidden(false);
+            useScene.temporal.getState().resume();
+        };
+    }, [lineset, isNew, node]);
+    const segments = [];
+    for (let i = 0; i < previewPath.length - 1; i++) {
+        segments.push({ a: previewPath[i], b: previewPath[i + 1] });
+    }
+    // Footprint box spanning the whole run (axis-aligned), drawn around the
+    // ghost the same way items get one. Recomputed from the live preview path.
+    const r = linesetRadiusM(lineset);
+    const box = pathAabb(previewPath, r);
+    const boxY = previewPath[0]?.[1] ?? 0;
+    return (_jsxs("group", { children: [segments.map((seg, i) => (_jsx(GhostSegment, { a: seg.a, b: seg.b, radius: r }, `ghost-${i}`))), _jsx(DragBoundingBox, { centerY: 0, nodeId: node.id, position: [(box.minX + box.maxX) / 2, boxY, (box.minZ + box.maxZ) / 2], size: [box.maxX - box.minX, lineset.suctionDiameter * IN_TO_M, box.maxZ - box.minZ] })] }));
+};
+/** Translucent stand-in for one lineset section — mirrors the draw tool's
+ *  `PreviewSegment` so the ghost matches what actually lands. */
+function GhostSegment({ a, b, radius }) {
+    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: [radius, radius, length, 16, 1, false] }), _jsx("meshBasicMaterial", { color: GHOST_COLOR, depthTest: false, opacity: GHOST_OPACITY, transparent: true })] }));
+}
+export default MoveLinesetTool;

package/dist/lineset/parametrics.d.ts

@@ -0,0 +1,4 @@
+import type { ParametricDescriptor } from '@pascal-app/core';
+import type { LinesetNode } from './schema';
+export declare const linesetParametrics: ParametricDescriptor<LinesetNode>;
+//# sourceMappingURL=parametrics.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/lineset/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAC5D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAE3C,eAAO,MAAM,kBAAkB,EAAE,oBAAoB,CAAC,WAAW,CAiChE,CAAA"}